From 02a9a126e3c0dec7e6e2a60e1463f30bd24edfc3 Mon Sep 17 00:00:00 2001
From: Evgeny Fadeev <evgeny.fadeev@gmail.com>
Date: Mon, 10 Jan 2011 03:47:20 -0500
Subject: some refactoring and removal of dead code

---
 askbot/auth.py                                     |  96 ++---
 askbot/const/__init__.py                           |   2 +
 askbot/models/__init__.py                          |  24 +-
 .../skins/default/templates/blocks/input_bar.html  |   6 +-
 .../default/templates/user_profile/user_info.html  |   2 +-
 askbot/templatetags/extra_filters.py               |  16 -
 askbot/templatetags/extra_filters_jinja.py         |  16 -
 askbot/templatetags/smart_if.py                    | 401 ---------------------
 askbot/urls.py                                     |   1 -
 askbot/views/readers.py                            |  26 +-
 askbot/views/users.py                              |   4 +-
 11 files changed, 60 insertions(+), 534 deletions(-)
 delete mode 100644 askbot/templatetags/smart_if.py

diff --git a/askbot/auth.py b/askbot/auth.py
index bfa55a22..6b12f08d 100644
--- a/askbot/auth.py
+++ b/askbot/auth.py
@@ -14,29 +14,9 @@ from askbot.models import Answer
 from askbot.models import signals
 from askbot.conf import settings as askbot_settings
 
-# user preferences view permissions
-def is_user_self(request_user, target_user):
-    return (request_user.is_authenticated() and request_user == target_user)
-    
-def can_view_user_votes(request_user, target_user):
-    return (request_user.is_authenticated() and request_user == target_user)
-
-def can_view_user_preferences(request_user, target_user):
-    return (request_user.is_authenticated() and request_user == target_user)
-
-def can_view_user_edit(request_user, target_user):
-    return (request_user.is_authenticated() and request_user == target_user)
-
 ###########################################
 ## actions and reputation changes event
 ###########################################
-def calculate_reputation(origin, offset):
-    result = int(origin) + int(offset)
-    if (result > 0):
-        return result
-    else:
-        return 1
-
 @transaction.commit_on_success
 def onFlaggedItem(post, user, timestamp=None):
     if timestamp is None:
@@ -45,10 +25,9 @@ def onFlaggedItem(post, user, timestamp=None):
     post.offensive_flag_count = post.offensive_flag_count + 1
     post.save()
 
-    post.author.reputation = calculate_reputation(
-                                post.author.reputation,
-                                askbot_settings.REP_LOSS_FOR_RECEIVING_FLAG
-                            )
+    post.author.receive_reputation(
+        askbot_settings.REP_LOSS_FOR_RECEIVING_FLAG
+    )
     post.author.save()
 
     question = post.get_origin_post()
@@ -71,11 +50,9 @@ def onFlaggedItem(post, user, timestamp=None):
 
     #todo: These should be updated to work on same revisions.
     if post.offensive_flag_count ==  askbot_settings.MIN_FLAGS_TO_HIDE_POST:
-        post.author.reputation = \
-            calculate_reputation(
-                post.author.reputation,
-                askbot_settings.REP_LOSS_FOR_RECEIVING_THREE_FLAGS_PER_REVISION
-            )
+        post.author.receive_reputation(
+            askbot_settings.REP_LOSS_FOR_RECEIVING_THREE_FLAGS_PER_REVISION
+        )
 
         post.author.save()
 
@@ -91,11 +68,9 @@ def onFlaggedItem(post, user, timestamp=None):
         reputation.save()
 
     elif post.offensive_flag_count == askbot_settings.MIN_FLAGS_TO_DELETE_POST:
-        post.author.reputation = \
-            calculate_reputation(
-                post.author.reputation,
-                askbot_settings.REP_LOSS_FOR_RECEIVING_FIVE_FLAGS_PER_REVISION
-            )
+        post.author.receive_reputation(
+            askbot_settings.REP_LOSS_FOR_RECEIVING_FIVE_FLAGS_PER_REVISION
+        )
 
         post.author.save()
 
