X-Git-Url: https://git.openstreetmap.org./osqa.git/blobdiff_plain/a9eef437702d5df7a2f97010e6798c689371808c..3ff018b6b9cc5c0b36054456a671389a481f72a2:/forum/views/readers.py

diff --git a/forum/views/readers.py b/forum/views/readers.py
index 6b0da47..1714a51 100644
--- a/forum/views/readers.py
+++ b/forum/views/readers.py
@@ -2,11 +2,12 @@
 import datetime
 import logging
 from urllib import unquote
-from django.conf import settings
+from django.conf import settings as django_settings
 from django.shortcuts import render_to_response, get_object_or_404
-from django.http import HttpResponseRedirect, HttpResponse, HttpResponseForbidden, Http404
+from django.http import HttpResponseRedirect, HttpResponse, HttpResponseForbidden, Http404, HttpResponsePermanentRedirect
 from django.core.paginator import Paginator, EmptyPage, InvalidPage
 from django.template import RequestContext
+from django import template
 from django.utils.html import *
 from django.utils import simplejson
 from django.db.models import Q
@@ -14,17 +15,20 @@ from django.utils.translation import ugettext as _
 from django.template.defaultfilters import slugify
 from django.core.urlresolvers import reverse
 from django.utils.datastructures import SortedDict
+from django.views.decorators.cache import cache_page
+from django.utils.http import urlquote  as django_urlquote
+from django.template.defaultfilters import slugify
+from django.utils.safestring import mark_safe
 
 from forum.utils.html import sanitize_html
-from markdown2 import Markdown
-#from lxml.html.diff import htmldiff
 from forum.utils.diff import textDiff as htmldiff
 from forum.forms import *
 from forum.models import *
-from forum.auth import *
 from forum.const import *
-from forum import auth
 from forum.utils.forms import get_next_url
+from forum.actions import QuestionViewAction
+from forum.modules.decorators import decoratable
+import decorators
 
 # used in index page
 #refactor - move these numbers somewhere?
@@ -38,327 +42,78 @@ QUESTIONS_PAGE_SIZE = 30
 # used in answers
 ANSWERS_PAGE_SIZE = 10
 
-markdowner = Markdown(html4tags=True)
-
-#system to display main content
-def _get_tags_cache_json():#service routine used by views requiring tag list in the javascript space
-    """returns list of all tags in json format
-    no caching yet, actually
-    """
-    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 _get_and_remember_questions_sort_method(request, view_dic, default):#service routine used by q listing views and question view
-    """manages persistence of post sort order
-    it is assumed that when user wants newest question - 
-    then he/she wants newest answers as well, etc.
-    how far should this assumption actually go - may be a good question
-    """
-    if default not in view_dic:
-        raise Exception('default value must be in view_dic')
-
-    q_sort_method = request.REQUEST.get('sort', None)
-    if q_sort_method == None:
-        q_sort_method = request.session.get('questions_sort_method', default)
-
-    if q_sort_method not in view_dic:
-        q_sort_method = default
-    request.session['questions_sort_method'] = q_sort_method
-    return q_sort_method, view_dic[q_sort_method]
-
-#refactor? - we have these
-#views that generate a listing of questions in one way or another:
-#index, unanswered, questions, search, tag
-#should we dry them up?
-#related topics - information drill-down, search refinement
-
-def index(request):#generates front page - shows listing of questions sorted in various ways
-    """index view mapped to the root url of the Q&A site
-    """
-    view_dic = {
-             "latest":"-last_activity_at",
-             "hottest":"-answer_count",
-             "mostvoted":"-score",
-             }
-    view_id, orderby = _get_and_remember_questions_sort_method(request, view_dic, 'latest')
-
-    pagesize = request.session.get("pagesize",QUESTIONS_PAGE_SIZE)
-    try:
-        page = int(request.GET.get('page', '1'))
-    except ValueError:
-        page = 1
+@decorators.render('index.html')
+def index(request):
+    return question_list(request, Question.objects.all(), sort='active', base_path=reverse('questions'))
 
