changes to unix mode

3 files changed, 3335 insertions, 0 deletions

diff --git a/forum/auth.py b/forum/auth.py
index e69de29b..36ca54d3 100644
--- a/forum/auth.py
+++ b/forum/auth.py
@@ -0,0 +1,443 @@
+"""
+Authorisation related functions.
+
+The actions a User is authorised to perform are dependent on their reputation
+and superuser status.
+"""
+import datetime
+from django.contrib.contenttypes.models import ContentType
+from django.db import transaction
+from models import Repute
+from models import Question
+from models import Answer
+from const import TYPE_REPUTATION
+question_type = ContentType.objects.get_for_model(Question)
+answer_type = ContentType.objects.get_for_model(Answer)
+
+VOTE_UP                   = 15
+FLAG_OFFENSIVE            = 15
+POST_IMAGES               = 15
+LEAVE_COMMENTS            = 50
+UPLOAD_FILES              = 60
+VOTE_DOWN                 = 100
+CLOSE_OWN_QUESTIONS       = 250
+RETAG_OTHER_QUESTIONS     = 500
+REOPEN_OWN_QUESTIONS      = 500
+EDIT_COMMUNITY_WIKI_POSTS = 750
+EDIT_OTHER_POSTS          = 2000
+DELETE_COMMENTS           = 2000
+VIEW_OFFENSIVE_FLAGS      = 2000
+DISABLE_URL_NOFOLLOW      = 2000
+CLOSE_OTHER_QUESTIONS     = 3000
+LOCK_POSTS                = 4000
+
+VOTE_RULES = {
+    'scope_votes_per_user_per_day' : 30, # how many votes of one user has everyday
+    'scope_flags_per_user_per_day' : 5,  # how many times user can flag posts everyday
+    'scope_warn_votes_left' : 10,        # start when to warn user how many votes left
+    'scope_deny_unvote_days' : 1,        # if 1 days passed, user can't cancel votes.
+    'scope_flags_invisible_main_page' : 3, # post doesn't show on main page if has more than 3 offensive flags
+    'scope_flags_delete_post' : 5,         # post will be deleted if it has more than 5 offensive flags
+}
+
+REPUTATION_RULES = {
+    'initial_score'                       : 1,
+    'scope_per_day_by_upvotes'            : 200,
+    'gain_by_upvoted'                     : 10,
+    'gain_by_answer_accepted'             : 15,
+    'gain_by_accepting_answer'            : 2,
+    'gain_by_downvote_canceled'           : 2,
+    'gain_by_canceling_downvote'          : 1,
+    'lose_by_canceling_accepted_answer'   : -2,
+    'lose_by_accepted_answer_cancled'     : -15,
+    'lose_by_downvoted'                   : -2,
+    'lose_by_flagged'                     : -2,
+    'lose_by_downvoting'                  : -1,
+    'lose_by_flagged_lastrevision_3_times': -30,
+    'lose_by_flagged_lastrevision_5_times': -100,
+    'lose_by_upvote_canceled'             : -10,
+}
+
+def can_vote_up(user):
+    """Determines if a User can vote Questions and Answers up."""
+    return user.is_authenticated() and (
+        user.reputation >= VOTE_UP or
+        user.is_superuser)
+
+def can_flag_offensive(user):
+    """Determines if a User can flag Questions and Answers as offensive."""
+    return user.is_authenticated() and (
+        user.reputation >= FLAG_OFFENSIVE or
+        user.is_superuser)
+
+def can_add_comments(user):
+    """Determines if a User can add comments to Questions and Answers."""
+    return user.is_authenticated() and (
+        user.reputation >= LEAVE_COMMENTS or
+        user.is_superuser)
+
+def can_vote_down(user):
+    """Determines if a User can vote Questions and Answers down."""
+    return user.is_authenticated() and (
+        user.reputation >= VOTE_DOWN or
+        user.is_superuser)
+
+def can_retag_questions(user):
+    """Determines if a User can retag Questions."""
+    return user.is_authenticated() and (
+        RETAG_OTHER_QUESTIONS <= user.reputation < EDIT_OTHER_POSTS or
+        user.is_superuser)
+
+def can_edit_post(user, post):
+    """Determines if a User can edit the given Question or Answer."""
+    return user.is_authenticated() and (
+        user.id == post.author_id or
+        (post.wiki and user.reputation >= EDIT_COMMUNITY_WIKI_POSTS) or
+        user.reputation >= EDIT_OTHER_POSTS or
+        user.is_superuser)
+
+def can_delete_comment(user, comment):
+    """Determines if a User can delete the given Comment."""
+    return user.is_authenticated() and (
+        user.id == comment.user_id or
+        user.reputation >= DELETE_COMMENTS or
+        user.is_superuser)
+
+def can_view_offensive_flags(user):
+    """Determines if a User can view offensive flag counts."""
+    return user.is_authenticated() and (
+        user.reputation >= VIEW_OFFENSIVE_FLAGS or
+        user.is_superuser)
+
+def can_close_question(user, question):
+    """Determines if a User can close the given Question."""
+    return user.is_authenticated() and (
+        (user.id == question.author_id and
+         user.reputation >= CLOSE_OWN_QUESTIONS) or
+        user.reputation >= CLOSE_OTHER_QUESTIONS or
+        user.is_superuser)
+
+def can_lock_posts(user):
+    """Determines if a User can lock Questions or Answers."""
+    return user.is_authenticated() and (
+        user.reputation >= LOCK_POSTS or
+        user.is_superuser)
+
+def can_follow_url(user):
+    """Determines if the URL link can be followed by Google search engine."""
+    return user.reputation >= DISABLE_URL_NOFOLLOW
+
+def can_accept_answer(user, question, answer):
+    return (user.is_authenticated() and
+        question.author != answer.author and
+        question.author == user) or user.is_superuser
+
+# now only support to reopen own question except superuser
+def can_reopen_question(user, question):
+    return (user.is_authenticated() and
+        user.id == question.author_id and
+        user.reputation >= REOPEN_OWN_QUESTIONS) or user.is_superuser
+
+def can_delete_post(user, post):
+    return (user.is_authenticated() and
+        user.id == post.author_id) or user.is_superuser
+
+def can_view_deleted_post(user, post):
+    return user.is_superuser
+
+# 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)
+
+def can_upload_files(request_user):
+    return (request_user.is_authenticated() and request_user.reputation >= UPLOAD_FILES) or \
+           request_user.is_superuser
+
+###########################################
+## actions and reputation changes event
+###########################################
+def calculate_reputation(origin, offset):
+    result = int(origin) + int(offset)
+    return result if result > 0 else 1
+
+@transaction.commit_on_success
+def onFlaggedItem(item, post, user):
+
+    item.save()
+    post.offensive_flag_count = post.offensive_flag_count + 1
+    post.save()
+
+    post.author.reputation = calculate_reputation(post.author.reputation,
+                           int(REPUTATION_RULES['lose_by_flagged']))
+    post.author.save()
+
+    question = post
+    if ContentType.objects.get_for_model(post) == answer_type:
+        question = post.question
+
+    reputation = Repute(user=post.author,
+               negative=int(REPUTATION_RULES['lose_by_flagged']),
+               question=question, reputed_at=datetime.datetime.now(),
+               reputation_type=-4,
+               reputation=post.author.reputation)
+    reputation.save()
+
+    #todo: These should be updated to work on same revisions.
+    if post.offensive_flag_count ==  VOTE_RULES['scope_flags_invisible_main_page'] :
+        post.author.reputation = calculate_reputation(post.author.reputation,
+                               int(REPUTATION_RULES['lose_by_flagged_lastrevision_3_times']))
+        post.author.save()
+
+        reputation = Repute(user=post.author,
+                   negative=int(REPUTATION_RULES['lose_by_flagged_lastrevision_3_times']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=-6,
+                   reputation=post.author.reputation)
+        reputation.save()
+
+    elif post.offensive_flag_count == VOTE_RULES['scope_flags_delete_post']:
+        post.author.reputation = calculate_reputation(post.author.reputation,
+                               int(REPUTATION_RULES['lose_by_flagged_lastrevision_5_times']))
+        post.author.save()
+
+        reputation = Repute(user=post.author,
+                   negative=int(REPUTATION_RULES['lose_by_flagged_lastrevision_5_times']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=-7,
+                   reputation=post.author.reputation)
+        reputation.save()
+
+        post.deleted = True
+        #post.deleted_at = datetime.datetime.now()
+        #post.deleted_by = Admin
+        post.save()
+
+
+@transaction.commit_on_success
+def onAnswerAccept(answer, user):
+    answer.accepted = True
+    answer.accepted_at = datetime.datetime.now()
+    answer.question.answer_accepted = True
+    answer.save()
+    answer.question.save()
+
+    answer.author.reputation = calculate_reputation(answer.author.reputation,
+                             int(REPUTATION_RULES['gain_by_answer_accepted']))
+    answer.author.save()
+    reputation = Repute(user=answer.author,
+               positive=int(REPUTATION_RULES['gain_by_answer_accepted']),
+               question=answer.question,
+               reputed_at=datetime.datetime.now(),
+               reputation_type=2,
+               reputation=answer.author.reputation)
+    reputation.save()
+
+    user.reputation = calculate_reputation(user.reputation,
+                    int(REPUTATION_RULES['gain_by_accepting_answer']))
+    user.save()
+    reputation = Repute(user=user,
+               positive=int(REPUTATION_RULES['gain_by_accepting_answer']),
+               question=answer.question,
+               reputed_at=datetime.datetime.now(),
+               reputation_type=3,
+               reputation=user.reputation)
+    reputation.save()
+
+@transaction.commit_on_success
+def onAnswerAcceptCanceled(answer, user):
+    answer.accepted = False
+    answer.accepted_at = None
+    answer.question.answer_accepted = False
+    answer.save()
+    answer.question.save()
+
+    answer.author.reputation = calculate_reputation(answer.author.reputation,
+                             int(REPUTATION_RULES['lose_by_accepted_answer_cancled']))
+    answer.author.save()
+    reputation = Repute(user=answer.author,
+               negative=int(REPUTATION_RULES['lose_by_accepted_answer_cancled']),
+               question=answer.question,
+               reputed_at=datetime.datetime.now(),
+               reputation_type=-2,
+               reputation=answer.author.reputation)
+    reputation.save()
+
+    user.reputation = calculate_reputation(user.reputation,
+                    int(REPUTATION_RULES['lose_by_canceling_accepted_answer']))
+    user.save()
+    reputation = Repute(user=user,
+               negative=int(REPUTATION_RULES['lose_by_canceling_accepted_answer']),
+               question=answer.question,
+               reputed_at=datetime.datetime.now(),
+               reputation_type=-1,
+               reputation=user.reputation)
+    reputation.save()
+
+@transaction.commit_on_success
+def onUpVoted(vote, post, user):
+    vote.save()
+
+    post.vote_up_count = int(post.vote_up_count) + 1
+    post.score = int(post.score) + 1
+    post.save()
+
+    if not post.wiki:
+        author = post.author
+        if Repute.objects.get_reputation_by_upvoted_today(author) <  int(REPUTATION_RULES['scope_per_day_by_upvotes']):
+            author.reputation = calculate_reputation(author.reputation,
+                              int(REPUTATION_RULES['gain_by_upvoted']))
+            author.save()
+
+            question = post
+            if ContentType.objects.get_for_model(post) == answer_type:
+                question = post.question
+
+            reputation = Repute(user=author,
+                       positive=int(REPUTATION_RULES['gain_by_upvoted']),
+                       question=question,
+                       reputed_at=datetime.datetime.now(),
+                       reputation_type=1,
+                       reputation=author.reputation)
+            reputation.save()
+
+@transaction.commit_on_success
+def onUpVotedCanceled(vote, post, user):
+    vote.delete()
+
+    post.vote_up_count = int(post.vote_up_count) - 1
+    if post.vote_up_count < 0:
+        post.vote_up_count  = 0
+    post.score = int(post.score) - 1
+    post.save()
+
+    if not post.wiki:
+        author = post.author
+        author.reputation = calculate_reputation(author.reputation,
+                          int(REPUTATION_RULES['lose_by_upvote_canceled']))
+        author.save()
+
+        question = post
+        if ContentType.objects.get_for_model(post) == answer_type:
+            question = post.question
+
+        reputation = Repute(user=author,
+                   negative=int(REPUTATION_RULES['lose_by_upvote_canceled']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=-8,
+                   reputation=author.reputation)
+        reputation.save()
+
+@transaction.commit_on_success
+def onDownVoted(vote, post, user):
+    vote.save()
+
+    post.vote_down_count = int(post.vote_down_count) + 1
+    post.score = int(post.score) - 1
+    post.save()
+
+    if not post.wiki:
+        author = post.author
+        author.reputation = calculate_reputation(author.reputation,
+                          int(REPUTATION_RULES['lose_by_downvoted']))
+        author.save()
+
+        question = post
+        if ContentType.objects.get_for_model(post) == answer_type:
+            question = post.question
+
+        reputation = Repute(user=author,
+                   negative=int(REPUTATION_RULES['lose_by_downvoted']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=-3,
+                   reputation=author.reputation)
+        reputation.save()
+
+        user.reputation = calculate_reputation(user.reputation,
+                        int(REPUTATION_RULES['lose_by_downvoting']))
+        user.save()
+
+        reputation = Repute(user=user,
+                   negative=int(REPUTATION_RULES['lose_by_downvoting']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=-5,
+                   reputation=user.reputation)
+        reputation.save()
+
+@transaction.commit_on_success
+def onDownVotedCanceled(vote, post, user):
+    vote.delete()
+
+    post.vote_down_count = int(post.vote_down_count) - 1
+    if post.vote_down_count < 0:
+        post.vote_down_count  = 0
+    post.score = post.score + 1
+    post.save()
+
+    if not post.wiki:
+        author = post.author
+        author.reputation = calculate_reputation(author.reputation,
+                          int(REPUTATION_RULES['gain_by_downvote_canceled']))
+        author.save()
+
+        question = post
+        if ContentType.objects.get_for_model(post) == answer_type:
+            question = post.question
+
+        reputation = Repute(user=author,
+                   positive=int(REPUTATION_RULES['gain_by_downvote_canceled']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=4,
+                   reputation=author.reputation)
+        reputation.save()
+
+        user.reputation = calculate_reputation(user.reputation,
+                        int(REPUTATION_RULES['gain_by_canceling_downvote']))
+        user.save()
+
+        reputation = Repute(user=user,
+                   positive=int(REPUTATION_RULES['gain_by_canceling_downvote']),
+                   question=question,
+                   reputed_at=datetime.datetime.now(),
+                   reputation_type=5,
+                   reputation=user.reputation)
+        reputation.save()
+
+def onDeleteCanceled(post, user):
+    post.deleted = False
+    post.deleted_by = None
+    post.deleted_at = None
+    post.save()
+    for tag in list(post.tags.all()):
+        if tag.used_count == 1 and tag.deleted:
+            tag.deleted = False
+            tag.deleted_by = None
+            tag.deleted_at = None
+            tag.save()
+
+def onDeleted(post, user):
+    post.deleted = True
+    post.deleted_by = user
+    post.deleted_at = datetime.datetime.now()
+    post.save()
+
+    for tag in list(post.tags.all()):
+        if tag.used_count == 1:
+            tag.deleted = True
+            tag.deleted_by = user
+            tag.deleted_at = datetime.datetime.now()
+            tag.save()
diff --git a/forum/models.py b/forum/models.py
index e69de29b..255eb21f 100644
--- a/forum/models.py
+++ b/forum/models.py
@@ -0,0 +1,808 @@
+# encoding:utf-8
+import datetime
+import hashlib
+from urllib import quote_plus, urlencode
+from django.db import models
+from django.utils.html import strip_tags
+from django.core.urlresolvers import reverse
+from django.contrib.auth.models import User
+from django.contrib.contenttypes import generic
+from django.contrib.contenttypes.models import ContentType
+from django.template.defaultfilters import slugify
+from django.db.models.signals import post_delete, post_save, pre_save
+from django.utils.translation import ugettext as _
+import django.dispatch
+import settings
+
+from forum.managers import *
+from const import *
+
+class EmailFeed(models.Model):
+    #subscription key for unsubscribe by visiting emailed link
+    key = models.CharField(max_length=32)
+    #generic relation with feed content (i.e. question or tags)
+    feed_content_type = models.ForeignKey(ContentType,related_name='content_emailfeed')
+    feed_id = models.PositiveIntegerField()
+    content = generic.GenericForeignKey('feed_content_type','feed_id')
+    #generic relation with owner - either nameless email or User
+    subscriber_content_type = models.ForeignKey(ContentType,related_name='subscriber_emailfeed')
+    subscriber_id = models.PositiveIntegerField()
+    subscriber = generic.GenericForeignKey('subscriber_content_type','subscriber_id')
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    reported_at = models.DateTimeField(default=datetime.datetime.now)
+
+    #getter functions rely on implementations of similar functions in content
+    #of subscriber objects
+    def get_update_summary(self):
+        return self.content.get_update_summary(last_reported_at = self.reported_at,recipient_email = self.get_email())
+
+    def get_email(self):
+        return self.subscriber.email
+
+class Tag(models.Model):
+    name       = models.CharField(max_length=255, unique=True)
+    created_by = models.ForeignKey(User, related_name='created_tags')
+    deleted         = models.BooleanField(default=False)
+    deleted_at      = models.DateTimeField(null=True, blank=True)
+    deleted_by      = models.ForeignKey(User, null=True, blank=True, related_name='deleted_tags')
+    email_feeds     = generic.GenericRelation(EmailFeed)
+    # Denormalised data
+    used_count = models.PositiveIntegerField(default=0)
+
+    objects = TagManager()
+
+    class Meta:
+        db_table = u'tag'
+        ordering = ('-used_count', 'name')
+
+    def __unicode__(self):
+        return self.name
+
+class Comment(models.Model):
+    content_type   = models.ForeignKey(ContentType)
+    object_id      = models.PositiveIntegerField()
+    content_object = generic.GenericForeignKey('content_type', 'object_id')
+    user           = models.ForeignKey(User, related_name='comments')
+    comment        = models.CharField(max_length=300)
+    added_at       = models.DateTimeField(default=datetime.datetime.now)
+
+    class Meta:
+        ordering = ('-added_at',)
+        db_table = u'comment'
+    def __unicode__(self):
+        return self.comment
+
+class Vote(models.Model):
+    VOTE_UP = +1
+    VOTE_DOWN = -1
+    VOTE_CHOICES = (
+        (VOTE_UP,   u'Up'),
+        (VOTE_DOWN, u'Down'),
+    )
+
+    content_type   = models.ForeignKey(ContentType)
+    object_id      = models.PositiveIntegerField()
+    content_object = generic.GenericForeignKey('content_type', 'object_id')
+    user           = models.ForeignKey(User, related_name='votes')
+    vote           = models.SmallIntegerField(choices=VOTE_CHOICES)
+    voted_at       = models.DateTimeField(default=datetime.datetime.now)
+
+    objects = VoteManager()
+
+    class Meta:
+        unique_together = ('content_type', 'object_id', 'user')
+        db_table = u'vote'
+    def __unicode__(self):
+        return '[%s] voted at %s: %s' %(self.user, self.voted_at, self.vote)
+
+    def is_upvote(self):
+        return self.vote == self.VOTE_UP
+
+    def is_downvote(self):
+        return self.vote == self.VOTE_DOWN
+
+class FlaggedItem(models.Model):
+    """A flag on a Question or Answer indicating offensive content."""
+    content_type   = models.ForeignKey(ContentType)
+    object_id      = models.PositiveIntegerField()
+    content_object = generic.GenericForeignKey('content_type', 'object_id')
+    user           = models.ForeignKey(User, related_name='flagged_items')
+    flagged_at     = models.DateTimeField(default=datetime.datetime.now)
+
+    objects = FlaggedItemManager()
+
+    class Meta:
+        unique_together = ('content_type', 'object_id', 'user')
+        db_table = u'flagged_item'
+    def __unicode__(self):
+        return '[%s] flagged at %s' %(self.user, self.flagged_at)
+
+class Question(models.Model):
+    title    = models.CharField(max_length=300)
+    author   = models.ForeignKey(User, related_name='questions')
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    tags     = models.ManyToManyField(Tag, related_name='questions')
+    # Status
+    wiki            = models.BooleanField(default=False)
+    wikified_at     = models.DateTimeField(null=True, blank=True)
+    answer_accepted = models.BooleanField(default=False)
+    closed          = models.BooleanField(default=False)
+    closed_by       = models.ForeignKey(User, null=True, blank=True, related_name='closed_questions')
+    closed_at       = models.DateTimeField(null=True, blank=True)
+    close_reason    = models.SmallIntegerField(choices=CLOSE_REASONS, null=True, blank=True)
+    deleted         = models.BooleanField(default=False)
+    deleted_at      = models.DateTimeField(null=True, blank=True)
+    deleted_by      = models.ForeignKey(User, null=True, blank=True, related_name='deleted_questions')
+    locked          = models.BooleanField(default=False)
+    locked_by       = models.ForeignKey(User, null=True, blank=True, related_name='locked_questions')
+    locked_at       = models.DateTimeField(null=True, blank=True)
+    # Denormalised data
+    score                = models.IntegerField(default=0)
+    vote_up_count        = models.IntegerField(default=0)
+    vote_down_count      = models.IntegerField(default=0)
+    answer_count         = models.PositiveIntegerField(default=0)
+    comment_count        = models.PositiveIntegerField(default=0)
+    view_count           = models.PositiveIntegerField(default=0)
+    offensive_flag_count = models.SmallIntegerField(default=0)
+    favourite_count      = models.PositiveIntegerField(default=0)
+    last_edited_at       = models.DateTimeField(null=True, blank=True)
+    last_edited_by       = models.ForeignKey(User, null=True, blank=True, related_name='last_edited_questions')
+    last_activity_at     = models.DateTimeField(default=datetime.datetime.now)
+    last_activity_by     = models.ForeignKey(User, related_name='last_active_in_questions')
+    tagnames             = models.CharField(max_length=125)
+    summary              = models.CharField(max_length=180)
+    html                 = models.TextField()
+    comments             = generic.GenericRelation(Comment)
+    votes                = generic.GenericRelation(Vote)
+    flagged_items        = generic.GenericRelation(FlaggedItem)
+    email_feeds          = generic.GenericRelation(EmailFeed)
+
+    objects = QuestionManager()
+
+    def save(self, **kwargs):
+        """
+        Overridden to manually manage addition of tags when the object
+        is first saved.
+
+        This is required as we're using ``tagnames`` as the sole means of
+        adding and editing tags.
+        """
+        initial_addition = (self.id is None)
+        super(Question, self).save(**kwargs)
+        if initial_addition:
+            tags = Tag.objects.get_or_create_multiple(self.tagname_list(),
+                                                      self.author)
+            self.tags.add(*tags)
+            Tag.objects.update_use_counts(tags)
+
+    def tagname_list(self):
+        """Creates a list of Tag names from the ``tagnames`` attribute."""
+        return [name for name in self.tagnames.split(u' ')]
+
+    def get_absolute_url(self):
+        return '%s%s' % (reverse('question', args=[self.id]), self.title.replace(' ', '-'))
+
+    def has_favorite_by_user(self, user):
+        if not user.is_authenticated():
+            return False
+        return FavoriteQuestion.objects.filter(question=self, user=user).count() > 0
+
+    def get_answer_count_by_user(self, user_id):
+        query_set = Answer.objects.filter(author__id=user_id)
+        return query_set.filter(question=self).count()
+
+    def get_question_title(self):
+        if self.closed:
+            attr = CONST['closed'] 
+        elif self.deleted:
+            attr = CONST['deleted']
+        else:
+            attr = None
+        if attr is not None:
+            return u'%s %s' % (self.title, attr)
+        else:
+            return self.title
+
+    def get_revision_url(self):
+        return reverse('question_revisions', args=[self.id])
+
+    def get_latest_revision(self):
+        return self.revisions.all()[0]
+
+    def get_update_summary(self,last_reported_at=None,recipient_email=''):
+        edited = False 
+        if self.last_edited_at and self.last_edited_at > last_reported_at:
+            if self.last_edited_by.email != recipient_email:
+                edited = True 
+        comments = []
+        for comment in self.comments.all():
+            if comment.added_at > last_reported_at and comment.user.email != recipient_email:
+                comments.append(comment)
+        new_answers = []
+        answer_comments = []
+        modified_answers = []
+        commented_answers = []
+        import sets
+        commented_answers = sets.Set([])
+        for answer in self.answers.all():
+            if (answer.added_at > last_reported_at and answer.author.email != recipient_email):
+                new_answers.append(answer)
+            if (answer.last_edited_at 
+                and answer.last_edited_at > last_reported_at 
+                and answer.last_edited_by.email != recipient_email):
+                modified_answers.append(answer)
+            for comment in answer.comments.all():
+                if comment.added_at > last_reported_at and comment.user.email != recipient_email:
+                    commented_answers.add(answer)
+                    answer_comments.append(comment)
+
+        #create the report
+        if edited or comments or new_answers or modified_answers or answer_comments:
+            out = [] 
+            if edited:
+                out.append(_('%(author)s modified the question') % {'author':self.last_edited_by.username})
+            if new_answers:
+                names = sets.Set(map(lambda x: x.author.username,new_answers))
+                people = ', '.join(names)
+                out.append(_('%(people)s posted %(new_answer_count)s new answers') \
+                                % {'new_answer_count':len(new_answers),'people':people})
+            if comments:
+                names = sets.Set(map(lambda x: x.user.username,comments))
+                people = ', '.join(names)
+                out.append(_('%(people)s commented the question') % {'people':people})
+            if answer_comments:
+                names = sets.Set(map(lambda x: x.user.username,answer_comments))
+                people = ', '.join(names)
+                if len(commented_answers) > 1:
+                    out.append(_('%(people)s commented answers') % {'people':people})
+                else:
+                    out.append(_('%(people)s commented an answer') % {'people':people})
+            url = settings.APP_URL + self.get_absolute_url()
+            retval = '<a href="%s">%s</a>:<br>\n' % (url,self.title)
+            out = map(lambda x: '<li>' + x + '</li>',out)
+            retval += '<ul>' + '\n'.join(out) + '</ul><br>\n'
+            return retval
+        else:
+            return None
+
+    def __unicode__(self):
+        return self.title
+
+    class Meta:
+        db_table = u'question'
+
+class QuestionRevision(models.Model):
+    """A revision of a Question."""
+    question   = models.ForeignKey(Question, related_name='revisions')
+    revision   = models.PositiveIntegerField(blank=True)
+    title      = models.CharField(max_length=300)
+    author     = models.ForeignKey(User, related_name='question_revisions')
+    revised_at = models.DateTimeField()
+    tagnames   = models.CharField(max_length=125)
+    summary    = models.CharField(max_length=300, blank=True)
+    text       = models.TextField()
+
+    class Meta:
+        db_table = u'question_revision'
+        ordering = ('-revision',)
+
+    def get_question_title(self):
+        return self.question.title
+
+    def get_absolute_url(self):
+        return '/questions/%s/revisions' % (self.question.id)
+
+    def save(self, **kwargs):
+        """Looks up the next available revision number."""
+        if not self.revision:
+            self.revision = QuestionRevision.objects.filter(
+                question=self.question).values_list('revision',
+                                                    flat=True)[0] + 1
+        super(QuestionRevision, self).save(**kwargs)
+
+    def __unicode__(self):
+        return u'revision %s of %s' % (self.revision, self.title)
+
+class AnonymousAnswer(models.Model):
+    question = models.ForeignKey(Question, related_name='anonymous_answers')
+    session_key = models.CharField(max_length=40)  #session id for anonymous questions
+    wiki = models.BooleanField(default=False)
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    ip_addr = models.IPAddressField(max_length=21) #allow high port numbers
+    author = models.ForeignKey(User,null=True)
+    text = models.TextField()
+    summary = models.CharField(max_length=180)
+
+    def publish(self,user):
+        from forum.views import create_new_answer
+        added_at = datetime.datetime.now()
+        print user.id
+        create_new_answer(question=self.question,wiki=self.wiki,
+                            added_at=added_at,text=self.text,
+                            author=user)
+        self.delete()
+
+class AnonymousQuestion(models.Model):
+    title = models.CharField(max_length=300)
+    session_key = models.CharField(max_length=40)  #session id for anonymous questions
+    text = models.TextField()
+    summary = models.CharField(max_length=180)
+    tagnames = models.CharField(max_length=125)
+    wiki = models.BooleanField(default=False)
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    ip_addr = models.IPAddressField(max_length=21) #allow high port numbers
+    author = models.ForeignKey(User,null=True)
+
+    def publish(self,user):
+        from forum.views import create_new_question
+        added_at = datetime.datetime.now()
+        create_new_question(title=self.title, author=user, added_at=added_at,
+                                wiki=self.wiki, tagnames=self.tagnames,
+                                summary=self.summary, text=self.text)
+        self.delete()
+
+class Answer(models.Model):
+    question = models.ForeignKey(Question, related_name='answers')
+    author   = models.ForeignKey(User, related_name='answers')
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    # Status
+    wiki        = models.BooleanField(default=False)
+    wikified_at = models.DateTimeField(null=True, blank=True)
+    accepted    = models.BooleanField(default=False)
+    accepted_at = models.DateTimeField(null=True, blank=True)
+    deleted     = models.BooleanField(default=False)
+    deleted_by  = models.ForeignKey(User, null=True, blank=True, related_name='deleted_answers')
+    locked      = models.BooleanField(default=False)
+    locked_by   = models.ForeignKey(User, null=True, blank=True, related_name='locked_answers')
+    locked_at   = models.DateTimeField(null=True, blank=True)
+    # Denormalised data
+    score                = models.IntegerField(default=0)
+    vote_up_count        = models.IntegerField(default=0)
+    vote_down_count      = models.IntegerField(default=0)
+    comment_count        = models.PositiveIntegerField(default=0)
+    offensive_flag_count = models.SmallIntegerField(default=0)
+    last_edited_at       = models.DateTimeField(null=True, blank=True)
+    last_edited_by       = models.ForeignKey(User, null=True, blank=True, related_name='last_edited_answers')
+    html                 = models.TextField()
+    comments             = generic.GenericRelation(Comment)
+    votes                = generic.GenericRelation(Vote)
+    flagged_items        = generic.GenericRelation(FlaggedItem)
+
+    objects = AnswerManager()
+
+    def get_user_vote(self, user):
+        votes = self.votes.filter(user=user)
+        if votes.count() > 0:
+            return votes[0]
+        else:
+            return None
+
+    def get_latest_revision(self):
+        return self.revisions.all()[0]
+
+    def get_question_title(self):
+        return self.question.title
+
+    def get_absolute_url(self):
+        return '%s%s#%s' % (reverse('question', args=[self.question.id]), self.question.title, self.id)
+
+    class Meta:
+        db_table = u'answer'
+
+    def __unicode__(self):
+        return self.html
+
+class AnswerRevision(models.Model):
+    """A revision of an Answer."""
+    answer     = models.ForeignKey(Answer, related_name='revisions')
+    revision   = models.PositiveIntegerField()
+    author     = models.ForeignKey(User, related_name='answer_revisions')
+    revised_at = models.DateTimeField()
+    summary    = models.CharField(max_length=300, blank=True)
+    text       = models.TextField()
+
+    def get_absolute_url(self):
+        return '/answers/%s/revisions' % (self.answer.id)
+
+    def get_question_title(self):
+        return self.answer.question.title
+
+    class Meta:
+        db_table = u'answer_revision'
+        ordering = ('-revision',)
+
+    def save(self, **kwargs):
+        """Looks up the next available revision number if not set."""
+        if not self.revision:
+            self.revision = AnswerRevision.objects.filter(
+                answer=self.answer).values_list('revision',
+                                                flat=True)[0] + 1
+        super(AnswerRevision, self).save(**kwargs)
+
+class FavoriteQuestion(models.Model):
+    """A favorite Question of a User."""
+    question      = models.ForeignKey(Question)
+    user          = models.ForeignKey(User, related_name='user_favorite_questions')
+    added_at = models.DateTimeField(default=datetime.datetime.now)
+    class Meta:
+        db_table = u'favorite_question'
+    def __unicode__(self):
+        return '[%s] favorited at %s' %(self.user, self.added_at)
+
+class Badge(models.Model):
+    """Awarded for notable actions performed on the site by Users."""
+    GOLD = 1
+    SILVER = 2
+    BRONZE = 3
+    TYPE_CHOICES = (
+        (GOLD,   _('gold')),
+        (SILVER, _('silver')),
+        (BRONZE, _('bronze')),
+    )
+
+    name        = models.CharField(max_length=50)
+    type        = models.SmallIntegerField(choices=TYPE_CHOICES)
+    slug        = models.SlugField(max_length=50, blank=True)
+    description = models.CharField(max_length=300)
+    multiple    = models.BooleanField(default=False)
+    # Denormalised data
+    awarded_count = models.PositiveIntegerField(default=0)
+
+    class Meta:
+        db_table = u'badge'
+        ordering = ('name',)
+        unique_together = ('name', 'type')
+
+    def __unicode__(self):
+        return u'%s: %s' % (self.get_type_display(), self.name)
+
+    def save(self, **kwargs):
+        if not self.slug:
+            self.slug = self.name#slugify(self.name)
+        super(Badge, self).save(**kwargs)
+
+    def get_absolute_url(self):
+        return '%s%s/' % (reverse('badge', args=[self.id]), self.slug)
+
+class Award(models.Model):
+    """The awarding of a Badge to a User."""
+    user       = models.ForeignKey(User, related_name='award_user')
+    badge      = models.ForeignKey(Badge, related_name='award_badge')
+    content_type   = models.ForeignKey(ContentType)
+    object_id      = models.PositiveIntegerField()
+    content_object = generic.GenericForeignKey('content_type', 'object_id')
+    awarded_at = models.DateTimeField(default=datetime.datetime.now)
+    notified   = models.BooleanField(default=False)
+    objects = AwardManager()
+    
+    def __unicode__(self):
+        return u'[%s] is awarded a badge [%s] at %s' % (self.user.username, self.badge.name, self.awarded_at)
+
+    class Meta:
+        db_table = u'award'
+
+class Repute(models.Model):
+    """The reputation histories for user"""
+    user     = models.ForeignKey(User)
+    positive = models.SmallIntegerField(default=0)
+    negative = models.SmallIntegerField(default=0)
+    question = models.ForeignKey(Question)
+    reputed_at = models.DateTimeField(default=datetime.datetime.now)
+    reputation_type = models.SmallIntegerField(choices=TYPE_REPUTATION)
+    reputation = models.IntegerField(default=1)
+    objects = ReputeManager()
+
+    def __unicode__(self):
+        return u'[%s]\' reputation changed at %s' % (self.user.username, self.reputed_at)
+
+    class Meta:
+        db_table = u'repute'
+
+class Activity(models.Model):
+    """
+    We keep some history data for user activities
+    """
+    user = models.ForeignKey(User)
+    activity_type = models.SmallIntegerField(choices=TYPE_ACTIVITY)
+    active_at = models.DateTimeField(default=datetime.datetime.now)
+    content_type   = models.ForeignKey(ContentType)
+    object_id      = models.PositiveIntegerField()
+    content_object = generic.GenericForeignKey('content_type', 'object_id')
+    is_auditted    = models.BooleanField(default=False)
+
+    def __unicode__(self):
+        return u'[%s] was active at %s' % (self.user.username, self.active_at)
+
+    class Meta:
+        db_table = u'activity'
+
+class Book(models.Model):
+    """
+    Model for book info
+    """
+    user = models.ForeignKey(User)
+    title = models.CharField(max_length=255)
+    short_name = models.CharField(max_length=255)
+    author = models.CharField(max_length=255)
+    price = models.DecimalField(max_digits=6, decimal_places=2)
+    pages = models.SmallIntegerField()
+    published_at = models.DateTimeField()
+    publication = models.CharField(max_length=255)
+    cover_img = models.CharField(max_length=255)
+    tagnames = models.CharField(max_length=125)
+    added_at = models.DateTimeField()
+    last_edited_at = models.DateTimeField()
+    questions = models.ManyToManyField(Question, related_name='book', db_table='book_question')
+    
+    def get_absolute_url(self):
+        return '%s' % reverse('book', args=[self.short_name])
+        
+    def __unicode__(self):
+        return self.title
+    class Meta:
+        db_table = u'book'
+
+class BookAuthorInfo(models.Model):
+    """
+    Model for book author info
+    """
+    user = models.ForeignKey(User)
+    book = models.ForeignKey(Book)
+    blog_url = models.CharField(max_length=255)
+    added_at = models.DateTimeField()
+    last_edited_at = models.DateTimeField()
+    
+    class Meta:
+        db_table = u'book_author_info'
+    
+class BookAuthorRss(models.Model):
+    """
+    Model for book author blog rss
+    """
+    user = models.ForeignKey(User)
+    book = models.ForeignKey(Book)
+    title = models.CharField(max_length=255)
+    url = models.CharField(max_length=255)
+    rss_created_at = models.DateTimeField()
+    added_at = models.DateTimeField()
+    
+    class Meta:
+        db_table = u'book_author_rss'
+
+class AnonymousEmail(models.Model):
+    #validation key, if used
+    key = models.CharField(max_length=32)
+    email = models.EmailField(null=False,unique=True)
+    isvalid = models.BooleanField(default=False)
+    feeds = generic.GenericRelation(EmailFeed)
+
+# User extend properties
+QUESTIONS_PER_PAGE_CHOICES = (
+   (10, u'10'),
+   (30, u'30'),
+   (50, u'50'),
+)
+
+User.add_to_class('email_isvalid', models.BooleanField(default=False))
+User.add_to_class('email_key', models.CharField(max_length=16, null=True))
+User.add_to_class('reputation', models.PositiveIntegerField(default=1))
+User.add_to_class('gravatar', models.CharField(max_length=32))
+User.add_to_class('email_feeds', generic.GenericRelation(EmailFeed))
+User.add_to_class('favorite_questions',
+                  models.ManyToManyField(Question, through=FavoriteQuestion,
+                                         related_name='favorited_by'))
+User.add_to_class('badges', models.ManyToManyField(Badge, through=Award,
+                                                   related_name='awarded_to'))
+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=QUESTIONS_PER_PAGE_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))
+User.add_to_class('website', models.URLField(max_length=200, blank=True))
+User.add_to_class('location', models.CharField(max_length=100, blank=True))
+User.add_to_class('date_of_birth', models.DateField(null=True, blank=True))
+User.add_to_class('about', models.TextField(blank=True))
+
+# custom signal
+tags_updated = django.dispatch.Signal(providing_args=["question"])
+edit_question_or_answer = django.dispatch.Signal(providing_args=["instance", "modified_by"])
+delete_post_or_answer = django.dispatch.Signal(providing_args=["instance", "deleted_by"])
+mark_offensive = django.dispatch.Signal(providing_args=["instance", "mark_by"])
+user_updated = django.dispatch.Signal(providing_args=["instance", "updated_by"])
+user_logged_in = django.dispatch.Signal(providing_args=["session"])
+
+
+def get_messages(self):
+    messages = []
+    for m in self.message_set.all():
+        messages.append(m.message)
+    return messages
+
+def delete_messages(self):
+    self.message_set.all().delete()
+
+def get_profile_url(self):
+    """Returns the URL for this User's profile."""
+    return '%s%s/' % (reverse('user', args=[self.id]), self.username)
+User.add_to_class('get_profile_url', get_profile_url)
+User.add_to_class('get_messages', get_messages)
+User.add_to_class('delete_messages', delete_messages)
+
+def calculate_gravatar_hash(instance, **kwargs):
+    """Calculates a User's gravatar hash from their email address."""
+    if kwargs.get('raw', False):
+        return
+    instance.gravatar = hashlib.md5(instance.email).hexdigest()
+
+def record_ask_event(instance, created, **kwargs):
+    if created:
+        activity = Activity(user=instance.author, active_at=instance.added_at, content_object=instance, activity_type=TYPE_ACTIVITY_ASK_QUESTION)
+        activity.save()
+
+def record_answer_event(instance, created, **kwargs):
+    if created:
+        activity = Activity(user=instance.author, active_at=instance.added_at, content_object=instance, activity_type=TYPE_ACTIVITY_ANSWER)
+        activity.save()
+
+def record_comment_event(instance, created, **kwargs):
+    if created:
+        from django.contrib.contenttypes.models import ContentType
+        question_type = ContentType.objects.get_for_model(Question)
+        question_type_id = question_type.id
+        type = TYPE_ACTIVITY_COMMENT_QUESTION if instance.content_type_id == question_type_id else TYPE_ACTIVITY_COMMENT_ANSWER
+        activity = Activity(user=instance.user, active_at=instance.added_at, content_object=instance, activity_type=type)
+        activity.save()
+
+def record_revision_question_event(instance, created, **kwargs):
+    if created and instance.revision <> 1:
+        activity = Activity(user=instance.author, active_at=instance.revised_at, content_object=instance, activity_type=TYPE_ACTIVITY_UPDATE_QUESTION)
+        activity.save()
+
+def record_revision_answer_event(instance, created, **kwargs):
+    if created and instance.revision <> 1:
+        activity = Activity(user=instance.author, active_at=instance.revised_at, content_object=instance, activity_type=TYPE_ACTIVITY_UPDATE_ANSWER)
+        activity.save()
+
+def record_award_event(instance, created, **kwargs):
+    """
+    After we awarded a badge to user, we need to record this activity and notify user.
+    We also recaculate awarded_count of this badge and user information.
+    """
+    if created:
+        activity = Activity(user=instance.user, active_at=instance.awarded_at, content_object=instance,
+            activity_type=TYPE_ACTIVITY_PRIZE)
+        activity.save()
+
+        instance.badge.awarded_count += 1
+        instance.badge.save()
+
+        if instance.badge.type == Badge.GOLD:
+            instance.user.gold += 1
+        if instance.badge.type == Badge.SILVER:
+            instance.user.silver += 1
+        if instance.badge.type == Badge.BRONZE:
+            instance.user.bronze += 1
+        instance.user.save()
+
+def notify_award_message(instance, created, **kwargs):
+    """
+    Notify users when they have been awarded badges by using Django message.
+    """
+    if created:
+        user = instance.user
+        user.message_set.create(message=u"%s" % instance.badge.name)
+
+def record_answer_accepted(instance, created, **kwargs):
+    """
+    when answer is accepted, we record this for question author - who accepted it.
+    """
+    if not created and instance.accepted:
+        activity = Activity(user=instance.question.author, active_at=datetime.datetime.now(), \
+            content_object=instance, activity_type=TYPE_ACTIVITY_MARK_ANSWER)
+        activity.save()
+
+def update_last_seen(instance, created, **kwargs):
+    """
+    when user has activities, we update 'last_seen' time stamp for him
+    """
+    user = instance.user
+    user.last_seen = datetime.datetime.now()
+    user.save()
+
+def record_vote(instance, created, **kwargs):
+    """
+    when user have voted
+    """
+    if created:
+        if instance.vote == 1:
+            vote_type = TYPE_ACTIVITY_VOTE_UP
+        else:
+            vote_type = TYPE_ACTIVITY_VOTE_DOWN
+
+        activity = Activity(user=instance.user, active_at=instance.voted_at, content_object=instance, activity_type=vote_type)
+        activity.save()
+
+def record_cancel_vote(instance, **kwargs):
+    """
+    when user canceled vote, the vote will be deleted.
+    """
+    activity = Activity(user=instance.user, active_at=datetime.datetime.now(), content_object=instance, activity_type=TYPE_ACTIVITY_CANCEL_VOTE)
+    activity.save()
+
+def record_delete_question(instance, delete_by, **kwargs):
+    """
+    when user deleted the question
+    """
+    if instance.__class__ == "Question":
+        activity_type = TYPE_ACTIVITY_DELETE_QUESTION
+    else:
+        activity_type = TYPE_ACTIVITY_DELETE_ANSWER
+
+    activity = Activity(user=delete_by, active_at=datetime.datetime.now(), content_object=instance, activity_type=activity_type)
+    activity.save()
+
+def record_mark_offensive(instance, mark_by, **kwargs):
+    activity = Activity(user=mark_by, active_at=datetime.datetime.now(), content_object=instance, activity_type=TYPE_ACTIVITY_MARK_OFFENSIVE)
+    activity.save()
+
+def record_update_tags(question, **kwargs):
+    """
+    when user updated tags of the question
+    """
+    activity = Activity(user=question.author, active_at=datetime.datetime.now(), content_object=question, activity_type=TYPE_ACTIVITY_UPDATE_TAGS)
+    activity.save()
+
+def record_favorite_question(instance, created, **kwargs):
+    """
+    when user add the question in him favorite questions list.
+    """
+    if created:
+        activity = Activity(user=instance.user, active_at=datetime.datetime.now(), content_object=instance, activity_type=TYPE_ACTIVITY_FAVORITE)
+        activity.save()
+
+def record_user_full_updated(instance, **kwargs):
+    activity = Activity(user=instance, active_at=datetime.datetime.now(), content_object=instance, activity_type=TYPE_ACTIVITY_USER_FULL_UPDATED)
+    activity.save()
+
+def post_stored_anonymous_content(sender,user,session_key,signal,*args,**kwargs):
+    aq_list = AnonymousQuestion.objects.filter(session_key = session_key)
+    aa_list = AnonymousAnswer.objects.filter(session_key = session_key)
+    import settings
+    if settings.EMAIL_VALIDATION == 'on':#add user to the record
+        for aq in aq_list:
+            aq.author = user
+            aq.save()
+        for aa in aa_list:
+            aa.author = user
+            aa.save()
+        #maybe add pending posts message?
+    else: #just publish the questions
+        for aq in aq_list:
+            aq.publish(user)
+        for aa in aa_list:
+            aa.publish(user)
+
+#signal for User modle save changes
+pre_save.connect(calculate_gravatar_hash, sender=User)
+post_save.connect(record_ask_event, sender=Question)
+post_save.connect(record_answer_event, sender=Answer)
+post_save.connect(record_comment_event, sender=Comment)
+post_save.connect(record_revision_question_event, sender=QuestionRevision)
+post_save.connect(record_revision_answer_event, sender=AnswerRevision)
+post_save.connect(record_award_event, sender=Award)
+post_save.connect(notify_award_message, sender=Award)
+post_save.connect(record_answer_accepted, sender=Answer)
+post_save.connect(update_last_seen, sender=Activity)
+post_save.connect(record_vote, sender=Vote)
+post_delete.connect(record_cancel_vote, sender=Vote)
+delete_post_or_answer.connect(record_delete_question, sender=Question)
+delete_post_or_answer.connect(record_delete_question, sender=Answer)
+mark_offensive.connect(record_mark_offensive, sender=Question)
+mark_offensive.connect(record_mark_offensive, sender=Answer)
+tags_updated.connect(record_update_tags, sender=Question)
+post_save.connect(record_favorite_question, sender=FavoriteQuestion)
+user_updated.connect(record_user_full_updated, sender=User)
+user_logged_in.connect(post_stored_anonymous_content)
diff --git a/forum/views.py b/forum/views.py
index e69de29b..6ef7bd6d 100644
--- a/forum/views.py
+++ b/forum/views.py
@@ -0,0 +1,2084 @@
+# encoding:utf-8
+import os.path
+import time, datetime, calendar, random
+import logging
+from urllib import quote, unquote
+from django.conf import settings
+from django.core.files.storage import default_storage
+from django.shortcuts import render_to_response, get_object_or_404
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponseRedirect, HttpResponse,Http404
+from django.core.paginator import Paginator, EmptyPage, InvalidPage
+from django.template import RequestContext
+from django.utils.html import *
+from django.utils import simplejson
+from django.core import serializers
+from django.db import transaction
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import ugettext as _
+
+from utils.html import sanitize_html
+from markdown2 import Markdown
+#from lxml.html.diff import htmldiff
+from forum.diff import textDiff as htmldiff
+from forum.forms import *
+from forum.models import *
+from forum.auth import *
+from forum.const import *
+from forum.user import *
+from forum import auth
+
+# used in index page
+INDEX_PAGE_SIZE = 20
+INDEX_AWARD_SIZE = 15
+INDEX_TAGS_SIZE = 100
+# used in tags list
+DEFAULT_PAGE_SIZE = 60
+# used in questions
+QUESTIONS_PAGE_SIZE = 10
+# used in users
+USERS_PAGE_SIZE = 35
+# used in answers
+ANSWERS_PAGE_SIZE = 10
+markdowner = Markdown(html4tags=True)
+question_type = ContentType.objects.get_for_model(Question)
+answer_type = ContentType.objects.get_for_model(Answer)
+comment_type = ContentType.objects.get_for_model(Comment)
+question_revision_type = ContentType.objects.get_for_model(QuestionRevision)
+answer_revision_type = ContentType.objects.get_for_model(AnswerRevision)
+repute_type =ContentType.objects.get_for_model(Repute)
+question_type_id = question_type.id
+answer_type_id = answer_type.id
+comment_type_id = comment_type.id
+question_revision_type_id = question_revision_type.id
+answer_revision_type_id = answer_revision_type.id
+repute_type_id = repute_type.id
+def _get_tags_cache_json():
+    tags = Tag.objects.filter(deleted=False).all()
+    tags_list = []
+    for tag in tags:
+        dic = {'n': tag.name, 'c': tag.used_count }
+        tags_list.append(dic)
+    tags = simplejson.dumps(tags_list)
+    return tags
+
+def index(request):
+    view_id = request.GET.get('sort', None)
+    view_dic = {
+             "latest":"-last_activity_at",
+             "hottest":"-answer_count",
+             "mostvoted":"-score",
+             "trans": "-last_activity_at"
+             }
+    try:
+        orderby = view_dic[view_id]
+    except KeyError:
+        view_id = "latest"
+        orderby = "-last_activity_at"
+    # group questions by author_id of 28,29
+    if view_id == 'trans':
+        questions = Question.objects.get_translation_questions(orderby, INDEX_PAGE_SIZE)
+    else:
+        questions = Question.objects.get_questions_by_pagesize(orderby, INDEX_PAGE_SIZE)
+    # RISK - inner join queries
+    questions = questions.select_related()
+    tags = Tag.objects.get_valid_tags(INDEX_TAGS_SIZE)
+
+    awards = Award.objects.get_recent_awards()
+
+    return render_to_response('index.html', {
+        "questions" : questions,
+        "tab_id" : view_id,
+        "tags" : tags,
+        "awards" : awards[:INDEX_AWARD_SIZE],
+        }, context_instance=RequestContext(request))
+
+def about(request):
+    return render_to_response('about.html', context_instance=RequestContext(request))
+
+def faq(request):
+    return render_to_response('faq.html', context_instance=RequestContext(request))
+
+def privacy(request):
+    return render_to_response('privacy.html', context_instance=RequestContext(request))
+
+def unanswered(request):
+    return questions(request, unanswered=True)
+
+def questions(request, tagname=None, unanswered=False):
+    """
+    List of Questions, Tagged questions, and Unanswered questions.
+    """
+    # template file
+    # "questions.html" or "unanswered.html"
+    template_file = "questions.html"
+    # Set flag to False by default. If it is equal to True, then need to be saved.
+    pagesize_changed = False
+    # get pagesize from session, if failed then get default value
+    pagesize = request.session.get("pagesize",10)
+    try:
+        page = int(request.GET.get('page', '1'))
+    except ValueError:
+        page = 1
+
+    view_id = request.GET.get('sort', None)
+    view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-answer_count", "mostvoted":"-score" }
+    try:
+        orderby = view_dic[view_id]
+    except KeyError:
+        view_id = "latest"
+        orderby = "-added_at"
+
+    # check if request is from tagged questions
+    if tagname is not None:
+        objects = Question.objects.get_questions_by_tag(tagname, orderby)
+    elif unanswered:
+        #check if request is from unanswered questions
+        template_file = "unanswered.html"
+        objects = Question.objects.get_unanswered_questions(orderby)
+    else:
+        objects = Question.objects.get_questions(orderby)
+
+    # RISK - inner join queries
+    objects = objects.select_related(depth=1);
+    objects_list = Paginator(objects, pagesize)
+    questions = objects_list.page(page)
+
+    # Get related tags from this page objects
+    if questions.object_list.count() > 0:
+        related_tags = Tag.objects.get_tags_by_questions(questions.object_list)
+    else:
+        related_tags = None
+    return render_to_response(template_file, {
+        "questions" : questions,
+        "tab_id" : view_id,
+        "questions_count" : objects_list.count,
+        "tags" : related_tags,
+        "searchtag" : tagname,
+        "is_unanswered" : unanswered,
+        "context" : {
+            'is_paginated' : True,
+            'pages': objects_list.num_pages,
+            'page': page,
+            'has_previous': questions.has_previous(),
+            'has_next': questions.has_next(),
+            'previous': questions.previous_page_number(),
+            'next': questions.next_page_number(),
+            'base_url' : request.path + '?sort=%s&' % view_id,
+            'pagesize' : pagesize
+        }}, context_instance=RequestContext(request))
+
+def create_new_answer( question=None, author=None,\
+            added_at=None, wiki=False,\
+            text='', email_notify=False):
+
+    html = sanitize_html(markdowner.convert(text))
+
+    #create answer
+    answer = Answer(
+        question = question,
+        author = author,
+        added_at = added_at,
+        wiki = wiki,
+        html = html
+    )
+    if answer.wiki:
+        answer.last_edited_by = answer.author
+        answer.last_edited_at = added_at 
+        answer.wikified_at = added_at 
+
+    answer.save()
+
+    #update question data
+    question.last_activity_at = added_at 
+    question.last_activity_by = author 
+    question.save()
+    Question.objects.update_answer_count(question)
+
+    #update revision
+    AnswerRevision.objects.create(
+        answer     = answer,
+        revision   = 1,
+        author     = author,
+        revised_at = added_at,
+        summary    = CONST['default_version'],
+        text       = text
+    )
+
+    #set notification/delete
+    if email_notify:
+        try:
+            EmailFeed.objects.get(feed_id = question.id, subscriber_id = author.id, feed_content_type=question_type)
+        except EmailFeed.DoesNotExist:
+            feed = EmailFeed(content = question, subscriber = author)
+            feed.save()
+    else:
+        #not sure if this is necessary. ajax should take care of this...
+        try:
+            feed = Email.objects.get(feed_id = question.id, subscriber_id = author.id, feed_content_type=question_type)
+            feed.delete()
+        except:
+            pass
+
+def create_new_question(title=None,author=None,added_at=None,
+                        wiki=False,tagnames=None,summary=None,
+                        text=None):
+    """this is not a view
+    and maybe should become one of the methods on Question object?
+    """
+    html = sanitize_html(markdowner.convert(text))
+    question = Question(
+        title            = title,
+        author           = author, 
+        added_at         = added_at,
+        last_activity_at = added_at,
+        last_activity_by = author,
+        wiki             = wiki,
+        tagnames         = tagnames,
+        html             = html,
+        summary          = summary 
+    )
+    if question.wiki:
+        question.last_edited_by = question.author
+        question.last_edited_at = added_at
+        question.wikified_at = added_at
+
+    question.save()
+
+    # create the first revision
+    QuestionRevision.objects.create(
+        question   = question,
+        revision   = 1,
+        title      = question.title,
+        author     = author,
+        revised_at = added_at,
+        tagnames   = question.tagnames,
+        summary    = CONST['default_version'],
+        text       = text
+    )
+    return question
+
+#TODO: allow anynomus user to ask question by providing email and username.
+#@login_required
+def ask(request):
+    if request.method == "POST":
+        form = AskForm(request.POST)
+        if form.is_valid():
+
+            added_at = datetime.datetime.now()
+            title = strip_tags(form.cleaned_data['title'])
+            wiki = form.cleaned_data['wiki']
+            tagnames = form.cleaned_data['tags'].strip()
+            text = form.cleaned_data['text']
+            html = sanitize_html(markdowner.convert(text))
+            summary = strip_tags(html)[:120]
+
+            if request.user.is_authenticated():
+                author = request.user 
+
+                question = create_new_question(
+                    title            = title,
+                    author           = author, 
+                    added_at         = added_at,
+                    wiki             = wiki,
+                    tagnames         = tagnames,
+                    summary          = summary,
+                    text = text
+                )
+
+                return HttpResponseRedirect(question.get_absolute_url())
+            else:
+                request.session.flush()
+                session_key = request.session.session_key
+                question = AnonymousQuestion(
+                    session_key = session_key,
+                    title       = title,
+                    tagnames = tagnames,
+                    wiki = wiki,
+                    text = text,
+                    summary = summary,
+                    added_at = added_at,
+					ip_addr = request.META['REMOTE_ADDR'],
+                )
+                question.save()
+                return HttpResponseRedirect('%s%s%s' % ( _('/account/'),_('signin/'),('newquestion/')))
+    else:
+        form = AskForm()
+
+    tags = _get_tags_cache_json()
+    return render_to_response('ask.html', {
+        'form' : form,
+        'tags' : tags,
+        }, context_instance=RequestContext(request))
+
+def question(request, id):
+    try:
+        page = int(request.GET.get('page', '1'))
+    except ValueError:
+        page = 1
+    view_id = request.GET.get('sort', 'votes')
+    view_dic = {"latest":"-added_at", "oldest":"added_at", "votes":"-score" }
+    try:
+        orderby = view_dic[view_id]
+    except KeyError:
+        view_id = "votes"
+        orderby = "-score"
+
+    question = get_object_or_404(Question, id=id)
+    if question.deleted and not can_view_deleted_post(request.user, question):
+        raise Http404
+    answer_form = AnswerForm(question,request.user)
+    answers = Answer.objects.get_answers_from_question(question, request.user)
+    answers = answers.select_related(depth=1)
+
+    favorited = question.has_favorite_by_user(request.user)
+    question_vote = question.votes.select_related().filter(user=request.user)
+    if question_vote is not None and question_vote.count() > 0:
+        question_vote = question_vote[0]
+
+    user_answer_votes = {}
+    for answer in answers:
+        vote = answer.get_user_vote(request.user)
+        if vote is not None and not user_answer_votes.has_key(answer.id):
+            vote_value = -1
+            if vote.is_upvote():
+                vote_value = 1
+            user_answer_votes[answer.id] = vote_value
+
+
+    if answers is not None:
+        answers = answers.order_by("-accepted", orderby)
+
+    filtered_answers = []
+    for answer in answers:
+        if answer.deleted == True:
+            if answer.author_id == request.user.id:
+                filtered_answers.append(answer)
+        else:
+            filtered_answers.append(answer)
+
+    objects_list = Paginator(filtered_answers, ANSWERS_PAGE_SIZE)
+    page_objects = objects_list.page(page)
+    # update view count
+    Question.objects.update_view_count(question)
+    return render_to_response('question.html', {
+        "question" : question,
+        "question_vote" : question_vote,
+        "question_comment_count":question.comments.count(),
+        "answer" : answer_form,
+        "answers" : page_objects.object_list,
+        "user_answer_votes": user_answer_votes,
+        "tags" : question.tags.all(),
+        "tab_id" : view_id,
+        "favorited" : favorited,
+        "similar_questions" : Question.objects.get_similar_questions(question),
+        "context" : {
+            'is_paginated' : True,
+            'pages': objects_list.num_pages,
+            'page': page,
+            'has_previous': page_objects.has_previous(),
+            'has_next': page_objects.has_next(),
+            'previous': page_objects.previous_page_number(),
+            'next': page_objects.next_page_number(),
+            'base_url' : request.path + '?sort=%s&' % view_id,
+            'extend_url' : "#sort-top"
+        }
+        }, context_instance=RequestContext(request))
+
+@login_required
+def close(request, id):
+    question = get_object_or_404(Question, id=id)
+    if not can_close_question(request.user, question):
+        return HttpResponse('Permission denied.')
+    if request.method == 'POST':
+        form = CloseForm(request.POST)
+        if form.is_valid():
+            reason = form.cleaned_data['reason']
+            question.closed = True
+            question.closed_by = request.user
+            question.closed_at = datetime.datetime.now()
+            question.close_reason = reason
+            question.save()
+        return HttpResponseRedirect(question.get_absolute_url())
+    else:
+        form = CloseForm()
+        return render_to_response('close.html', {
+            'form' : form,
+            'question' : question,
+            }, context_instance=RequestContext(request))
+
+@login_required
+def reopen(request, id):
+    question = get_object_or_404(Question, id=id)
+    # open question
+    if not can_reopen_question(request.user, question):
+        return HttpResponse('Permission denied.')
+    if request.method == 'POST' :
+        Question.objects.filter(id=question.id).update(closed=False,
+            closed_by=None, closed_at=None, close_reason=None)
+        return HttpResponseRedirect(question.get_absolute_url())
+    else:
+        return render_to_response('reopen.html', {
+            'question' : question,
+            }, context_instance=RequestContext(request))
+
+@login_required
+def edit_question(request, id):
+    question = get_object_or_404(Question, id=id)
+    if question.deleted and not can_view_deleted_post(request.user, question):
+        raise Http404
+    if can_edit_post(request.user, question):
+        return _edit_question(request, question)
+    elif can_retag_questions(request.user):
+        return _retag_question(request, question)
+    else:
+        raise Http404
+
+def _retag_question(request, question):
+    if request.method == 'POST':
+        form = RetagQuestionForm(question, request.POST)
+        if form.is_valid():
+            if form.has_changed():
+                latest_revision = question.get_latest_revision()
+                retagged_at = datetime.datetime.now()
+                # Update the Question itself
+                Question.objects.filter(id=question.id).update(
+                    tagnames         = form.cleaned_data['tags'],
+                    last_edited_at   = retagged_at,
+                    last_edited_by   = request.user,
+                    last_activity_at = retagged_at,
+                    last_activity_by = request.user
+                )
+                # Update the Question's tag associations
+                tags_updated = Question.objects.update_tags(question,
+                    form.cleaned_data['tags'], request.user)
+                # Create a new revision
+                QuestionRevision.objects.create(
+                    question   = question,
+                    title      = latest_revision.title,
+                    author     = request.user,
+                    revised_at = retagged_at,
+                    tagnames   = form.cleaned_data['tags'],
+                    summary    = CONST['retagged'],
+                    text       = latest_revision.text
+                )
+                # send tags updated singal
+                tags_updated.send(sender=question.__class__, question=question)
+
+            return HttpResponseRedirect(question.get_absolute_url())
+    else:
+        form = RetagQuestionForm(question)
+    return render_to_response('question_retag.html', {
+        'question': question,
+        'form' : form,
+        'tags' : _get_tags_cache_json(),
+    }, context_instance=RequestContext(request))
+
+
+def _edit_question(request, question):
+    latest_revision = question.get_latest_revision()
+    revision_form = None
+    if request.method == 'POST':
+        if 'select_revision' in request.POST:
+            # user has changed revistion number
+            revision_form = RevisionForm(question, latest_revision, request.POST)
+            if revision_form.is_valid():
+                # Replace with those from the selected revision
+                form = EditQuestionForm(question,
+                    QuestionRevision.objects.get(question=question,
+                        revision=revision_form.cleaned_data['revision']))
+            else:
+                form = EditQuestionForm(question, latest_revision, request.POST)
+        else:
+            # Always check modifications against the latest revision
+            form = EditQuestionForm(question, latest_revision, request.POST)
+            if form.is_valid():
+                html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
+                if form.has_changed():
+                    edited_at = datetime.datetime.now()
+                    tags_changed = (latest_revision.tagnames !=
+                                    form.cleaned_data['tags'])
+                    tags_updated = False
+                    # Update the Question itself
+                    updated_fields = {
+                        'title': form.cleaned_data['title'],
+                        'last_edited_at': edited_at,
+                        'last_edited_by': request.user,
+                        'last_activity_at': edited_at,
+                        'last_activity_by': request.user,
+                        'tagnames': form.cleaned_data['tags'],
+                        'summary': strip_tags(html)[:120],
+                        'html': html,
+                    }
+
+                    # only save when it's checked
+                    # because wiki doesn't allow to be edited if last version has been enabled already
+                    # and we make sure this in forms.
+                    if ('wiki' in form.cleaned_data and
+                        form.cleaned_data['wiki']):
+                        updated_fields['wiki'] = True
+                        updated_fields['wikified_at'] = edited_at
+
+                    Question.objects.filter(
+                        id=question.id).update(**updated_fields)
+                    # Update the Question's tag associations
+                    if tags_changed:
+                        tags_updated = Question.objects.update_tags(
+                            question, form.cleaned_data['tags'], request.user)
+                    # Create a new revision
+                    revision = QuestionRevision(
+                        question   = question,
+                        title      = form.cleaned_data['title'],
+                        author     = request.user,
+                        revised_at = edited_at,
+                        tagnames   = form.cleaned_data['tags'],
+                        text       = form.cleaned_data['text'],
+                    )
+                    if form.cleaned_data['summary']:
+                        revision.summary = form.cleaned_data['summary']
+                    else:
+                        revision.summary = 'No.%s Revision' % latest_revision.revision
+                    revision.save()
+
+                return HttpResponseRedirect(question.get_absolute_url())
+    else:
+
+        revision_form = RevisionForm(question, latest_revision)
+        form = EditQuestionForm(question, latest_revision)
+    return render_to_response('question_edit.html', {
+        'question': question,
+        'revision_form': revision_form,
+        'form' : form,
+        'tags' : _get_tags_cache_json()
+    }, context_instance=RequestContext(request))
+
+
+@login_required
+def edit_answer(request, id):
+    answer = get_object_or_404(Answer, id=id)
+    if answer.deleted and not can_view_deleted_post(request.user, answer):
+        raise Http404
+    elif not can_edit_post(request.user, answer):
+        raise Http404
+    else:
+        latest_revision = answer.get_latest_revision()
+        if request.method == "POST":
+            if 'select_revision' in request.POST:
+                # user has changed revistion number
+                revision_form = RevisionForm(answer, latest_revision, request.POST)
+                if revision_form.is_valid():
+                    # Replace with those from the selected revision
+                    form = EditAnswerForm(answer,
+                        AnswerRevision.objects.get(answer=answer,
+                            revision=revision_form.cleaned_data['revision']))
+                else:
+                    form = EditAnswerForm(answer, latest_revision, request.POST)
+            else:
+                form = EditAnswerForm(answer, latest_revision, request.POST)
+                if form.is_valid():
+                    html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
+                    if form.has_changed():
+                        edited_at = datetime.datetime.now()
+                        updated_fields = {
+                            'last_edited_at': edited_at,
+                            'last_edited_by': request.user,
+                            'html': html,
+                        }
+                        Answer.objects.filter(id=answer.id).update(**updated_fields)
+
+                        revision = AnswerRevision(
+                            answer     = answer,
+                            author     = request.user,
+                            revised_at = edited_at,
+                            text       = form.cleaned_data['text']
+                        )
+
+                        if form.cleaned_data['summary']:
+                            revision.summary = form.cleaned_data['summary']
+                        else:
+                            revision.summary = 'No.%s Revision' % latest_revision.revision
+                        revision.save()
+
+                        answer.question.last_activity_at = edited_at
+                        answer.question.last_activity_by = request.user
+                        answer.question.save()
+
+                    return HttpResponseRedirect(answer.get_absolute_url())
+        else:
+            revision_form = RevisionForm(answer, latest_revision)
+            form = EditAnswerForm(answer, latest_revision)
+        return render_to_response('answer_edit.html', {
+        'answer': answer,
+        'revision_form': revision_form,
+        'form' : form,
+    }, context_instance=RequestContext(request))
+
+QUESTION_REVISION_TEMPLATE = ('<h1>%(title)s</h1>\n'
+    '<div class="text">%(html)s</div>\n'
+    '<div class="tags">%(tags)s</div>')
+def question_revisions(request, id):
+    post = get_object_or_404(Question, id=id)
+    revisions = list(post.revisions.all())
+    for i, revision in enumerate(revisions):
+        revision.html = QUESTION_REVISION_TEMPLATE % {
+            'title': revision.title,
+            'html': sanitize_html(markdowner.convert(revision.text)),
+            'tags': ' '.join(['<a class="post-tag">%s</a>' % tag
+                              for tag in revision.tagnames.split(' ')]),
+        }
+        if i > 0:
+            revisions[i - 1].diff = htmldiff(revision.html,
+                                             revisions[i - 1].html)
+        else:
+            revisions[i - 1].diff = QUESTION_REVISION_TEMPLATE % {
+                'title': revisions[0].title,
+                'html': sanitize_html(markdowner.convert(revisions[0].text)),
+                'tags': ' '.join(['<a class="post-tag">%s</a>' % tag
+                                  for tag in revisions[0].tagnames.split(' ')]),
+            }
+            revisions[i - 1].summary = None
+    return render_to_response('revisions_question.html', {
+        'post': post,
+        'revisions': revisions,
+    }, context_instance=RequestContext(request))
+
+ANSWER_REVISION_TEMPLATE = ('<div class="text">%(html)s</div>')
+def answer_revisions(request, id):
+    post = get_object_or_404(Answer, id=id)
+    revisions = list(post.revisions.all())
+    for i, revision in enumerate(revisions):
+        revision.html = ANSWER_REVISION_TEMPLATE % {
+            'html': sanitize_html(markdowner.convert(revision.text))
+        }
+        if i > 0:
+            revisions[i - 1].diff = htmldiff(revision.html,
+                                             revisions[i - 1].html)
+        else:
+            revisions[i - 1].diff = revisions[i-1].text
+            revisions[i - 1].summary = None
+    return render_to_response('revisions_answer.html', {
+        'post': post,
+        'revisions': revisions,
+    }, context_instance=RequestContext(request))
+
+def answer(request, id):
+    question = get_object_or_404(Question, id=id)
+    if request.method == "POST":
+        form = AnswerForm(question, request.user, request.POST)
+        if form.is_valid():
+            wiki = form.cleaned_data['wiki']
+            text = form.cleaned_data['text']
+            update_time = datetime.datetime.now()
+
+            if request.user.is_authenticated():
+                create_new_answer(
+                        question=question,
+                        author=request.user,
+                        added_at=update_time,
+                        wiki=wiki,
+                        text=text,
+                        email_notify=form.cleaned_data['email_notify']
+                    )
+            else:
+                request.session.flush()
+                html = sanitize_html(markdowner.convert(text))
+                summary = strip_tags(html)[:120]
+                anon = AnonymousAnswer(
+                    question = question,
+                    wiki = wiki,
+                    text = text,
+                    summary = summary,
+                    session_key = request.session.session_key,
+                    ip_addr = request.META['REMOTE_ADDR'],
+                    )
+                anon.save()
+                return HttpResponseRedirect('/account/signin/newanswer')
+
+    return HttpResponseRedirect(question.get_absolute_url())
+
+def tags(request):
+    stag = ""
+    is_paginated = True
+    sortby = request.GET.get('sort', 'used')
+    try:
+        page = int(request.GET.get('page', '1'))
+    except ValueError:
+        page = 1
+
+    if request.method == "GET":
+        stag = request.GET.get("q", "").strip()
+        if stag is not None:
+            objects_list = Paginator(Tag.objects.filter(deleted=False).exclude(used_count=0).extra(where=['name like %s'], params=['%' + stag + '%']), DEFAULT_PAGE_SIZE)
+        else:
+            if sortby == "name":
+                objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("name"), DEFAULT_PAGE_SIZE)
+            else:
+                objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("-used_count"), DEFAULT_PAGE_SIZE)
+
+    try:
+        tags = objects_list.page(page)
+    except (EmptyPage, InvalidPage):
+        tags = objects_list.page(objects_list.num_pages)
+
+    return render_to_response('tags.html', {
+        "tags" : tags,
+        "stag" : stag,
+        "tab_id" : sortby,
+        "keywords" : stag,
+        "context" : {
+            'is_paginated' : is_paginated,
+            'pages': objects_list.num_pages,
+            'page': page,
+            'has_previous': tags.has_previous(),
+            'has_next': tags.has_next(),
+            'previous': tags.previous_page_number(),
+            'next': tags.next_page_number(),
+            'base_url' : '/tags/?sort=%s&' % sortby
+        }
+
+        }, context_instance=RequestContext(request))
+
+def tag(request, tag):
+    return questions(request, tagname=tag)
+
+def vote(request, id):
+    """
+    vote_type:
+        acceptAnswer : 0,
+        questionUpVote : 1,
+        questionDownVote : 2,
+        favorite : 4,
+        answerUpVote: 5,
+        answerDownVote:6,
+        offensiveQuestion : 7,
+        offensiveAnswer:8,
+        removeQuestion: 9,
+        removeAnswer:10
+        questionSubscribeUpdates:11
+
+    accept answer code:
+        response_data['allowed'] = -1, Accept his own answer   0, no allowed - Anonymous    1, Allowed - by default
+        response_data['success'] =  0, failed                                               1, Success - by default
+        response_data['status']  =  0, By default                                           1, Answer has been accepted already(Cancel)
+
+    vote code:
+        allowed = -3, Don't have enough votes left
+                  -2, Don't have enough reputation score
+                  -1, Vote his own post
+                   0, no allowed - Anonymous
+                   1, Allowed - by default
+        status  =  0, By default
+                   1, Cancel
+                   2, Vote is too old to be canceled
+
+    offensive code:
+        allowed = -3, Don't have enough flags left
+                  -2, Don't have enough reputation score to do this
+                   0, not allowed
+                   1, allowed
+        status  =  0, by default
+                   1, can't do it again
+    """
+    response_data = {
+        "allowed": 1,
+        "success": 1,
+        "status" : 0,
+        "count"  : 0,
+        "message" : ''
+    }
+
+    def can_vote(vote_score, user):
+        if vote_score == 1:
+            return can_vote_up(request.user)
+        else:
+            return can_vote_down(request.user)
+
+    try:
+        if not request.user.is_authenticated():
+            response_data['allowed'] = 0
+            response_data['success'] = 0
+
+        elif request.is_ajax():
+            question = get_object_or_404(Question, id=id)
+            vote_type = request.POST.get('type')
+
+            #accept answer
+            if vote_type == '0':
+                answer_id = request.POST.get('postId')
+                answer = get_object_or_404(Answer, id=answer_id)
+                # make sure question author is current user
+                if question.author == request.user:
+                    # answer user who is also question author is not allow to accept answer
+                    if answer.author == question.author:
+                        response_data['success'] = 0
+                        response_data['allowed'] = -1
+                    # check if answer has been accepted already
+                    elif answer.accepted:
+                        onAnswerAcceptCanceled(answer, request.user)
+                        response_data['status'] = 1
+                    else:
+                        # set other answers in this question not accepted first
+                        for answer_of_question in Answer.objects.get_answers_from_question(question, request.user):
+                            if answer_of_question != answer and answer_of_question.accepted:
+                                onAnswerAcceptCanceled(answer_of_question, request.user)
+
+                        #make sure retrieve data again after above author changes, they may have related data
+                        answer = get_object_or_404(Answer, id=answer_id)
+                        onAnswerAccept(answer, request.user)
+                else:
+                    response_data['allowed'] = 0
+                    response_data['success'] = 0
+            # favorite
+            elif vote_type == '4':
+                has_favorited = False
+                fav_questions = FavoriteQuestion.objects.filter(question=question)
+                # if the same question has been favorited before, then delete it
+                if fav_questions is not None:
+                    for item in fav_questions:
+                        if item.user == request.user:
+                            item.delete()
+                            response_data['status'] = 1
+                            response_data['count']  = len(fav_questions) - 1
+                            if response_data['count'] < 0:
+                                response_data['count'] = 0
+                            has_favorited = True
+                # if above deletion has not been executed, just insert a new favorite question
+                if not has_favorited:
+                    new_item = FavoriteQuestion(question=question, user=request.user)
+                    new_item.save()
+                    response_data['count']  = FavoriteQuestion.objects.filter(question=question).count()
+                Question.objects.update_favorite_count(question)
+
+            elif vote_type in ['1', '2', '5', '6']:
+                post_id = id
+                post = question
+                vote_score = 1
+                if vote_type in ['5', '6']:
+                    answer_id = request.POST.get('postId')
+                    answer = get_object_or_404(Answer, id=answer_id)
+                    post_id = answer_id
+                    post = answer
+                if vote_type in ['2', '6']:
+                    vote_score = -1
+
+                if post.author == request.user:
+                    response_data['allowed'] = -1
+                elif not can_vote(vote_score, request.user):
+                    response_data['allowed'] = -2
+                elif post.votes.filter(user=request.user).count() > 0:
+                    vote = post.votes.filter(user=request.user)[0]
+                    # unvote should be less than certain time
+                    if (datetime.datetime.now().day - vote.voted_at.day) >= VOTE_RULES['scope_deny_unvote_days']:
+                        response_data['status'] = 2
+                    else:
+                        voted = vote.vote
+                        if voted > 0:
+                            # cancel upvote
+                            onUpVotedCanceled(vote, post, request.user)
+
+                        else:
+                            # cancel downvote
+                            onDownVotedCanceled(vote, post, request.user)
+
+                        response_data['status'] = 1
+                        response_data['count'] = post.score
+                elif Vote.objects.get_votes_count_today_from_user(request.user) >= VOTE_RULES['scope_votes_per_user_per_day']:
+                    response_data['allowed'] = -3
+                else:
+                    vote = Vote(user=request.user, content_object=post, vote=vote_score, voted_at=datetime.datetime.now())
+                    if vote_score > 0:
+                        # upvote
+                        onUpVoted(vote, post, request.user)
+                    else:
+                        # downvote
+                        onDownVoted(vote, post, request.user)
+
+                    votes_left = VOTE_RULES['scope_votes_per_user_per_day'] - Vote.objects.get_votes_count_today_from_user(request.user)
+                    if votes_left <= VOTE_RULES['scope_warn_votes_left']:
+                        response_data['message'] = u'%s votes left' % votes_left
+                    response_data['count'] = post.score
+            elif vote_type in ['7', '8']:
+                post = question
+                post_id = id
+                if vote_type == '8':
+                    post_id = request.POST.get('postId')
+                    post = get_object_or_404(Answer, id=post_id)
+
+                if FlaggedItem.objects.get_flagged_items_count_today(request.user) >= VOTE_RULES['scope_flags_per_user_per_day']:
+                    response_data['allowed'] = -3
+                elif not can_flag_offensive(request.user):
+                    response_data['allowed'] = -2
+                elif post.flagged_items.filter(user=request.user).count() > 0:
+                    response_data['status'] = 1
+                else:
+                    item = FlaggedItem(user=request.user, content_object=post, flagged_at=datetime.datetime.now())
+                    onFlaggedItem(item, post, request.user)
+                    response_data['count'] = post.offensive_flag_count
+                    # send signal when question or answer be marked offensive
+                    mark_offensive.send(sender=post.__class__, instance=post, mark_by=request.user)
+            elif vote_type in ['9', '10']:
+                post = question
+                post_id = id
+                if vote_type == '10':
+                    post_id = request.POST.get('postId')
+                    post = get_object_or_404(Answer, id=post_id)
+
+                if not can_delete_post(request.user, post):
+                    response_data['allowed'] = -2
+                elif post.deleted:
+                    onDeleteCanceled(post, request.user)
+                    response_data['status'] = 1
+                else:
+                    onDeleted(post, request.user)
+                    delete_post_or_answer.send(sender=post.__class__, instance=post, delete_by=request.user)
+            elif vote_type == '11':#subscribe q updates
+                user = request.user
+                if user.is_authenticated():
+                    try:
+                        EmailFeed.objects.get(feed_id=question.id,subscriber_id=user.id,feed_content_type=question_type)
+                    except EmailFeed.DoesNotExist:
+                        feed = EmailFeed(subscriber=user,content=question)
+                        feed.save()
+                        if settings.EMAIL_VALIDATION == 'on' and user.email_isvalid == False:
+                            response_data['message'] = _('subscription saved, %(email)s needs validation') % {'email':user.email}
+                    #response_data['status'] = 1
+                    #responst_data['allowed'] = 1
+                else:
+                    pass
+                    #response_data['status'] = 0
+                    #response_data['allowed'] = 0
+            elif vote_type == '12':#unsubscribe q updates
+                user = request.user
+                if user.is_authenticated():
+                    try:
+                        feed = EmailFeed.objects.get(feed_id=question.id,subscriber_id=user.id)
+                        feed.delete()
+                    except EmailFeed.DoesNotExist:
+                        pass
+                    
+        else:
+            response_data['success'] = 0
+            response_data['message'] = u'Request mode is not supported. Please try again.'
+
+        data = simplejson.dumps(response_data)
+
+    except Exception, e:
+        response_data['message'] = str(e)
+        data = simplejson.dumps(response_data)
+    return HttpResponse(data, mimetype="application/json")
+
+def users(request):
+    is_paginated = True
+    sortby = request.GET.get('sort', 'reputation')
+    suser = request.REQUEST.get('q',  "")
+    try:
+        page = int(request.GET.get('page', '1'))
+    except ValueError:
+        page = 1
+
+    if suser == "":
+        if sortby == "newest":
+            objects_list = Paginator(User.objects.all().order_by('-date_joined'), USERS_PAGE_SIZE)
+        elif sortby == "last":
+            objects_list = Paginator(User.objects.all().order_by('date_joined'), USERS_PAGE_SIZE)
+        elif sortby == "user":
+            objects_list = Paginator(User.objects.all().order_by('username'), USERS_PAGE_SIZE)
+        # default
+        else:
+            objects_list = Paginator(User.objects.all().order_by('-reputation'), USERS_PAGE_SIZE)
+        base_url = '/users/?sort=%s&' % sortby
+    else:
+        sortby = "reputation"
+        objects_list = Paginator(User.objects.extra(where=['username like %s'], params=['%' + suser + '%']).order_by('-reputation'), USERS_PAGE_SIZE)
+        base_url = '/users/?name=%s&sort=%s&' % (suser, sortby)
+
+    try:
+        users = objects_list.page(page)
+    except (EmptyPage, InvalidPage):
+        users = objects_list.page(objects_list.num_pages)
+
+    return render_to_response('users.html', {
+        "users" : users,
+        "suser" : suser,
+        "keywords" : suser,
+        "tab_id" : sortby,
+        "context" : {
+            'is_paginated' : is_paginated,
+            'pages': objects_list.num_pages,
+            'page': page,
+            'has_previous': users.has_previous(),
+            'has_next': users.has_next(),
+            'previous': users.previous_page_number(),
+            'next': users.next_page_number(),
+            'base_url' : base_url
+        }
+
+        }, context_instance=RequestContext(request))
+
+def user(request, id):
+    sort = request.GET.get('sort', 'stats')
+    user_view = dict((v.id, v) for v in USER_TEMPLATE_VIEWS).get(sort, USER_TEMPLATE_VIEWS[0])
+    from forum import views
+    func = getattr(views, user_view.view_name)
+    return func(request, id, user_view)
+
+@login_required
+def edit_user(request, id):
+    user = get_object_or_404(User, id=id)
+    if request.user != user:
+        raise Http404
+    if request.method == "POST":
+        form = EditUserForm(user, request.POST)
+        if form.is_valid():
+            new_email = sanitize_html(form.cleaned_data['email'])
+
+            from django_authopenid.views import set_new_email
+            set_new_email(user, new_email)
+
+            user.real_name = sanitize_html(form.cleaned_data['realname'])
+            user.website = sanitize_html(form.cleaned_data['website'])
+            user.location = sanitize_html(form.cleaned_data['city'])
+            user.date_of_birth = sanitize_html(form.cleaned_data['birthday'])
+            if len(user.date_of_birth) == 0:
+                user.date_of_birth = '1900-01-01'
+            user.about = sanitize_html(form.cleaned_data['about'])
+
+            user.save()
+            # send user updated singal if full fields have been updated
+            if user.email and user.real_name and user.website and user.location and \
+                user.date_of_birth and user.about:
+                user_updated.send(sender=user.__class__, instance=user, updated_by=user)
+            return HttpResponseRedirect(user.get_profile_url())
+    else:
+        form = EditUserForm(user)
+    return render_to_response('user_edit.html', {
+        'form' : form,
+    }, context_instance=RequestContext(request))
+
+def user_stats(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    questions = Question.objects.extra(
+        select={
+            'vote_count' : 'question.score',
+            'favorited_myself' : 'SELECT count(*) FROM favorite_question f WHERE f.user_id = %s AND f.question_id = question.id',
+            'la_user_id' : 'auth_user.id',
+            'la_username' : 'auth_user.username',
+            'la_user_gold' : 'auth_user.gold',
+            'la_user_silver' : 'auth_user.silver',
+            'la_user_bronze' : 'auth_user.bronze',
+            'la_user_reputation' : 'auth_user.reputation'
+            },
+        select_params=[user_id],
+        tables=['question', 'auth_user'],
+        where=['question.deleted = 0 AND question.author_id=%s AND question.last_activity_by_id = auth_user.id'],
+        params=[user_id],
+        order_by=['-vote_count', '-last_activity_at']
+    ).values('vote_count',
+             'favorited_myself',
+             'id',
+             'title',
+             'author_id',
+             'added_at',
+             'answer_accepted',
+             'answer_count',
+             'comment_count',
+             'view_count',
+             'favourite_count',
+             'summary',
+             'tagnames',
+             'vote_up_count',
+             'vote_down_count',
+             'last_activity_at',
+             'la_user_id',
+             'la_username',
+             'la_user_gold',
+             'la_user_silver',
+             'la_user_bronze',
+             'la_user_reputation')[:100]
+
+    answered_questions = Question.objects.extra(
+        select={
+            'vote_up_count' : 'answer.vote_up_count',
+            'vote_down_count' : 'answer.vote_down_count',
+            'answer_id' : 'answer.id',
+            'accepted' : 'answer.accepted',
+            'vote_count' : 'answer.score',
+            'comment_count' : 'answer.comment_count'
+            },
+        tables=['question', 'answer'],
+        where=['answer.deleted=0 AND answer.author_id=%s AND answer.question_id=question.id'],
+        params=[user_id],
+        order_by=['-vote_count', '-answer_id'],
+        select_params=[user_id]
+    ).distinct().values('comment_count',
+                        'id',
+                        'answer_id',
+                        'title',
+                        'author_id',
+                        'accepted',
+                        'vote_count',
+                        'answer_count',
+                        'vote_up_count',
+                        'vote_down_count')[:100]
+    up_votes = Vote.objects.get_up_vote_count_from_user(user)
+    down_votes = Vote.objects.get_down_vote_count_from_user(user)
+    votes_today = Vote.objects.get_votes_count_today_from_user(user)
+    votes_total = VOTE_RULES['scope_votes_per_user_per_day']
+    tags = user.created_tags.all().order_by('-used_count')[:50]
+    awards = Award.objects.extra(
+        select={'id': 'badge.id', 'count': 'count(badge_id)', 'name':'badge.name', 'description': 'badge.description', 'type': 'badge.type'},
+        tables=['award', 'badge'],
+        order_by=['-awarded_at'],
+        where=['user_id=%s AND badge_id=badge.id'],
+        params=[user.id]
+    ).values('id', 'count', 'name', 'description', 'type')
+    total_awards = awards.count()
+    awards.query.group_by = ['badge_id']
+
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+        "questions" : questions,
+        "answered_questions" : answered_questions,
+        "up_votes" : up_votes,
+        "down_votes" : down_votes,
+        "total_votes": up_votes + down_votes,
+        "votes_today_left": votes_total-votes_today,
+        "votes_total_per_day": votes_total,
+        "tags" : tags,
+        "awards": awards,
+        "total_awards" : total_awards,
+    }, context_instance=RequestContext(request))
+
+def user_recent(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    def get_type_name(type_id):
+        for item in TYPE_ACTIVITY:
+            if type_id in item:
+                return item[1]
+
+    class Event:
+        def __init__(self, time, type, title, summary, answer_id, question_id):
+            self.time = time
+            self.type = get_type_name(type)
+            self.type_id = type
+            self.title = title
+            self.summary = summary
+            self.title_link = u'/questions/%s/%s#%s' %(question_id, title, answer_id)\
+                if int(answer_id) > 0 else u'/questions/%s/%s' %(question_id, title)
+    class AwardEvent:
+        def __init__(self, time, type, id):
+            self.time = time
+            self.type = get_type_name(type)
+            self.type_id = type
+            self.badge = get_object_or_404(Badge, id=id)
+
+    activities = []
+    # ask questions
+    questions = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'active_at' : 'activity.active_at',
+            'activity_type' : 'activity.activity_type'
+            },
+        tables=['activity', 'question'],
+        where=['activity.content_type_id = %s AND activity.object_id = ' +
+            'question.id AND activity.user_id = %s AND activity.activity_type = %s'],
+        params=[question_type_id, user_id, TYPE_ACTIVITY_ASK_QUESTION],
+        order_by=['-activity.active_at']
+    ).values(
+            'title',
+            'question_id',
+            'active_at',
+            'activity_type'
+            )
+    if len(questions) > 0:
+        questions = [(Event(q['active_at'], q['activity_type'], q['title'], '', '0', \
+            q['question_id'])) for q in questions]
+        activities.extend(questions)
+
+    # answers
+    answers = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'active_at' : 'activity.active_at',
+            'activity_type' : 'activity.activity_type'
+            },
+        tables=['activity', 'answer', 'question'],
+        where=['activity.content_type_id = %s AND activity.object_id = answer.id AND ' + 
+            'answer.question_id=question.id AND activity.user_id=%s AND activity.activity_type=%s'],
+        params=[answer_type_id, user_id, TYPE_ACTIVITY_ANSWER],
+        order_by=['-activity.active_at']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'active_at',
+            'activity_type'
+            )
+    if len(answers) > 0:
+        answers = [(Event(q['active_at'], q['activity_type'], q['title'], '', q['answer_id'], \
+            q['question_id'])) for q in answers]
+        activities.extend(answers)
+
+    # question comments
+    comments = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'comment.object_id',
+            'added_at' : 'comment.added_at',
+            'activity_type' : 'activity.activity_type'
+            },
+        tables=['activity', 'question', 'comment'],
+
+        where=['activity.content_type_id = %s AND activity.object_id = comment.id AND '+
+            'activity.user_id = comment.user_id AND comment.object_id=question.id AND '+
+            'comment.content_type_id=%s AND activity.user_id = %s AND activity.activity_type=%s'],
+        params=[comment_type_id, question_type_id, user_id, TYPE_ACTIVITY_COMMENT_QUESTION],
+        order_by=['-comment.added_at']
+    ).values(
+            'title',
+            'question_id',
+            'added_at',
+            'activity_type'
+            )
+
+    if len(comments) > 0:
+        comments = [(Event(q['added_at'], q['activity_type'], q['title'], '', '0', \
+            q['question_id'])) for q in comments]
+        activities.extend(comments)
+
+    # answer comments
+    comments = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'added_at' : 'comment.added_at',
+            'activity_type' : 'activity.activity_type'
+            },
+        tables=['activity', 'question', 'answer', 'comment'],
+
+        where=['activity.content_type_id = %s AND activity.object_id = comment.id AND '+
+            'activity.user_id = comment.user_id AND comment.object_id=answer.id AND '+
+            'comment.content_type_id=%s AND question.id = answer.question_id AND '+
+            'activity.user_id = %s AND activity.activity_type=%s'],
+        params=[comment_type_id, answer_type_id, user_id, TYPE_ACTIVITY_COMMENT_ANSWER],
+        order_by=['-comment.added_at']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'added_at',
+            'activity_type'
+            )
+
+    if len(comments) > 0:
+        comments = [(Event(q['added_at'], q['activity_type'], q['title'], '', q['answer_id'], \
+            q['question_id'])) for q in comments]
+        activities.extend(comments)
+
+    # question revisions
+    revisions = Activity.objects.extra(
+        select={
+            'title' : 'question_revision.title',
+            'question_id' : 'question_revision.question_id',
+            'added_at' : 'activity.active_at',
+            'activity_type' : 'activity.activity_type',
+            'summary' : 'question_revision.summary'
+            },
+        tables=['activity', 'question_revision'],
+        where=['activity.content_type_id = %s AND activity.object_id = question_revision.id AND '+
+            'activity.user_id = question_revision.author_id AND activity.user_id = %s AND '+
+            'activity.activity_type=%s'],
+        params=[question_revision_type_id, user_id, TYPE_ACTIVITY_UPDATE_QUESTION],
+        order_by=['-activity.active_at']
+    ).values(
+            'title',
+            'question_id',
+            'added_at',
+            'activity_type',
+            'summary'
+            )
+
+    if len(revisions) > 0:
+        revisions = [(Event(q['added_at'], q['activity_type'], q['title'], q['summary'], '0', \
+            q['question_id'])) for q in revisions]
+        activities.extend(revisions)
+
+    # answer revisions
+    revisions = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'added_at' : 'activity.active_at',
+            'activity_type' : 'activity.activity_type',
+            'summary' : 'answer_revision.summary'
+            },
+        tables=['activity', 'answer_revision', 'question', 'answer'],
+
+        where=['activity.content_type_id = %s AND activity.object_id = answer_revision.id AND '+
+            'activity.user_id = answer_revision.author_id AND activity.user_id = %s AND '+
+            'answer_revision.answer_id=answer.id AND answer.question_id = question.id AND '+
+            'activity.activity_type=%s'],
+        params=[answer_revision_type_id, user_id, TYPE_ACTIVITY_UPDATE_ANSWER],
+        order_by=['-activity.active_at']
+    ).values(
+            'title',
+            'question_id',
+            'added_at',
+            'answer_id',
+            'activity_type',
+            'summary'
+            )
+
+    if len(revisions) > 0:
+        revisions = [(Event(q['added_at'], q['activity_type'], q['title'], q['summary'], \
+            q['answer_id'], q['question_id'])) for q in revisions]
+        activities.extend(revisions)
+
+    # accepted answers
+    accept_answers = Activity.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'added_at' : 'activity.active_at',
+            'activity_type' : 'activity.activity_type',
+            },
+        tables=['activity', 'answer', 'question'],
+        where=['activity.content_type_id = %s AND activity.object_id = answer.id AND '+
+            'activity.user_id = question.author_id AND activity.user_id = %s AND '+
+            'answer.question_id=question.id AND activity.activity_type=%s'],
+        params=[answer_type_id, user_id, TYPE_ACTIVITY_MARK_ANSWER],
+        order_by=['-activity.active_at']
+    ).values(
+            'title',
+            'question_id',
+            'added_at',
+            'activity_type',
+            )
+    if len(accept_answers) > 0:
+        accept_answers = [(Event(q['added_at'], q['activity_type'], q['title'], '', '0', \
+            q['question_id'])) for q in accept_answers]
+        activities.extend(accept_answers)
+    #award history
+    awards = Activity.objects.extra(
+        select={
+            'badge_id' : 'badge.id',
+            'awarded_at': 'award.awarded_at',
+            'activity_type' : 'activity.activity_type'
+            },
+        tables=['activity', 'award', 'badge'],
+        where=['activity.user_id = award.user_id AND activity.user_id = %s AND '+
+            'award.badge_id=badge.id AND activity.object_id=award.id AND activity.activity_type=%s'],
+        params=[user_id, TYPE_ACTIVITY_PRIZE],
+        order_by=['-activity.active_at']
+    ).values(
+            'badge_id',
+            'awarded_at',
+            'activity_type'
+            )
+    if len(awards) > 0:
+        awards = [(AwardEvent(q['awarded_at'], q['activity_type'], q['badge_id'])) for q in awards]
+        activities.extend(awards)
+
+    activities.sort(lambda x,y: cmp(y.time, x.time))
+
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+        "activities" : activities[:user_view.data_size]
+    }, context_instance=RequestContext(request))
+
+def user_responses(request, user_id, user_view):
+    """
+    We list answers for question, comments, and answer accepted by others for this user.
+    """
+    class Response:
+        def __init__(self, type, title, question_id, answer_id, time, username, user_id, content):
+            self.type = type
+            self.title = title
+            self.titlelink = u'/questions/%s/%s#%s' % (question_id, title, answer_id)
+            self.time = time
+            self.userlink = u'/users/%s/%s/' % (user_id, username)
+            self.username = username
+            self.content = u'%s ...' % strip_tags(content)[:300]
+
+        def __unicode__(self):
+            return u'%s %s' % (self.type, self.titlelink)
+
+    user = get_object_or_404(User, id=user_id)
+    responses = []
+    answers = Answer.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'added_at' : 'answer.added_at',
+            'html' : 'answer.html',
+            'username' : 'auth_user.username',
+            'user_id' : 'auth_user.id'
+            },
+        select_params=[user_id],
+        tables=['answer', 'question', 'auth_user'],
+        where=['answer.question_id = question.id AND answer.deleted=0 AND question.deleted = 0 AND '+
+            'question.author_id = %s AND answer.author_id <> %s AND answer.author_id=auth_user.id'],
+        params=[user_id, user_id],
+        order_by=['-answer.id']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'added_at',
+            'html',
+            'username',
+            'user_id'
+            )
+    if len(answers) > 0:
+        answers = [(Response(TYPE_RESPONSE['QUESTION_ANSWERED'], a['title'], a['question_id'],
+        a['answer_id'], a['added_at'], a['username'], a['user_id'], a['html'])) for a in answers]
+        responses.extend(answers)
+
+
+    # question comments
+    comments = Comment.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'comment.object_id',
+            'added_at' : 'comment.added_at',
+            'comment' : 'comment.comment',
+            'username' : 'auth_user.username',
+            'user_id' : 'auth_user.id'
+            },
+        tables=['question', 'auth_user', 'comment'],
+        where=['question.deleted = 0 AND question.author_id = %s AND comment.object_id=question.id AND '+
+            'comment.content_type_id=%s AND comment.user_id <> %s AND comment.user_id = auth_user.id'],
+        params=[user_id, question_type_id, user_id],
+        order_by=['-comment.added_at']
+    ).values(
+            'title',
+            'question_id',
+            'added_at',
+            'comment',
+            'username',
+            'user_id'
+            )
+
+    if len(comments) > 0:
+        comments = [(Response(TYPE_RESPONSE['QUESTION_COMMENTED'], c['title'], c['question_id'],
+            '', c['added_at'], c['username'], c['user_id'], c['comment'])) for c in comments]
+        responses.extend(comments)
+
+    # answer comments
+    comments = Comment.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'added_at' : 'comment.added_at',
+            'comment' : 'comment.comment',
+            'username' : 'auth_user.username',
+            'user_id' : 'auth_user.id'
+            },
+        tables=['answer', 'auth_user', 'comment', 'question'],
+        where=['answer.deleted = 0 AND answer.author_id = %s AND comment.object_id=answer.id AND '+
+            'comment.content_type_id=%s AND comment.user_id <> %s AND comment.user_id = auth_user.id '+
+            'AND question.id = answer.question_id'],
+        params=[user_id, answer_type_id, user_id],
+        order_by=['-comment.added_at']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'added_at',
+            'comment',
+            'username',
+            'user_id'
+            )
+
+    if len(comments) > 0:
+        comments = [(Response(TYPE_RESPONSE['ANSWER_COMMENTED'], c['title'], c['question_id'],
+        c['answer_id'], c['added_at'], c['username'], c['user_id'], c['comment'])) for c in comments]
+        responses.extend(comments)
+
+    # answer has been accepted
+    answers = Answer.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'added_at' : 'answer.accepted_at',
+            'html' : 'answer.html',
+            'username' : 'auth_user.username',
+            'user_id' : 'auth_user.id'
+            },
+        select_params=[user_id],
+        tables=['answer', 'question', 'auth_user'],
+        where=['answer.question_id = question.id AND answer.deleted=0 AND question.deleted = 0 AND '+
+            'answer.author_id = %s AND answer.accepted=1 AND question.author_id=auth_user.id'],
+        params=[user_id],
+        order_by=['-answer.id']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'added_at',
+            'html',
+            'username',
+            'user_id'
+            )
+    if len(answers) > 0:
+        answers = [(Response(TYPE_RESPONSE['ANSWER_ACCEPTED'], a['title'], a['question_id'],
+            a['answer_id'], a['added_at'], a['username'], a['user_id'], a['html'])) for a in answers]
+        responses.extend(answers)
+
+    # sort posts by time
+    responses.sort(lambda x,y: cmp(y.time, x.time))
+
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+        "responses" : responses[:user_view.data_size],
+
+    }, context_instance=RequestContext(request))
+
+def user_votes(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    if not can_view_user_votes(request.user, user):
+        raise Http404
+    votes = []
+    question_votes = Vote.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 0,
+            'voted_at' : 'vote.voted_at',
+            'vote' : 'vote',
+            },
+        select_params=[user_id],
+        tables=['vote', 'question', 'auth_user'],
+        where=['vote.content_type_id = %s AND vote.user_id = %s AND vote.object_id = question.id '+
+            'AND vote.user_id=auth_user.id'],
+        params=[question_type_id, user_id],
+        order_by=['-vote.id']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'voted_at',
+            'vote',
+            )
+    if(len(question_votes) > 0):
+        votes.extend(question_votes)
+
+    answer_votes = Vote.objects.extra(
+        select={
+            'title' : 'question.title',
+            'question_id' : 'question.id',
+            'answer_id' : 'answer.id',
+            'voted_at' : 'vote.voted_at',
+            'vote' : 'vote',
+            },
+        select_params=[user_id],
+        tables=['vote', 'answer', 'question', 'auth_user'],
+        where=['vote.content_type_id = %s AND vote.user_id = %s AND vote.object_id = answer.id '+
+            'AND answer.question_id = question.id AND vote.user_id=auth_user.id'],
+        params=[answer_type_id, user_id],
+        order_by=['-vote.id']
+    ).values(
+            'title',
+            'question_id',
+            'answer_id',
+            'voted_at',
+            'vote',
+            )
+    if(len(answer_votes) > 0):
+        votes.extend(answer_votes)
+    votes.sort(lambda x,y: cmp(y['voted_at'], x['voted_at']))
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+        "votes" : votes[:user_view.data_size]
+
+    }, context_instance=RequestContext(request))
+
+def user_reputation(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    reputation = Repute.objects.extra(
+        select={'positive': 'sum(positive)', 'negative': 'sum(negative)', 'question_id':'question_id', 
+            'title': 'question.title'},
+        tables=['repute', 'question'],
+        order_by=['-reputed_at'],
+        where=['user_id=%s AND question_id=question.id'],
+        params=[user.id]
+    ).values('positive', 'negative', 'question_id', 'title', 'reputed_at', 'reputation')
+
+    reputation.query.group_by = ['question_id']
+
+    rep_list = []
+    for rep in Repute.objects.filter(user=user).order_by('reputed_at'):
+        dic = '[%s,%s]' % (calendar.timegm(rep.reputed_at.timetuple()) * 1000, rep.reputation)
+        rep_list.append(dic)
+    reps = ','.join(rep_list)
+    reps = '[%s]' % reps
+
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+        "reputation" : reputation,
+        "reps" : reps
+    }, context_instance=RequestContext(request))
+
+def user_favorites(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    questions = Question.objects.extra(
+        select={
+            'vote_count' : 'question.vote_up_count + question.vote_down_count',
+            'favorited_myself' : 'SELECT count(*) FROM favorite_question f WHERE f.user_id = %s '+
+                'AND f.question_id = question.id',
+            'la_user_id' : 'auth_user.id',
+            'la_username' : 'auth_user.username',
+            'la_user_gold' : 'auth_user.gold',
+            'la_user_silver' : 'auth_user.silver',
+            'la_user_bronze' : 'auth_user.bronze',
+            'la_user_reputation' : 'auth_user.reputation'
+            },
+        select_params=[user_id],
+        tables=['question', 'auth_user', 'favorite_question'],
+        where=['question.deleted = 0 AND question.last_activity_by_id = auth_user.id '+
+            'AND favorite_question.question_id = question.id AND favorite_question.user_id = %s'],
+        params=[user_id],
+        order_by=['-vote_count', '-question.id']
+    ).values('vote_count',
+             'favorited_myself',
+             'id',
+             'title',
+             'author_id',
+             'added_at',
+             'answer_accepted',
+             'answer_count',
+             'comment_count',
+             'view_count',
+             'favourite_count',
+             'summary',
+             'tagnames',
+             'vote_up_count',
+             'vote_down_count',
+             'last_activity_at',
+             'la_user_id',
+             'la_username',
+             'la_user_gold',
+             'la_user_silver',
+             'la_user_bronze',
+             'la_user_reputation')
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "questions" : questions[:user_view.data_size],
+        "view_user" : user
+    }, context_instance=RequestContext(request))
+
+
+def user_preferences(request, user_id, user_view):
+    user = get_object_or_404(User, id=user_id)
+    return render_to_response(user_view.template_file,{
+        "tab_name" : user_view.id,
+        "tab_description" : user_view.tab_description,
+        "page_title" : user_view.page_title,
+        "view_user" : user,
+    }, context_instance=RequestContext(request))
+
+def question_comments(request, id):
+    question = get_object_or_404(Question, id=id)
+    user = request.user
+    return __comments(request, question, 'question', user)
+
+def answer_comments(request, id):
+    answer = get_object_or_404(Answer, id=id)
+    user = request.user
+    return __comments(request, answer, 'answer', user)
+
+def __comments(request, obj, type, user):
+    # only support get comments by ajax now
+    if request.is_ajax():
+        if request.method == "GET":
+            return __generate_comments_json(obj, type, user)
+        elif request.method == "POST":
+            comment_data = request.POST.get('comment')
+            comment = Comment(content_object=obj, comment=comment_data, user=request.user)
+            comment.save()
+            obj.comment_count = obj.comment_count + 1
+            obj.save()
+            return __generate_comments_json(obj, type, user)
+
+def __generate_comments_json(obj, type, user):
+    comments = obj.comments.all().order_by('-id')
+    # {"Id":6,"PostId":38589,"CreationDate":"an hour ago","Text":"hello there!","UserDisplayName":"Jarrod Dixon","UserUrl":"/users/3/jarrod-dixon","DeleteUrl":null}
+    json_comments = []
+    for comment in comments:
+        comment_user = comment.user
+        delete_url = ""
+        if user != None and auth.can_delete_comment(user, comment):
+            #/posts/392845/comments/219852/delete
+            delete_url = "/" + type + "s/%s/comments/%s/delete/" % (obj.id, comment.id)
+        json_comments.append({"id" : comment.id,
+            "object_id" : obj.id,
+            "add_date" : comment.added_at.strftime('%Y-%m-%d'),
+            "text" : comment.comment,
+            "user_display_name" : comment_user.username,
+            "user_url" : "/users/%s/%s" % (comment_user.id, comment_user.username),
+            "delete_url" : delete_url
+        })
+
+    data = simplejson.dumps(json_comments)
+    return HttpResponse(data, mimetype="application/json")
+
+def delete_question_comment(request, question_id, comment_id):
+    if request.is_ajax():
+        question = get_object_or_404(Question, id=question_id)
+        comment = get_object_or_404(Comment, id=comment_id)
+
+        question.comments.remove(comment)
+        question.comment_count = question.comment_count - 1
+        question.save()
+        user = request.user
+        return __generate_comments_json(question, 'question', user)
+
+def delete_answer_comment(request, answer_id, comment_id):
+    if request.is_ajax():
+        answer = get_object_or_404(Answer, id=answer_id)
+        comment = get_object_or_404(Comment, id=comment_id)
+
+        answer.comments.remove(comment)
+        answer.comment_count = answer.comment_count - 1
+        answer.save()
+        user = request.user
+        return __generate_comments_json(answer, 'answer', user)
+
+def logout(request):
+    url = request.GET.get('next')
+    return render_to_response('logout.html', {
+        'next' : url,
+    }, context_instance=RequestContext(request))
+
+def badges(request):
+    badges = Badge.objects.all().order_by('type')
+    my_badges = []
+    if request.user.is_authenticated():
+        my_badges = Award.objects.filter(user=request.user)
+        my_badges.query.group_by = ['badge_id']
+
+    return render_to_response('badges.html', {
+        'badges' : badges,
+        'mybadges' : my_badges,
+    }, context_instance=RequestContext(request))
+
+def badge(request, id):
+    badge = get_object_or_404(Badge, id=id)
+    awards = Award.objects.extra(
+        select={'id': 'auth_user.id', 
+                'name': 'auth_user.username', 
+                'rep':'auth_user.reputation', 
+                'gold': 'auth_user.gold', 
+                'silver': 'auth_user.silver', 
+                'bronze': 'auth_user.bronze'},
+        tables=['award', 'auth_user'],
+        where=['badge_id=%s AND user_id=auth_user.id'],
+        params=[id]
+    ).values('id').distinct()
+
+    return render_to_response('badge.html', {
+        'awards' : awards,
+        'badge' : badge,
+    }, context_instance=RequestContext(request))
+
+def read_message(request):
+    if request.method == "POST":
+        if request.POST['formdata'] == 'required':
+            request.session['message_silent'] = 1
+            if request.user.is_authenticated():
+                request.user.delete_messages()
+    return HttpResponse('')
+
+def upload(request):
+    class FileTypeNotAllow(Exception):
+        pass
+    class FileSizeNotAllow(Exception):
+        pass
+    class UploadPermissionNotAuthorized(Exception):
+        pass
+
+    #<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>
+    xml_template = "<result><msg><![CDATA[%s]]></msg><error><![CDATA[%s]]></error><file_url>%s</file_url></result>"
+
+    try:
+        f = request.FILES['file-upload']
+        # check upload permission
+        if not can_upload_files(request.user):
+            raise UploadPermissionNotAuthorized
+
+        # check file type
+        file_name_suffix = os.path.splitext(f.name)[1].lower()
+        if not file_name_suffix in settings.ALLOW_FILE_TYPES:
+            raise FileTypeNotAllow
+
+        # genetate new file name
+        new_file_name = str(time.time()).replace('.', str(random.randint(0,100000))) + file_name_suffix
+        # use default storage to store file
+        default_storage.save(new_file_name, f)
+        # check file size
+        # byte
+        size = default_storage.size(new_file_name)
+        if size > settings.ALLOW_MAX_FILE_SIZE:
+            default_storage.delete(new_file_name)
+            raise FileSizeNotAllow
+
+        result = xml_template % ('Good', '', default_storage.url(new_file_name))
+    except UploadPermissionNotAuthorized:
+        result = xml_template % ('', _('uploading images is limited to users with >60 reputation points'), '')
+    except FileTypeNotAllow:
+        result = xml_template % ('', _("allowed file types are 'jpg', 'jpeg', 'gif', 'bmp', 'png', 'tiff'"), '')
+    except FileSizeNotAllow:
+        result = xml_template % ('', _("maximum upload file size is %sK") % settings.ALLOW_MAX_FILE_SIZE / 1024, '')
+    except Exception:
+        result = xml_template % ('', _('Error uploading file. Please contact the site administrator. Thank you. %s' % Exception), '')
+
+    return HttpResponse(result, mimetype="application/xml")
+
+def books(request):
+    return HttpResponseRedirect("/books/mysql-zhaoyang")
+    
+def book(request, short_name, unanswered=False):
+    """
+    1. questions list
+    2. book info
+    3. author info and blog rss items
+    """
+    """
+    List of Questions, Tagged questions, and Unanswered questions.
+    """
+    books = Book.objects.extra(where=['short_name = %s'], params=[short_name])
+    match_count = len(books)
+    if match_count == 0 :
+        raise Http404
+    else:
+        # the book info
+        book = books[0]
+        # get author info
+        author_info = BookAuthorInfo.objects.get(book=book)
+        # get author rss info
+        author_rss = BookAuthorRss.objects.filter(book=book)
+
+        # get pagesize from session, if failed then get default value
+        user_page_size = request.session.get("pagesize", QUESTIONS_PAGE_SIZE)
+        # set pagesize equal to logon user specified value in database
+        if request.user.is_authenticated() and request.user.questions_per_page > 0:
+            user_page_size = request.user.questions_per_page
+            
+        try:
+            page = int(request.GET.get('page', '1'))
+        except ValueError:
+            page = 1
+
+        view_id = request.GET.get('sort', None)
+        view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-answer_count", "mostvoted":"-score" }
+        try:
+            orderby = view_dic[view_id]
+        except KeyError:
+            view_id = "latest"
+            orderby = "-added_at"
+            
+        # check if request is from tagged questions
+        if unanswered:
+            # check if request is from unanswered questions
+            # Article.objects.filter(publications__id__exact=1)
+            objects = Question.objects.filter(book__id__exact=book.id, deleted=False, answer_count=0).order_by(orderby)
+        else:
+            objects = Question.objects.filter(book__id__exact=book.id, deleted=False).order_by(orderby)
+
+        # RISK - inner join queries
+        objects = objects.select_related();
+        objects_list = Paginator(objects, user_page_size)
+        questions = objects_list.page(page)
+
+        return render_to_response('book.html', {
+            "book" : book,
+            "author_info" : author_info,
+            "author_rss" : author_rss,
+            "questions" : questions,
+            "context" : {
+                'is_paginated' : True,
+                'pages': objects_list.num_pages,
+                'page': page,
+                'has_previous': questions.has_previous(),
+                'has_next': questions.has_next(),
+                'previous': questions.previous_page_number(),
+                'next': questions.next_page_number(),
+                'base_url' : request.path + '?sort=%s&' % view_id,
+                'pagesize' : user_page_size
+            }
+        }, context_instance=RequestContext(request))
+
+@login_required
+def ask_book(request, short_name):
+    if request.method == "POST":
+        form = AskForm(request.POST)
+        if form.is_valid():
+            added_at = datetime.datetime.now()
+            html = sanitize_html(markdowner.convert(form.cleaned_data['text']))
+            question = Question(
+                title            = strip_tags(form.cleaned_data['title']),
+                author           = request.user,
+                added_at         = added_at,
+                last_activity_at = added_at,
+                last_activity_by = request.user,
+                wiki             = form.cleaned_data['wiki'],
+                tagnames         = form.cleaned_data['tags'].strip(),
+                html             = html,
+                summary          = strip_tags(html)[:120]
+            )
+            if question.wiki:
+                question.last_edited_by = question.author
+                question.last_edited_at = added_at
+                question.wikified_at = added_at
+
+            question.save()
+
+            # create the first revision
+            QuestionRevision.objects.create(
+                question   = question,
+                revision   = 1,
+                title      = question.title,
+                author     = request.user,
+                revised_at = added_at,
+                tagnames   = question.tagnames,
+                summary    = CONST['default_version'],
+                text       = form.cleaned_data['text']
+            )
+            
+            books = Book.objects.extra(where=['short_name = %s'], params=[short_name])
+            match_count = len(books)
+            if match_count == 1:
+                # the book info
+                book = books[0]
+                book.questions.add(question)
+
+            return HttpResponseRedirect(question.get_absolute_url())
+    else:
+        form = AskForm()
+
+    tags = _get_tags_cache_json()
+    return render_to_response('ask.html', {
+        'form' : form,
+        'tags' : tags,
+        }, context_instance=RequestContext(request))
+
+def search(request):
+    """
+    Search by question, user and tag keywords.
+    For questions now we only search keywords in question title.
+    """
+    if request.method == "GET":
+        keywords = request.GET.get("q")
+        search_type = request.GET.get("t")
+        try:
+            page = int(request.GET.get('page', '1'))
+        except ValueError:
+            page = 1
+        if keywords is None:
+            return HttpResponseRedirect('/')
+        if search_type == 'tag':
+            return HttpResponseRedirect('/tags/?q=%s&page=%s' % (keywords.strip(), page))
+        elif search_type == "user":
+            return HttpResponseRedirect('/users/?q=%s&page=%s' % (keywords.strip(), page))
+        elif search_type == "question":
+            
+            template_file = "questions.html"
+            # Set flag to False by default. If it is equal to True, then need to be saved.
+            pagesize_changed = False
+            # get pagesize from session, if failed then get default value
+            user_page_size = request.session.get("pagesize", QUESTIONS_PAGE_SIZE)
+            # set pagesize equal to logon user specified value in database
+            if request.user.is_authenticated() and request.user.questions_per_page > 0:
+                user_page_size = request.user.questions_per_page
+
+            try:
+                page = int(request.GET.get('page', '1'))
+                # get new pagesize from UI selection
+                pagesize = int(request.GET.get('pagesize', user_page_size))
+                if pagesize <> user_page_size:
+                    pagesize_changed = True
+
+            except ValueError:
+                page = 1
+                pagesize  = user_page_size
+
+            # save this pagesize to user database
+            if pagesize_changed:
+                request.session["pagesize"] = pagesize
+                if request.user.is_authenticated():
+                    user = request.user
+                    user.questions_per_page = pagesize
+                    user.save()
+
+            view_id = request.GET.get('sort', None)
+            view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-answer_count", "mostvoted":"-score" }
+            try:
+                orderby = view_dic[view_id]
+            except KeyError:
+                view_id = "latest"
+                orderby = "-added_at"
+                
+            objects = Question.objects.filter(deleted=False).extra(where=['title like %s'], params=['%' + keywords + '%']).order_by(orderby)
+
+            # RISK - inner join queries
+            objects = objects.select_related();
+            objects_list = Paginator(objects, pagesize)
+            questions = objects_list.page(page)
+
+            # Get related tags from this page objects
+            related_tags = []
+            for question in questions.object_list:
+                tags = list(question.tags.all())
+                for tag in tags:
+                    if tag not in related_tags:
+                        related_tags.append(tag)
+
+            return render_to_response(template_file, {
+                "questions" : questions,
+                "tab_id" : view_id,
+                "questions_count" : objects_list.count,
+                "tags" : related_tags,
+                "searchtag" : None,
+                "searchtitle" : keywords,
+                "keywords" : keywords,
+                "is_unanswered" : False,
+                "context" : {
+                    'is_paginated' : True,
+                    'pages': objects_list.num_pages,
+                    'page': page,
+                    'has_previous': questions.has_previous(),
+                    'has_next': questions.has_next(),
+                    'previous': questions.previous_page_number(),
+                    'next': questions.next_page_number(),
+                    'base_url' : request.path + '?t=question&q=%s&sort=%s&' % (keywords, view_id),
+                    'pagesize' : pagesize
+                }}, context_instance=RequestContext(request))
+ 
+    else:
+        raise Http404