@@ -123,10 +98,9 @@ def onAnswerAccept(answer, user, timestamp=None):
     answer.save()
     answer.question.save()
 
-    answer.author.reputation = calculate_reputation(
-                        answer.author.reputation,
-                        askbot_settings.REP_GAIN_FOR_RECEIVING_ANSWER_ACCEPTANCE
-                    )
+    answer.author.receive_reputation(
+        askbot_settings.REP_GAIN_FOR_RECEIVING_ANSWER_ACCEPTANCE
+    )
     answer.author.save()
     reputation = Repute(user=answer.author,
                positive=askbot_settings.REP_GAIN_FOR_RECEIVING_ANSWER_ACCEPTANCE,
@@ -136,8 +110,7 @@ def onAnswerAccept(answer, user, timestamp=None):
                reputation=answer.author.reputation)
     reputation.save()
 
-    user.reputation = calculate_reputation(user.reputation,
-                            askbot_settings.REP_GAIN_FOR_ACCEPTING_ANSWER)
+    user.receive_reputation(askbot_settings.REP_GAIN_FOR_ACCEPTING_ANSWER)
     user.save()
     reputation = Repute(user=user,
                positive=askbot_settings.REP_GAIN_FOR_ACCEPTING_ANSWER,
@@ -157,8 +130,7 @@ def onAnswerAcceptCanceled(answer, user, timestamp=None):
     answer.save()
     answer.question.save()
 
-    answer.author.reputation = calculate_reputation(
-        answer.author.reputation,
+    answer.author.receive_reputation(
         askbot_settings.REP_LOSS_FOR_RECEIVING_CANCELATION_OF_ANSWER_ACCEPTANCE
     )
     answer.author.save()
@@ -173,8 +145,9 @@ def onAnswerAcceptCanceled(answer, user, timestamp=None):
     )
     reputation.save()
 
-    user.reputation = calculate_reputation(user.reputation,
-                    askbot_settings.REP_LOSS_FOR_CANCELING_ANSWER_ACCEPTANCE)
+    user.receive_reputation(
+        askbot_settings.REP_LOSS_FOR_CANCELING_ANSWER_ACCEPTANCE
+    )
     user.save()
     reputation = Repute(user=user,
                negative=askbot_settings.REP_LOSS_FOR_CANCELING_ANSWER_ACCEPTANCE,
@@ -198,8 +171,9 @@ def onUpVoted(vote, post, user, timestamp=None):
         author = post.author
         todays_rep_gain = Repute.objects.get_reputation_by_upvoted_today(author)
         if todays_rep_gain <  askbot_settings.MAX_REP_GAIN_PER_USER_PER_DAY:
-            author.reputation = calculate_reputation(author.reputation,
-                              askbot_settings.REP_GAIN_FOR_RECEIVING_UPVOTE)
+            author.receive_reputation(
+                askbot_settings.REP_GAIN_FOR_RECEIVING_UPVOTE
+            )
             author.save()
 
             question = post
@@ -228,11 +202,9 @@ def onUpVotedCanceled(vote, post, user, timestamp=None):
 
     if not post.wiki:
         author = post.author
-        author.reputation = \
-                calculate_reputation(
-                    author.reputation,
-                    askbot_settings.REP_LOSS_FOR_RECEIVING_UPVOTE_CANCELATION
-                )
+        author.receive_reputation(
+            askbot_settings.REP_LOSS_FOR_RECEIVING_UPVOTE_CANCELATION
+        )
         author.save()
 
         question = post
@@ -261,10 +233,7 @@ def onDownVoted(vote, post, user, timestamp=None):
 
     if not post.wiki:
         author = post.author
-        author.reputation = calculate_reputation(
-                                        author.reputation,
-                                        askbot_settings.REP_LOSS_FOR_DOWNVOTING
-                                    )
+        author.receive_reputation(askbot_settings.REP_LOSS_FOR_DOWNVOTING)
         author.save()
 
         question = post
@@ -279,10 +248,9 @@ def onDownVoted(vote, post, user, timestamp=None):
                    reputation=author.reputation)
         reputation.save()
 
-        user.reputation = calculate_reputation(
-                                user.reputation,
-                                askbot_settings.REP_LOSS_FOR_RECEIVING_DOWNVOTE
-                            )
+        user.receive_reputation(
+            askbot_settings.REP_LOSS_FOR_RECEIVING_DOWNVOTE
+        )
         user.save()
 
         reputation = Repute(user=user,
@@ -307,10 +275,9 @@ def onDownVotedCanceled(vote, post, user, timestamp=None):
 
     if not post.wiki:
         author = post.author
-        author.reputation = calculate_reputation(
-                author.reputation,
-                askbot_settings.REP_GAIN_FOR_RECEIVING_DOWNVOTE_CANCELATION
-            )
+        author.receive_reputation(
+            askbot_settings.REP_GAIN_FOR_RECEIVING_DOWNVOTE_CANCELATION
+        )
         author.save()
 
         question = post
@@ -327,8 +294,7 @@ def onDownVotedCanceled(vote, post, user, timestamp=None):
             )
         reputation.save()
 
-        user.reputation = calculate_reputation(user.reputation,
-                        askbot_settings.REP_GAIN_FOR_CANCELING_DOWNVOTE)
+        user.receive_reputation(askbot_settings.REP_GAIN_FOR_CANCELING_DOWNVOTE)
         user.save()
 
         reputation = Repute(user=user,
diff --git a/askbot/const/__init__.py b/askbot/const/__init__.py
index 693a7328..608cde43 100644
--- a/askbot/const/__init__.py
+++ b/askbot/const/__init__.py
@@ -249,6 +249,8 @@ BADGE_CSS_CLASSES = {
 }
 BADGE_DISPLAY_SYMBOL = '&#9679;'
 
+MIN_REPUTATION = 1
+
 
 #an exception import * because that file has only strings
 from askbot.const.message_keys import *
diff --git a/askbot/models/__init__.py b/askbot/models/__init__.py
index f357789c..ad709509 100644
--- a/askbot/models/__init__.py
+++ b/askbot/models/__init__.py
@@ -53,16 +53,20 @@ User.add_to_class(
 User.add_to_class('email_isvalid', models.BooleanField(default=False))
 User.add_to_class('email_key', models.CharField(max_length=32, null=True))
 #hardcoded initial reputaion of 1, no setting for this one
-User.add_to_class('reputation', models.PositiveIntegerField(default=1))
+User.add_to_class('reputation', 
+    models.PositiveIntegerField(default=const.MIN_REPUTATION)
+)
 User.add_to_class('gravatar', models.CharField(max_length=32))
 User.add_to_class('gold', models.SmallIntegerField(default=0))
 User.add_to_class('silver', models.SmallIntegerField(default=0))
 User.add_to_class('bronze', models.SmallIntegerField(default=0))
-User.add_to_class('questions_per_page',
-              models.SmallIntegerField(
-                            choices=const.QUESTIONS_PER_PAGE_USER_CHOICES,
-                            default=10)
-            )
+User.add_to_class(
+    'questions_per_page',
+    models.SmallIntegerField(
+        choices=const.QUESTIONS_PER_PAGE_USER_CHOICES,
+        default=10
+    )
+)
 User.add_to_class('last_seen',
                   models.DateTimeField(default=datetime.datetime.now))
 User.add_to_class('real_name', models.CharField(max_length=100, blank=True))
@@ -1528,6 +1532,13 @@ def user_clean_response_counts(user):
                 'seen response count wanted to go below zero form %s' % user.username
             )
 
+def user_receive_reputation(self, num_points):
+    new_points = self.reputation + num_points
+    if new_points > 0:
+        self.reputation = new_points
+    else:
+        self.reputation = const.MIN_REPUTATION
+
 User.add_to_class('is_username_taken',classmethod(user_is_username_taken))
 User.add_to_class(
             'get_q_sel_email_feed_frequency',
@@ -1546,6 +1557,7 @@ User.add_to_class('visit_question', user_visit_question)
 User.add_to_class('upvote', upvote)
 User.add_to_class('downvote', downvote)
 User.add_to_class('flag_post', flag_post)
+User.add_to_class('receive_reputation', user_receive_reputation)
 User.add_to_class('get_flags', user_get_flags)
 User.add_to_class('get_flag_count_posted_today', user_get_flag_count_posted_today)
 User.add_to_class('get_flags_for_post', user_get_flags_for_post)
diff --git a/askbot/skins/default/templates/blocks/input_bar.html b/askbot/skins/default/templates/blocks/input_bar.html
index a7be193e..bed97eb4 100644
--- a/askbot/skins/default/templates/blocks/input_bar.html
+++ b/askbot/skins/default/templates/blocks/input_bar.html
@@ -3,8 +3,10 @@
 <div id="searchBar">
     {# url action depends on which tab is active #}
     <form 
-        {% if active_tab == "tags" or active_tab == "users" %}
-            action="{% url search %}" 
+        {% if active_tab == "tags" %}
+            action="{% url tags %}" 
+        {% elif active_tab == "users" %}
+            action="{% url users %}" 
         {% else %}
             action="{% url questions %}" 
         {% endif %}
diff --git a/askbot/skins/default/templates/user_profile/user_info.html b/askbot/skins/default/templates/user_profile/user_info.html
index b3af02b1..e52eab64 100644
--- a/askbot/skins/default/templates/user_profile/user_info.html
+++ b/askbot/skins/default/templates/user_profile/user_info.html
@@ -14,7 +14,7 @@
         </td>
         <td width="360" style="vertical-align: top;">
             <table class="user-details">
-                {% if request.user|can_view_user_edit(view_user) %}
+                {% if request.user == view_user %}
                 <tr>
                     <td class="user-profile-tool-links" align="left" colspan="2">
                         {% if request.user == view_user %}
diff --git a/askbot/templatetags/extra_filters.py b/askbot/templatetags/extra_filters.py
index 2f0ab078..27ba5fd2 100644
--- a/askbot/templatetags/extra_filters.py
+++ b/askbot/templatetags/extra_filters.py
@@ -128,22 +128,6 @@ def can_see_offensive_flags(user, post):
     else:
         return False
 
-@register.filter
-def can_view_user_edit(request_user, target_user):
-    return auth.can_view_user_edit(request_user, target_user)
-    
-@register.filter
-def can_view_user_votes(request_user, target_user):
-    return auth.can_view_user_votes(request_user, target_user)
-    
-@register.filter
-def can_view_user_preferences(request_user, target_user):
-    return auth.can_view_user_preferences(request_user, target_user)
-    
-@register.filter
-def is_user_self(request_user, target_user):
-    return auth.is_user_self(request_user, target_user)
-    
 @register.filter
 def cnprog_intword(number):
     try:
diff --git a/askbot/templatetags/extra_filters_jinja.py b/askbot/templatetags/extra_filters_jinja.py
index 29968615..3ca2e09a 100644
--- a/askbot/templatetags/extra_filters_jinja.py
+++ b/askbot/templatetags/extra_filters_jinja.py
@@ -198,22 +198,6 @@ def can_see_offensive_flags(user, post):
     else:
         return False
 
-@register.filter
-def can_view_user_edit(request_user, target_user):
-    return auth.can_view_user_edit(request_user, target_user)
-    
-@register.filter
-def can_view_user_votes(request_user, target_user):
-    return auth.can_view_user_votes(request_user, target_user)
-    
-@register.filter
-def can_view_user_preferences(request_user, target_user):
-    return auth.can_view_user_preferences(request_user, target_user)
-    
-@register.filter
-def is_user_self(request_user, target_user):
-    return auth.is_user_self(request_user, target_user)
-    
 @register.filter
 def cnprog_intword(number):
     try:
diff --git a/askbot/templatetags/smart_if.py b/askbot/templatetags/smart_if.py
deleted file mode 100644
index ca3b43fe..00000000
--- a/askbot/templatetags/smart_if.py
+++ /dev/null
@@ -1,401 +0,0 @@
-"""
-A smarter {% if %} tag for django templates.
-
-While retaining current Django functionality, it also handles equality,
-greater than and less than operators. Some common case examples::
-
-    {% if articles|length >= 5 %}...{% endif %}
-    {% if "ifnotequal tag" != "beautiful" %}...{% endif %}
-"""
-import unittest
-from django import template
-
-
-register = template.Library()
-
-
-#==============================================================================
-# Calculation objects
-#==============================================================================
-
-class BaseCalc(object):
-    def __init__(self, var1, var2=None, negate=False):
-        self.var1 = var1
-        self.var2 = var2
-        self.negate = negate
-
-    def resolve(self, context):
-        try:
-            var1, var2 = self.resolve_vars(context)
-            outcome = self.calculate(var1, var2)
-        except:
-            outcome = False
-        if self.negate:
-            return not outcome
-        return outcome
-
-    def resolve_vars(self, context):
-        var2 = self.var2 and self.var2.resolve(context)
-        return self.var1.resolve(context), var2
-
-    def calculate(self, var1, var2):
-        raise NotImplementedError()
-
-
-class Or(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 or var2
-
-
-class And(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 and var2
-
-
-class Equals(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 == var2
-
-
-class Greater(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 > var2
-
-
-class GreaterOrEqual(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 >= var2
-
-
-class In(BaseCalc):
-    def calculate(self, var1, var2):
-        return var1 in var2
-
-
-#==============================================================================
-# Tests
-#==============================================================================
-
-class TestVar(object):
-    """
-    A basic self-resolvable object similar to a Django template variable. Used
-    to assist with tests.
-    """
-    def __init__(self, value):
-        self.value = value
-
-    def resolve(self, context):
-        return self.value
-
-
-class SmartIfTests(unittest.TestCase):
-    def setUp(self):
-        self.true = TestVar(True)
-        self.false = TestVar(False)
-        self.high = TestVar(9000)
-        self.low = TestVar(1)
-
-    def assertCalc(self, calc, context=None):
-        """
-        Test a calculation is True, also checking the inverse "negate" case.
-        """
-        context = context or {}
-        self.assert_(calc.resolve(context))
-        calc.negate = not calc.negate
-        self.assertFalse(calc.resolve(context))
-
-    def assertCalcFalse(self, calc, context=None):
-        """
-        Test a calculation is False, also checking the inverse "negate" case.
-        """
-        context = context or {}
-        self.assertFalse(calc.resolve(context))
-        calc.negate = not calc.negate
-        self.assert_(calc.resolve(context))
-
-    def test_or(self):
-        self.assertCalc(Or(self.true))
-        self.assertCalcFalse(Or(self.false))
-        self.assertCalc(Or(self.true, self.true))
-        self.assertCalc(Or(self.true, self.false))
-        self.assertCalc(Or(self.false, self.true))
-        self.assertCalcFalse(Or(self.false, self.false))
-
-    def test_and(self):
-        self.assertCalc(And(self.true, self.true))
-        self.assertCalcFalse(And(self.true, self.false))
-        self.assertCalcFalse(And(self.false, self.true))
-        self.assertCalcFalse(And(self.false, self.false))
-
-    def test_equals(self):
-        self.assertCalc(Equals(self.low, self.low))
-        self.assertCalcFalse(Equals(self.low, self.high))
-
-    def test_greater(self):
-        self.assertCalc(Greater(self.high, self.low))
-        self.assertCalcFalse(Greater(self.low, self.low))
-        self.assertCalcFalse(Greater(self.low, self.high))
-
-    def test_greater_or_equal(self):
-        self.assertCalc(GreaterOrEqual(self.high, self.low))
-        self.assertCalc(GreaterOrEqual(self.low, self.low))
-        self.assertCalcFalse(GreaterOrEqual(self.low, self.high))
-
-    def test_in(self):
-        list_ = TestVar([1,2,3])
-        invalid_list = TestVar(None)
-        self.assertCalc(In(self.low, list_))
-        self.assertCalcFalse(In(self.low, invalid_list))
-
-    def test_parse_bits(self):
-        var = IfParser([True]).parse()
-        self.assert_(var.resolve({}))
-        var = IfParser([False]).parse()
-        self.assertFalse(var.resolve({}))
-
-        var = IfParser([False, 'or', True]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([False, 'and', True]).parse()
-        self.assertFalse(var.resolve({}))
-
-        var = IfParser(['not', False, 'and', 'not', False]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser(['not', 'not', True]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([1, '=', 1]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([1, 'not', '=', 1]).parse()
-        self.assertFalse(var.resolve({}))
-
-        var = IfParser([1, 'not', 'not', '=', 1]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([1, '!=', 1]).parse()
-        self.assertFalse(var.resolve({}))
-
-        var = IfParser([3, '>', 2]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([1, '<', 2]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([2, 'not', 'in', [2, 3]]).parse()
-        self.assertFalse(var.resolve({}))
-
-        var = IfParser([1, 'or', 1, '=', 2]).parse()
-        self.assert_(var.resolve({}))
-
-    def test_boolean(self):
-        var = IfParser([True, 'and', True, 'and', True]).parse()
-        self.assert_(var.resolve({}))
-        var = IfParser([False, 'or', False, 'or', True]).parse()
-        self.assert_(var.resolve({}))
-        var = IfParser([True, 'and', False, 'or', True]).parse()
-        self.assert_(var.resolve({}))
-        var = IfParser([False, 'or', True, 'and', True]).parse()
-        self.assert_(var.resolve({}))
-
-        var = IfParser([True, 'and', True, 'and', False]).parse()
-        self.assertFalse(var.resolve({}))
-        var = IfParser([False, 'or', False, 'or', False]).parse()
-        self.assertFalse(var.resolve({}))
-        var = IfParser([False, 'or', True, 'and', False]).parse()
-        self.assertFalse(var.resolve({}))
-        var = IfParser([False, 'and', True, 'or', False]).parse()
-        self.assertFalse(var.resolve({}))
-
-    def test_invalid(self):
-        self.assertRaises(ValueError, IfParser(['not']).parse)
-        self.assertRaises(ValueError, IfParser(['==']).parse)
-        self.assertRaises(ValueError, IfParser([1, 'in']).parse)
-        self.assertRaises(ValueError, IfParser([1, '>', 'in']).parse)
-        self.assertRaises(ValueError, IfParser([1, '==', 'not', 'not']).parse)
-        self.assertRaises(ValueError, IfParser([1, 2]).parse)
-
-
-OPERATORS = {
-    '=': (Equals, True),
-    '==': (Equals, True),
-    '!=': (Equals, False),
-    '>': (Greater, True),
-    '>=': (GreaterOrEqual, True),
-    '<=': (Greater, False),
-    '<': (GreaterOrEqual, False),
-    'or': (Or, True),
-    'and': (And, True),
-    'in': (In, True),
-}
-BOOL_OPERATORS = ('or', 'and')
-
-
-class IfParser(object):
-    error_class = ValueError
-
-    def __init__(self, tokens):
-        self.tokens = tokens
-
-    def _get_tokens(self):
-        return self._tokens
-
-    def _set_tokens(self, tokens):
-        self._tokens = tokens
-        self.len = len(tokens)
-        self.pos = 0
-
-    tokens = property(_get_tokens, _set_tokens)
-
-    def parse(self):
-        if self.at_end():
-            raise self.error_class('No variables provided.')
-        var1 = self.get_bool_var()
-        while not self.at_end():
-            op, negate = self.get_operator()
-            var2 = self.get_bool_var()
-            var1 = op(var1, var2, negate=negate)
-        return var1
-
-    def get_token(self, eof_message=None, lookahead=False):
-        negate = True
-        token = None
-        pos = self.pos
-        while token is None or token == 'not':
-            if pos >= self.len:
-                if eof_message is None:
-                    raise self.error_class()
-                raise self.error_class(eof_message)
-            token = self.tokens[pos]
-            negate = not negate
-            pos += 1
-        if not lookahead:
-            self.pos = pos
-        return token, negate
-
-    def at_end(self):
-        return self.pos >= self.len
-
-    def create_var(self, value):
-        return TestVar(value)
-
-    def get_bool_var(self):
-        """
-        Returns either a variable by itself or a non-boolean operation (such as
-        ``x == 0`` or ``x < 0``).
-
-        This is needed to keep correct precedence for boolean operations (i.e.
-        ``x or x == 0`` should be ``x or (x == 0)``, not ``(x or x) == 0``).
-        """
-        var = self.get_var()
-        if not self.at_end():
-            op_token = self.get_token(lookahead=True)[0]
-            if isinstance(op_token, basestring) and (op_token not in
-                                                     BOOL_OPERATORS):
-                op, negate = self.get_operator()
-                return op(var, self.get_var(), negate=negate)
-        return var
-
-    def get_var(self):
-        token, negate = self.get_token('Reached end of statement, still '
-                                       'expecting a variable.')
-        if isinstance(token, basestring) and token in OPERATORS:
-            raise self.error_class('Expected variable, got operator (%s).' %
-                                   token)
-        var = self.create_var(token)
-        if negate:
-            return Or(var, negate=True)
-        return var
-
-    def get_operator(self):
-        token, negate = self.get_token('Reached end of statement, still '
-                                       'expecting an operator.')
-        if not isinstance(token, basestring) or token not in OPERATORS:
-            raise self.error_class('%s is not a valid operator.' % token)
-        if self.at_end():
-            raise self.error_class('No variable provided after "%s".' % token)
-        op, true = OPERATORS[token]
-        if not true:
-            negate = not negate
-        return op, negate
-
-
-#==============================================================================
-# Actual templatetag code.
-#==============================================================================
-
-class TemplateIfParser(IfParser):
-    error_class = template.TemplateSyntaxError
-
-    def __init__(self, parser, *args, **kwargs):
-        self.template_parser = parser
-        return super(TemplateIfParser, self).__init__(*args, **kwargs)
-
-    def create_var(self, value):
-        return self.template_parser.compile_filter(value)
-
-
-class SmartIfNode(template.Node):
-    def __init__(self, var, nodelist_true, nodelist_false=None):
-        self.nodelist_true, self.nodelist_false = nodelist_true, nodelist_false
-        self.var = var
-
-    def render(self, context):
-        if self.var.resolve(context):
-            return self.nodelist_true.render(context)
-        if self.nodelist_false:
-            return self.nodelist_false.render(context)
-        return ''
-
-    def __repr__(self):
-        return "<Smart If node>"
-
-    def __iter__(self):
-        for node in self.nodelist_true:
-            yield node
-        if self.nodelist_false:
-            for node in self.nodelist_false:
-                yield node
-
-    def get_nodes_by_type(self, nodetype):
-        nodes = []
-        if isinstance(self, nodetype):
-            nodes.append(self)
-        nodes.extend(self.nodelist_true.get_nodes_by_type(nodetype))
-        if self.nodelist_false:
-            nodes.extend(self.nodelist_false.get_nodes_by_type(nodetype))
-        return nodes
-
-
-@register.tag('if')
-def smart_if(parser, token):
-    """
-    A smarter {% if %} tag for django templates.
-
-    While retaining current Django functionality, it also handles equality,
-    greater than and less than operators. Some common case examples::
-
-        {% if articles|length >= 5 %}...{% endif %}
-        {% if "ifnotequal tag" != "beautiful" %}...{% endif %}
-
-    Arguments and operators _must_ have a space between them, so
-    ``{% if 1>2 %}`` is not a valid smart if tag.
-
-    All supported operators are: ``or``, ``and``, ``in``, ``=`` (or ``==``),
-    ``!=``, ``>``, ``>=``, ``<`` and ``<=``.
-    """
-    bits = token.split_contents()[1:]
-    var = TemplateIfParser(parser, bits).parse()
-    nodelist_true = parser.parse(('else', 'endif'))
-    token = parser.next_token()
-    if token.contents == 'else':
-        nodelist_false = parser.parse(('endif',))
-        parser.delete_first_token()
-    else:
-        nodelist_false = None
-    return SmartIfNode(var, nodelist_true, nodelist_false)
-
-
-if __name__ == '__main__':
-    unittest.main()
diff --git a/askbot/urls.py b/askbot/urls.py
index 2c350b6b..5947905b 100644
--- a/askbot/urls.py
+++ b/askbot/urls.py
@@ -198,7 +198,6 @@ urlpatterns = patterns('',
     ),
     #upload url is ajax only
     url( r'^%s$' % _('upload/'), views.writers.upload, name='upload'),
-    url(r'^%s$' % _('search/'), views.readers.search, name='search'),
     url(r'^%s$' % _('feedback/'), views.meta.feedback, name='feedback'),
     (r'^%s' % _('account/'), include('askbot.deps.django_authopenid.urls')),
     #url(r'^feeds/rss/$', RssLastestQuestionsFeed, name="latest_questions_feed"),
diff --git a/askbot/views/readers.py b/askbot/views/readers.py
index b6e6d2bf..4c462081 100644
--- a/askbot/views/readers.py
+++ b/askbot/views/readers.py
@@ -309,28 +309,6 @@ def questions(request):
     #print after - before
     return response
 
-def search(request): #generates listing of questions matching a search query - including tags and just words
-    """redirects to people and tag search pages
-    todo: eliminate this altogether and instead make
-    search "tab" sensitive automatically - the radio-buttons
-    are useless under the search bar
-    """
-    if request.method == "GET":
-        search_type = request.GET.get('t')
-        query = request.GET.get('query')
-        try:
-            page = int(request.GET.get('page', '1'))
-        except ValueError:
-            page = 1
-        if search_type == 'tag':
-            return HttpResponseRedirect(reverse('tags') + '?' + urlencode({'q':query.strip(),'page': page}))
-        elif search_type == 'user':
-            return HttpResponseRedirect(reverse('users') + '?' + urlencode({'q':query.strip(),'page': page}))
-        else:
-            raise Http404
-    else:
-        raise Http404
-
 def tags(request):#view showing a listing of available tags - plain list
     stag = ""
     is_paginated = True
@@ -341,9 +319,9 @@ def tags(request):#view showing a listing of available tags - plain list
         page = 1
 
     if request.method == "GET":
-        stag = request.GET.get("q", "").strip()
+        stag = request.GET.get("query", "").strip()
         if stag != '':
-            objects_list = Paginator(models.Tag.objects.filter(deleted=False).exclude(used_count=0).extra(where=['name like %s'], params=['%' + stag + '%']), DEFAULT_PAGE_SIZE)
+            objects_list = Paginator(models.Tag.objects.filter(deleted=False).exclude(used_count=0).extra(where=['name ilike %s'], params=['%' + stag + '%']), DEFAULT_PAGE_SIZE)
         else:
             if sortby == "name":
                 objects_list = Paginator(models.Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("name"), DEFAULT_PAGE_SIZE)
diff --git a/askbot/views/users.py b/askbot/views/users.py
index d667de27..c7f9ebb5 100644
--- a/askbot/views/users.py
+++ b/askbot/views/users.py
@@ -64,7 +64,7 @@ def owner_or_moderator_required(f):
 def users(request):
     is_paginated = True
     sortby = request.GET.get('sort', 'reputation')
-    suser = request.REQUEST.get('q',  "")
+    suser = request.REQUEST.get('query',  "")
     try:
         page = int(request.GET.get('page', '1'))
     except ValueError:
@@ -92,7 +92,7 @@ def users(request):
         sortby = "reputation"
         objects_list = Paginator(
                             models.User.objects.extra(
-                                                where=['username like %s'],
+                                                where=['username ilike %s'],
                                                 params=['%' + suser + '%']
                                             ).order_by(
                                                 '-reputation'
-- 
cgit v1.2.3-1-g7c22