-    qs = Question.objects.exclude(deleted=True).order_by(orderby)
+@decorators.render('questions.html', 'unanswered')
+def unanswered(request):
+    return question_list(request, Question.objects.filter(extra_ref=None),
+                         _('Open questions without an accepted answer'))
 
-    objects_list = Paginator(qs, pagesize)
-    questions = objects_list.page(page)
+@decorators.render('questions.html', 'questions')
+def questions(request):
+    return question_list(request, Question.objects.all())
 
-    # RISK - inner join queries
-    #questions = questions.select_related()
-    tags = Tag.objects.get_valid_tags(INDEX_TAGS_SIZE)
+@decorators.render('questions.html')
+def tag(request, tag):
+    return question_list(request, Question.objects.filter(tags__name=unquote(tag)),
+                        mark_safe(_('Questions tagged <span class="tag">%(tag)s</span>') % {'tag': tag}))
 
-    awards = Award.objects.get_recent_awards()
+@decorators.list('questions', QUESTIONS_PAGE_SIZE)
+def question_list(request, initial, list_description=_('questions'), sort=None, base_path=None):
+    questions = initial.filter(deleted=None, in_moderation=None)
 
-    (interesting_tag_names, ignored_tag_names) = (None, None)
     if request.user.is_authenticated():
