Adds better permalinks to answers, computing the position of an answer in the list.

[osqa.git] / forum / views / readers.py

diff --git a/forum/views/readers.py b/forum/views/readers.py
index c86794f308a48893d64a25510975cbfe0018c1a4..7bfd75af2a34f054e7a9810c81128d4fd15bc332 100644 (file)
--- a/forum/views/readers.py
+++ b/forum/views/readers.py
@@ -1,10 +1,10 @@
-# encoding:utf-8   
+# encoding:utf-8

 import datetime
 import logging
 from urllib import unquote
 from forum import settings as django_settings
 from django.shortcuts import render_to_response, get_object_or_404
 import datetime
 import logging
 from urllib import unquote
 from forum import settings as django_settings
 from django.shortcuts import render_to_response, get_object_or_404

-from django.http import HttpResponseRedirect, HttpResponse, HttpResponseForbidden, Http404, HttpResponsePermanentRedirect
+from django.http import HttpResponseRedirect, HttpResponse, Http404, HttpResponsePermanentRedirect

 from django.core.paginator import Paginator, EmptyPage, InvalidPage
 from django.template import RequestContext
 from django import template
 from django.core.paginator import Paginator, EmptyPage, InvalidPage
 from django.template import RequestContext
 from django import template


@@ -20,13 +20,15 @@ from django.utils.http import urlquote  as django_urlquote
 from django.template.defaultfilters import slugify
 from django.utils.safestring import mark_safe
 
 from django.template.defaultfilters import slugify
 from django.utils.safestring import mark_safe
 

-from forum.utils.html import sanitize_html
+from forum.utils.html import sanitize_html, hyperlink

 from forum.utils.diff import textDiff as htmldiff
 from forum.utils.diff import textDiff as htmldiff

+from forum.utils import pagination

 from forum.forms import *
 from forum.models import *
 from forum.forms import *
 from forum.models import *

-from forum.utils.forms import get_next_url
+from forum.forms import get_next_url

 from forum.actions import QuestionViewAction
 from forum.actions import QuestionViewAction

-from forum.modules.decorators import decoratable
+from forum.http_responses import HttpResponseUnauthorized
+from forum.feed import RssQuestionFeed

 import decorators
 
 # used in index page
 import decorators
 
 # used in index page


@@ -41,23 +43,57 @@ QUESTIONS_PAGE_SIZE = 30
 # used in answers
 ANSWERS_PAGE_SIZE = 10
 
 # used in answers
 ANSWERS_PAGE_SIZE = 10
 

+class QuestionListPaginatorContext(pagination.PaginatorContext):
+    def __init__(self):
+        super (QuestionListPaginatorContext, self).__init__('QUESTIONS_LIST', sort_methods=(
+            (_('active'), pagination.SimpleSort(_('active'), '-last_activity_at', _("most recently updated questions"))),
+            (_('newest'), pagination.SimpleSort(_('newest'), '-added_at', _("most recently asked questions"))),
+            (_('hottest'), pagination.SimpleSort(_('hottest'), '-extra_count', _("hottest questions"))),
+            (_('mostvoted'), pagination.SimpleSort(_('most voted'), '-score', _("most voted questions"))),
+        ), pagesizes=(15, 30, 50))
+
+class AnswerSort(pagination.SimpleSort):
+    def apply(self, objects):
+        if self.label == _('votes'):
+            return objects.order_by('-marked', self.order_by, 'added_at')
+        else:
+            return objects.order_by('-marked', self.order_by)
+
+class AnswerPaginatorContext(pagination.PaginatorContext):
+    def __init__(self):
+        super (AnswerPaginatorContext, self).__init__('ANSWER_LIST', sort_methods=(
+            (_('oldest'), AnswerSort(_('oldest answers'), 'added_at', _("oldest answers will be shown first"))),
+            (_('newest'), AnswerSort(_('newest answers'), '-added_at', _("newest answers will be shown first"))),
+            (_('votes'), AnswerSort(_('popular answers'), '-score', _("most voted answers will be shown first"))),
+        ), default_sort=_('votes'), sticky_sort = True, pagesizes=(5, 10, 20))
+    
+
+def feed(request):
+    return RssQuestionFeed(
+                Question.objects.filter_state(deleted=False).order_by('-last_activity_at'),
+                settings.APP_TITLE + _(' - ')+ _('latest questions'),
+                settings.APP_DESCRIPTION,
+                request)(request)
+
+

 @decorators.render('index.html')
 def index(request):
     return question_list(request,
                          Question.objects.all(),
                          sort=request.utils.set_sort_method('active'),
 @decorators.render('index.html')
 def index(request):
     return question_list(request,
                          Question.objects.all(),
                          sort=request.utils.set_sort_method('active'),

-                         base_path=reverse('questions'))
+                         base_path=reverse('questions'),
+                         feed_url=reverse('latest_questions_feed'))

 
 

-@decorators.render('questions.html', 'unanswered')
+@decorators.render('questions.html', 'unanswered', _('unanswered'), weight=400)

 def unanswered(request):
     return question_list(request,
                          Question.objects.filter(extra_ref=None),
 def unanswered(request):
     return question_list(request,
                          Question.objects.filter(extra_ref=None),

-                         _('Open questions without an accepted answer'),
+                         _('open questions without an accepted answer'),

                          request.utils.set_sort_method('active'),
                          None,
                          request.utils.set_sort_method('active'),
                          None,

-                         _("Unanswered questions"))
+                         _("Unanswered Questions"))

 
 

-@decorators.render('questions.html', 'questions')
+@decorators.render('questions.html', 'questions', _('questions'), weight=0)

 def questions(request):
     return question_list(request, Question.objects.all(), _('questions'), request.utils.set_sort_method('active'))
 
 def questions(request):
     return question_list(request, Question.objects.all(), _('questions'), request.utils.set_sort_method('active'))
 


@@ -65,40 +101,86 @@ def questions(request):
 def tag(request, tag):
     return question_list(request,
                          Question.objects.filter(tags__name=unquote(tag)),
 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}),
+                         mark_safe(_('questions tagged <span class="tag">%(tag)s</span>') % {'tag': tag}),

                          request.utils.set_sort_method('active'),
                          None,
                          request.utils.set_sort_method('active'),
                          None,

-                         mark_safe(_('Questions tagged %(tag)s') % {'tag': tag}),
+                         mark_safe(_('Questions Tagged With %(tag)s') % {'tag': tag}),

                          False)
 
                          False)
 

-@decorators.list('questions', QUESTIONS_PAGE_SIZE)
-def question_list(request, initial, list_description=_('questions'), sort=None, base_path=None, page_title=None, allowIgnoreTags=True):
-    questions = initial.filter(deleted=None, in_moderation=None)
+@decorators.render('questions.html', 'questions', tabbed=False)
+def user_questions(request, mode, user, slug):
+    user = get_object_or_404(User, id=user)
+
+    if mode == _('asked-by'):
+        questions = Question.objects.filter(author=user)
+        description = _("Questions asked by %s")
+    elif mode == _('answered-by'):
+        questions = Question.objects.filter(children__author=user, children__node_type='answer').distinct()
+        description = _("Questions answered by %s")
+    elif mode == _('subscribed-by'):
+        if not (request.user.is_superuser or request.user == user):
+            return HttpResponseUnauthorized(request)
+        questions = user.subscriptions
+
+        if request.user == user:
+            description = _("Questions you subscribed %s")
+        else:
+            description = _("Questions subscribed by %s")
+    else:
+        raise Http404

 
 

-    if request.user.is_authenticated() and allowIgnoreTags:
-        questions = questions.filter(~Q(tags__id__in = request.user.marked_tags.filter(user_selections__reason = 'bad')))

 
 

-    if sort is not False:
-        if sort is None:
-            sort = request.utils.sort_method('latest')
-        else:
-            request.utils.set_sort_method(sort)
+    return question_list(request, questions,
+                         mark_safe(description % hyperlink(user.get_profile_url(), user.username)),
+                         request.utils.set_sort_method('active'),
+                         page_title=description % user.username)

 
 