-        pt = MarkedTag.objects.filter(user=request.user)
-        interesting_tag_names = pt.filter(reason='good').values_list('tag__name', flat=True)
-        ignored_tag_names = pt.filter(reason='bad').values_list('tag__name', flat=True)
-
-    tags_autocomplete = _get_tags_cache_json()
-
-    return render_to_response('index.html', {
-        'interesting_tag_names': interesting_tag_names,
-        'tags_autocomplete': tags_autocomplete,
-        'ignored_tag_names': ignored_tag_names,
-        "questions" : questions,
-        "tab_id" : view_id,
-        "tags" : tags,
-        "awards" : awards[:INDEX_AWARD_SIZE],
-        "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 unanswered(request):#generates listing of unanswered questions
-    return questions(request, unanswered=True)
-
-def questions(request, tagname=None, unanswered=False):#a view generating listing of questions, used by 'unanswered' too
-    """
-    List of Questions, Tagged questions, and Unanswered questions.
-    """
-    # template file
-    # "questions.html" or maybe index.html in the future
-    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",QUESTIONS_PAGE_SIZE)
-    try:
-        page = int(request.GET.get('page', '1'))
-    except ValueError:
-        page = 1
-
-    view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-answer_count", "mostvoted":"-score" }
-    view_id, orderby = _get_and_remember_questions_sort_method(request,view_dic,'latest')
-
-    # check if request is from tagged questions
-    qs = Question.objects.exclude(deleted=True)
+        questions = questions.filter(
+                ~Q(tags__id__in=request.user.marked_tags.filter(user_selections__reason='bad')))
 
-    if tagname is not None:
-        qs = qs.filter(tags__name = unquote(tagname))
+    if sort is not False:
+        if sort is None:
+            sort = request.utils.sort_method('latest')
+        else:
+            request.utils.set_sort_method(sort)
 
-    if unanswered:
-        qs = qs.exclude(answer_accepted=True)
+        view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-extra_count", "mostvoted":"-score" }
 
-    author_name = None
-    #user contributed questions & answers
-    if 'user' in request.GET:
-        try:
-            author_name = request.GET['user']
-            u = User.objects.get(username=author_name)
-            qs = qs.filter(Q(author=u) | Q(answers__author=u))
-        except User.DoesNotExist:
-            author_name = None
+        questions=questions.order_by(view_dic.get(sort, '-added_at'))
 
-    if request.user.is_authenticated():
-        uid_str = str(request.user.id)
-        qs = qs.extra(
-                        select = SortedDict([
-                            (
-                                'interesting_score', 
-                                'SELECT COUNT(1) FROM forum_markedtag, question_tags '
-                                  + 'WHERE forum_markedtag.user_id = %s '
-                                  + 'AND forum_markedtag.tag_id = question_tags.tag_id '
-                                  + 'AND forum_markedtag.reason = \'good\' '
-                                  + 'AND question_tags.question_id = question.id'
-                            ),
-                                ]),
-                        select_params = (uid_str,),
-                     )
-        if request.user.hide_ignored_questions:
-            ignored_tags = Tag.objects.filter(user_selections__reason='bad',
-                                            user_selections__user = request.user)
-            qs = qs.exclude(tags__in=ignored_tags)
-        else:
-            qs = qs.extra(
-                        select = SortedDict([
-                            (
-                                'ignored_score', 
-                                'SELECT COUNT(1) FROM forum_markedtag, question_tags '
-                                  + 'WHERE forum_markedtag.user_id = %s '
-                                  + 'AND forum_markedtag.tag_id = question_tags.tag_id '
-                                  + 'AND forum_markedtag.reason = \'bad\' '
-                                  + 'AND question_tags.question_id = question.id'
-                            )
-                                ]),
-                        select_params = (uid_str, )
-                     )
-
-    qs = qs.select_related(depth=1).order_by(orderby)
-
-    objects_list = Paginator(qs, 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
-    tags_autocomplete = _get_tags_cache_json()
+    return {
+        "questions" : questions,
+        "questions_count" : questions.count(),
+        #"tags_autocomplete" : _get_tags_cache_json(),
+        "list_description": list_description,
+        "base_path" : base_path,
+        }
 
-    # get the list of interesting and ignored tags
-    (interesting_tag_names, ignored_tag_names) = (None, None)
-    if request.user.is_authenticated():
-        pt = MarkedTag.objects.filter(user=request.user)
-        interesting_tag_names = pt.filter(reason='good').values_list('tag__name', flat=True)
-        ignored_tag_names = pt.filter(reason='bad').values_list('tag__name', flat=True)
 
-    return render_to_response(template_file, {
-        "questions" : questions,
-        "author_name" : author_name,
-        "tab_id" : view_id,
-        "questions_count" : objects_list.count,
-        "tags" : related_tags,
-        "tags_autocomplete" : tags_autocomplete, 
-        "searchtag" : tagname,
-        "is_unanswered" : unanswered,
-        "interesting_tag_names": interesting_tag_names,
-        'ignored_tag_names': ignored_tag_names, 
-        "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 search(request): #generates listing of questions matching a search query - including tags and just words
-    """generates listing of questions matching a search query
-    supports full text search in mysql db using sphinx and internally in postgresql
-    falls back on simple partial string matching approach if
-    full text search function is not available
-    """
-    if request.method == "GET":
+def search(request):
+    if request.method == "GET" and "q" in request.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:
+        
+        if not keywords:
             return HttpResponseRedirect(reverse(index))
         if search_type == 'tag':
-            return HttpResponseRedirect(reverse('tags') + '?q=%s&page=%s' % (keywords.strip(), page))
+            return HttpResponseRedirect(reverse('tags') + '?q=%s' % (keywords.strip()))
         elif search_type == "user":
-            return HttpResponseRedirect(reverse('users') + '?q=%s&page=%s' % (keywords.strip(), page))
+            return HttpResponseRedirect(reverse('users') + '?q=%s' % (keywords.strip()))
         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"
-
-            def question_search(keywords, orderby):
-                objects = Question.objects.filter(deleted=False).extra(where=['title like %s'], params=['%' + keywords + '%']).order_by(orderby)
-                # RISK - inner join queries
-                return objects.select_related();
-
-            from forum.modules import get_handler
-
-            question_search = get_handler('question_search', question_search)
-            
-            objects = question_search(keywords, orderby)
-
-            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)
-
-            #if is_search is true in the context, prepend this string to soting tabs urls
-            search_uri = "?q=%s&page=%d&t=question" % ("+".join(keywords.split()),  page)
-
-            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,
-                "is_search": True, 
-                "search_uri":  search_uri, 
-                "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))
- 
+            return question_search(request, keywords)
     else:
-        raise Http404
+        return render_to_response("search.html", context_instance=RequestContext(request))
+
+@decoratable
+def do_question_search(keywords):
+    return Question.objects.filter(Q(title__icontains=keywords) | Q(body__icontains=keywords))
+
+@decorators.render('questions.html')
+def question_search(request, keywords):
+    initial = do_question_search(keywords)
 
-def tag(request, tag):#stub generates listing of questions tagged with a single tag
-    return questions(request, tagname=tag)
+    return question_list(request, initial, _("questions matching '%(keywords)s'") % {'keywords': keywords},
+            base_path="%s?t=question&q=%s" % (reverse('search'), django_urlquote(keywords)), sort=False)
+    
 
 def tags(request):#view showing a listing of available tags - plain list
     stag = ""
@@ -401,130 +156,87 @@ def tags(request):#view showing a listing of available tags - plain list
                                             }
                                 }, context_instance=RequestContext(request))
 
-def question(request, id):#refactor - long subroutine. display question body, answers and comments
-    """view that displays body of the question and 
-    all answers to it
-    """
-    try:
-        page = int(request.GET.get('page', '1'))
-    except ValueError:
-        page = 1
-
-    view_id = request.GET.get('sort', None)
+def get_answer_sort_order(request):
     view_dic = {"latest":"-added_at", "oldest":"added_at", "votes":"-score" }
-    try:
-        orderby = view_dic[view_id]
-    except KeyError:
-        qsm = request.session.get('questions_sort_method',None)
-        if qsm in ('mostvoted','latest'):
-            logging.debug('loaded from session ' + qsm)
-            if qsm == 'mostvoted':
-                view_id = 'votes'
-                orderby = '-score'
-            else:
-                view_id = 'latest'
-                orderby = '-added_at'
-        else:
-            view_id = "votes"
-            orderby = "-score"
 
-    logging.debug('view_id=' + str(view_id))
+    view_id = request.GET.get('sort', request.session.get('answer_sort_order', None))
 
-    question = get_object_or_404(Question, id=id)
-    try:
-        pattern = r'/%s%s%d/([\w-]+)' % (settings.FORUM_SCRIPT_ALIAS,_('question/'), question.id)
-        path_re = re.compile(pattern)
-        logging.debug(pattern)
-        logging.debug(request.path)
-        m = path_re.match(request.path)
-        if m:
-            slug = m.group(1)
-            logging.debug('have slug %s' % slug)
-            assert(slug == slugify(question.title))
-        else:
-            logging.debug('no match!')
-    except:
-        return HttpResponseRedirect(question.get_absolute_url())
+    if view_id is None or not view_id in view_dic:
+        view_id = "votes"
 
-    if question.deleted and not auth.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)
+    if view_id != request.session.get('answer_sort_order', None):
+        request.session['answer_sort_order'] = view_id
 