-        view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-extra_count", "mostvoted":"-score" }
+def question_list(request, initial,
+                  list_description=_('questions'),
+                  sort=None,
+                  base_path=None,
+                  page_title=_("All Questions"),
+                  allowIgnoreTags=True,
+                  feed_url=None,
+                  paginator_context=None):

 
 

-        questions=questions.order_by(view_dic.get(sort, '-added_at'))
+    questions = initial.filter_state(deleted=False)
+
+    if request.user.is_authenticated() and allowIgnoreTags:
+        questions = questions.filter(~Q(tags__id__in = request.user.marked_tags.filter(user_selections__reason = 'bad')))

 
     if page_title is None:
         page_title = _("Questions")
 
 
     if page_title is None:
         page_title = _("Questions")
 

-    return {
-        "questions" : questions,
-        "questions_count" : questions.count(),
-        #"tags_autocomplete" : _get_tags_cache_json(),
-        "list_description": list_description,
-        "base_path" : base_path,
-        "page_title" : page_title,
-        }
+    if request.GET.get('type', None) == 'rss':
+        return RssQuestionFeed(questions, page_title, list_description, request)(request)
+
+    keywords =  ""
+    if request.GET.get("q"):
+        keywords = request.GET.get("q").strip()
+
+    answer_count = Answer.objects.filter_state(deleted=False).filter(parent__in=questions).count()
+    answer_description = _("answers")
+
+    if not feed_url:
+        req_params = "&".join(["%s=%s" % (k, v) for k, v in request.GET.items() if not k in (_('page'), _('pagesize'), _('sort'))])
+        if req_params:
+            req_params = '&' + req_params
+
+        feed_url = mark_safe(request.path + "?type=rss" + req_params)
+
+    return pagination.paginated(request, 'questions', paginator_context or QuestionListPaginatorContext(), {
+    "questions" : questions,
+    "questions_count" : questions.count(),
+    "answer_count" : answer_count,
+    "keywords" : keywords,
+    "list_description": list_description,
+    "answer_description": answer_description,
+    "base_path" : base_path,
+    "page_title" : page_title,
+    "tab" : "questions",
+    'feed_url': feed_url,
+    })

 
 
 def search(request):
 
 
 def search(request):


@@ -109,27 +191,35 @@ def search(request):
         if not keywords:
             return HttpResponseRedirect(reverse(index))
         if search_type == 'tag':
         if not keywords:
             return HttpResponseRedirect(reverse(index))
         if search_type == 'tag':

-            return HttpResponseRedirect(reverse('tags') + '?q=%s' % (keywords.strip()))
+            return HttpResponseRedirect(reverse('tags') + '?q=%s' % urlquote(keywords.strip()))

         elif search_type == "user":
         elif search_type == "user":

-            return HttpResponseRedirect(reverse('users') + '?q=%s' % (keywords.strip()))
+            return HttpResponseRedirect(reverse('users') + '?q=%s' % urlquote(keywords.strip()))

         elif search_type == "question":
             return question_search(request, keywords)
     else:
         return render_to_response("search.html", context_instance=RequestContext(request))
 
         elif search_type == "question":
             return question_search(request, keywords)
     else:
         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):
 @decorators.render('questions.html')
 def question_search(request, keywords):

-    initial = do_question_search(keywords)
+    can_rank, initial = Question.objects.search(keywords)
+
+    if can_rank:
+        paginator_context = QuestionListPaginatorContext()
+        paginator_context.sort_methods[_('ranking')] = pagination.SimpleSort(_('relevance'), '-ranking', _("most relevant questions"))
+        paginator_context.force_sort = _('ranking')
+    else:
+        paginator_context = None

 
 

-    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)
+    return question_list(request, initial,
+                         _("questions matching '%(keywords)s'") % {'keywords': keywords},
+                         False,
+                         "%s?t=question&q=%s" % (reverse('search'),django_urlquote(keywords)),
+                         _("questions matching '%(keywords)s'") % {'keywords': keywords},
+                         paginator_context=paginator_context)

 
 
 
 