-    favorited = question.has_favorite_by_user(request.user)
-    if request.user.is_authenticated():
-        question_vote = question.votes.select_related().filter(user=request.user)
-    else:
-        question_vote = None #is this correct?
-    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
+    return (view_id, view_dic[view_id])
 
-    if answers is not None:
-        answers = answers.order_by("-accepted", orderby)
+def update_question_view_times(request, question):
+    if not 'last_seen_in_question' in request.session:
+        request.session['last_seen_in_question'] = {}
 
-    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)
+    last_seen = request.session['last_seen_in_question'].get(question.id,None)
 
-    objects_list = Paginator(filtered_answers, ANSWERS_PAGE_SIZE)
-    page_objects = objects_list.page(page)
+    if (not last_seen) or last_seen < question.last_activity_at:
+        QuestionViewAction(question, request.user).save()
+        request.session['last_seen_in_question'][question.id] = datetime.datetime.now()
+
+    request.session['last_seen_in_question'][question.id] = datetime.datetime.now()
+
+def match_question_slug(slug):
+    slug_words = slug.split('-')
+    qs = Question.objects.filter(node_type="question", title__istartswith=slug_words[0])
 
-    #todo: merge view counts per user and per session
-    #1) view count per session
-    update_view_count = False
-    if 'question_view_times' not in request.session:
-        request.session['question_view_times'] = {}
+    for q in qs:
+        if slug == urlquote(slugify(q.title)):
+            return q
 
-    last_seen = request.session['question_view_times'].get(question.id,None)
-    updated_when, updated_who = question.get_last_update_info()
+    return None
 