-def tags(request):#view showing a listing of available tags - plain list
+@decorators.render('tags.html', 'tags', _('tags'), weight=100)
+def tags(request):

     stag = ""
     is_paginated = True
     sortby = request.GET.get('sort', 'used')
     stag = ""
     is_paginated = True
     sortby = request.GET.get('sort', 'used')


@@ -141,53 +231,40 @@ def tags(request):#view showing a listing of available tags - plain list
     if request.method == "GET":
         stag = request.GET.get("q", "").strip()
         if stag != '':
     if request.method == "GET":
         stag = request.GET.get("q", "").strip()
         if stag != '':

-            objects_list = Paginator(Tag.objects.filter(deleted=False).exclude(used_count=0).extra(where=['name like %s'], params=['%' + stag + '%']), DEFAULT_PAGE_SIZE)
+            objects_list = Paginator(Tag.active.filter(name__contains=stag), DEFAULT_PAGE_SIZE)

         else:
             if sortby == "name":
         else:
             if sortby == "name":

-                objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("name"), DEFAULT_PAGE_SIZE)
+                objects_list = Paginator(Tag.active.order_by("name"), DEFAULT_PAGE_SIZE)

             else:
             else:

-                objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("-used_count"), DEFAULT_PAGE_SIZE)
+                objects_list = Paginator(Tag.active.order_by("-used_count"), DEFAULT_PAGE_SIZE)

 
     try:
         tags = objects_list.page(page)
     except (EmptyPage, InvalidPage):
         tags = objects_list.page(objects_list.num_pages)
 
 
     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' : reverse('tags') + '?sort=%s&' % sortby
-                                            }
-                                }, context_instance=RequestContext(request))
-
-def get_answer_sort_order(request):
-    view_dic = {"latest":"-added_at", "oldest":"added_at", "votes":"-score" }
-
-    view_id = request.GET.get('sort', request.session.get('answer_sort_order', None))
-
-    if view_id is None or not view_id in view_dic:
-        view_id = "votes"
-
-    if view_id != request.session.get('answer_sort_order', None):
-        request.session['answer_sort_order'] = view_id
-
-    return (view_id, view_dic[view_id])
+    return {
+        "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' : reverse('tags') + '?sort=%s&' % sortby
+        }
+    }

 
 def update_question_view_times(request, question):
     if not 'last_seen_in_question' in request.session:
         request.session['last_seen_in_question'] = {}
 
 
 def update_question_view_times(request, question):
     if not 'last_seen_in_question' in request.session:
         request.session['last_seen_in_question'] = {}
 

-    last_seen = request.session['last_seen_in_question'].get(question.id,None)
+    last_seen = request.session['last_seen_in_question'].get(question.id, None)

 
     if (not last_seen) or last_seen < question.last_activity_at:
         QuestionViewAction(question, request.user, ip=request.META['REMOTE_ADDR']).save()
 
     if (not last_seen) or last_seen < question.last_activity_at:
         QuestionViewAction(question, request.user, ip=request.META['REMOTE_ADDR']).save()


@@ -197,7 +274,7 @@ def update_question_view_times(request, question):
 
 def match_question_slug(slug):
     slug_words = slug.split('-')
 
 def match_question_slug(slug):
     slug_words = slug.split('-')

-    qs = Question.objects.filter(node_type="question", title__istartswith=slug_words[0])
+    qs = Question.objects.filter(title__istartswith=slug_words[0])

 
     for q in qs:
         if slug == urlquote(slugify(q.title)):
 
     for q in qs:
         if slug == urlquote(slugify(q.title)):


@@ -205,34 +282,63 @@ def match_question_slug(slug):
 
     return None
 
 
     return None
 

-def question(request, id, slug):
+def answer_redirect(request, answer):
+    pc = AnswerPaginatorContext()
+
+    sort = pc.sort(request)
+
+    if sort == _('oldest'):
+        filter = Q(added_at__lt=answer.added_at)
+    elif sort == _('newest'):
+        filter = Q(added_at__gt=answer.added_at)
+    elif sort == _('votes'):
+        filter = Q(score__gt=answer.score) | Q(score=answer.score, added_at__lt=answer.added_at)
+    else:
+        raise Http404()
+        
+    count = answer.question.answers.filter(Q(marked=True) | filter).count()
+    pagesize = pc.pagesize(request)
+
+    page = count / pagesize
+    
+    if count % pagesize:
+        page += 1
+
+    return HttpResponsePermanentRedirect("%s?%s=%s#%s" % (
+        answer.question.get_absolute_url(), _('page'), page, answer.id))
+
+@decorators.render("question.html", 'questions', tabbed=False)
+def question(request, id, slug, answer=None):

     try:
     try:

-        question = Question.objects.get(node_type="question", id=id)
+        question = Question.objects.get(id=id)

     except:
     except:

-        question = match_question_slug(slug)
-        if question is not None:
-            return HttpResponsePermanentRedirect(question.get_absolute_url())
-        else:
-            raise Http404()
+        if slug:
+            question = match_question_slug(slug)
+            if question is not None:
+                return HttpResponseRedirect(question.get_absolute_url())

 
 

-    if slug != urlquote(slugify(question.title)):
-        return HttpResponsePermanentRedirect(question.get_absolute_url())
+        raise Http404()

 
 

-    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):
+    if question.nis.deleted and not request.user.can_view_deleted_post(question):

         raise Http404
 
         raise Http404
 

-    answer_form = AnswerForm(question)
-    answers = request.user.get_visible_answers(question)
+    if answer:
+        answer = get_object_or_404(Answer, id=answer)

 
 

-    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]
+        if (question.nis.deleted and not request.user.can_view_deleted_post(question)) or answer.question != question:
+            raise Http404
+
+        if answer.marked:
+            return HttpResponsePermanentRedirect(question.get_absolute_url())
+
+        return answer_redirect(request, answer)
+
+    if request.POST:
+        answer_form = AnswerForm(question, request.POST)
+    else:
+        answer_form = AnswerForm(question)

 
 

-    objects_list = Paginator(answers, ANSWERS_PAGE_SIZE)
-    page_objects = objects_list.page(page)
+    answers = request.user.get_visible_answers(question)

 
     update_question_view_times(request, question)
 
 
     update_question_view_times(request, question)
 


@@ -244,25 +350,13 @@ def question(request, id, slug):
     else:
         subscription = False
 
     else:
         subscription = False
 

-    return render_to_response('question.html', {
-        "question" : question,
-        "answer" : answer_form,
-        "answers" : page_objects.object_list,
-        "tab_id" : view_id,
-        "similar_questions" : question.get_related_questions(),
-        "subscription": subscription,
-        "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))
+    return pagination.paginated(request, 'answers', AnswerPaginatorContext(), {
+    "question" : question,
+    "answer" : answer_form,
+    "answers" : answers,
+    "similar_questions" : question.get_related_questions(),
+    "subscription": subscription,
+    })

 
 
 REVISION_TEMPLATE = template.loader.get_template('node/revision.html')
 
 
 REVISION_TEMPLATE = template.loader.get_template('node/revision.html')


@@ -270,14 +364,13 @@ 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'))
 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):
     rev_ctx = []
 
     for i, revision in enumerate(revisions):

-        rev_ctx.append(dict(inst=revision, html=REVISION_TEMPLATE.render(template.Context({
-                'title': revision.title,
-                'html': revision.html,
-                'tags': revision.tagname_list(),
+        rev_ctx.append(dict(inst=revision, html=template.loader.get_template('node/revision.html').render(template.Context({
+        'title': revision.title,
+        'html': revision.html,
+        'tags': revision.tagname_list(),

         }))))
 
         if i > 0:
         }))))
 
         if i > 0:


@@ -290,10 +383,12 @@ def revisions(request, id):
         else:
             rev_ctx[i]['summary'] = revision.summary
 
         else:
             rev_ctx[i]['summary'] = revision.summary
 

+    rev_ctx.reverse()
+

     return render_to_response('revisions.html', {
     return render_to_response('revisions.html', {

-                              'post': post,
-                              'revisions': rev_ctx,
-                              }, context_instance=RequestContext(request))
+    'post': post,
+    'revisions': rev_ctx,
+    }, context_instance=RequestContext(request))