-    if updated_who != request.user:
-        if last_seen:
-            if last_seen < updated_when:
-                update_view_count = True 
+def question(request, id, slug):
+    try:
+        question = Question.objects.get(node_type="question", id=id)
+    except:
+        question = match_question_slug(slug)
+        if question is not None:
+            return HttpResponsePermanentRedirect(question.get_absolute_url())
         else:
-            update_view_count = True
+            raise Http404()
+
+    if slug != urlquote(slugify(question.title)):
+        return HttpResponsePermanentRedirect(question.get_absolute_url())
+
+    page = int(request.GET.get('page', 1))
+    view_id, order_by = get_answer_sort_order(request)
+
+    if question.deleted and not request.user.can_view_deleted_post(question):
+        raise Http404
+
+    answer_form = AnswerForm(question)
+    answers = request.user.get_visible_answers(question)
+
+    if answers is not None:
+        answers = [a for a in answers.order_by("-marked", order_by)
+                   if not a.deleted or a.author == request.user]
 
-    request.session['question_view_times'][question.id] = datetime.datetime.now()
+    objects_list = Paginator(answers, ANSWERS_PAGE_SIZE)
+    page_objects = objects_list.page(page)
 
-    if update_view_count:
-        question.view_count += 1
-        question.save()
+    update_question_view_times(request, question)
 
-    #2) question view count per user
     if request.user.is_authenticated():
         try:
-            question_view = QuestionView.objects.get(who=request.user, question=question)
-        except QuestionView.DoesNotExist:
-            question_view = QuestionView(who=request.user, question=question)
-        question_view.when = datetime.datetime.now()
-        question_view.save()
+            subscription = QuestionSubscription.objects.get(question=question, user=request.user)
+        except:
+            subscription = False
+    else:
+        subscription = False
 
     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),
+        "similar_questions" : question.get_related_questions(),
+        "subscription": subscription,
         "context" : {
             'is_paginated' : True,
             'pages': objects_list.num_pages,
@@ -538,51 +250,36 @@ def question(request, id):#refactor - long subroutine. display question body, an
         }
         }, 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())
-    revisions.reverse()
+
+REVISION_TEMPLATE = template.loader.get_template('node/revision.html')
+
+def revisions(request, id):
+    post = get_object_or_404(Node, id=id).leaf
+    revisions = list(post.revisions.order_by('revised_at'))
+
+    rev_ctx = []
+
     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(' ')]),
-        }
+        rev_ctx.append(dict(inst=revision, html=REVISION_TEMPLATE.render(template.Context({
+                'title': revision.title,
+                'html': revision.html,
+                'tags': revision.tagname_list(),
+        }))))
+
         if i > 0:
-            revisions[i].diff = htmldiff(revisions[i-1].html, revision.html)
+            rev_ctx[i]['diff'] = mark_safe(htmldiff(rev_ctx[i-1]['html'], rev_ctx[i]['html']))
         else:
-            revisions[i].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].summary = _('initial version') 
-    return render_to_response('revisions_question.html', {
-                              'post': post,
-                              'revisions': revisions,
-                              }, context_instance=RequestContext(request))
+            rev_ctx[i]['diff'] = mark_safe(rev_ctx[i]['html'])
 
-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())
-    revisions.reverse()
-    for i, revision in enumerate(revisions):
-        revision.html = ANSWER_REVISION_TEMPLATE % {
-            'html': sanitize_html(markdowner.convert(revision.text))
-        }
-        if i > 0:
-            revisions[i].diff = htmldiff(revisions[i-1].html, revision.html)
+        if not (revision.summary):
+            rev_ctx[i]['summary'] = _('Revision n. %(rev_number)d') % {'rev_number': revision.revision}
         else:
-            revisions[i].diff = revisions[i].text
-            revisions[i].summary = _('initial version')
-    return render_to_response('revisions_answer.html', {
+            rev_ctx[i]['summary'] = revision.summary
+            
+    return render_to_response('revisions_question.html', {
                               'post': post,
-                              'revisions': revisions,
+                              'revisions': rev_ctx,
                               }, context_instance=RequestContext(request))
 
+
+