4 from urllib import unquote
5 from forum import settings as django_settings
6 from django.shortcuts import render_to_response, get_object_or_404
7 from django.http import HttpResponseRedirect, HttpResponse, HttpResponseForbidden, Http404, HttpResponsePermanentRedirect
8 from django.core.paginator import Paginator, EmptyPage, InvalidPage
9 from django.template import RequestContext
10 from django import template
11 from django.utils.html import *
12 from django.utils import simplejson
13 from django.db.models import Q
14 from django.utils.translation import ugettext as _
15 from django.template.defaultfilters import slugify
16 from django.core.urlresolvers import reverse
17 from django.utils.datastructures import SortedDict
18 from django.views.decorators.cache import cache_page
19 from django.utils.http import urlquote as django_urlquote
20 from django.template.defaultfilters import slugify
21 from django.utils.safestring import mark_safe
23 from forum.utils.html import sanitize_html
24 from forum.utils.diff import textDiff as htmldiff
25 from forum.forms import *
26 from forum.models import *
27 from forum.utils.forms import get_next_url
28 from forum.actions import QuestionViewAction
29 from forum.modules.decorators import decoratable
33 #refactor - move these numbers somewhere?
38 DEFAULT_PAGE_SIZE = 60
40 QUESTIONS_PAGE_SIZE = 30
42 ANSWERS_PAGE_SIZE = 10
44 @decorators.render('index.html')
46 return question_list(request,
47 Question.objects.all(),
48 sort=request.utils.set_sort_method('active'),
49 base_path=reverse('questions'))
51 @decorators.render('questions.html', 'unanswered')
52 def unanswered(request):
53 return question_list(request,
54 Question.objects.filter(extra_ref=None),
55 _('Open questions without an accepted answer'),
56 request.utils.set_sort_method('active'),
58 _("Unanswered questions"))
60 @decorators.render('questions.html', 'questions')
61 def questions(request):
62 return question_list(request, Question.objects.all(), _('questions'), request.utils.set_sort_method('active'))
64 @decorators.render('questions.html')
65 def tag(request, tag):
66 return question_list(request,
67 Question.objects.filter(tags__name=unquote(tag)),
68 mark_safe(_('Questions tagged <span class="tag">%(tag)s</span>') % {'tag': tag}),
69 request.utils.set_sort_method('active'),
71 mark_safe(_('Questions tagged %(tag)s') % {'tag': tag}),
74 @decorators.list('questions', QUESTIONS_PAGE_SIZE)
75 def question_list(request, initial, list_description=_('questions'), sort=None, base_path=None, page_title=None, allowIgnoreTags=True):
76 questions = initial.filter(deleted=None, in_moderation=None)
78 test = request.user.marked_tags
80 if request.user.is_authenticated() and allowIgnoreTags:
81 questions = questions.filter(~Q(tags__id__in = request.user.marked_tags.filter(user_selections__reason = 'bad')))
85 sort = request.utils.sort_method('latest')
87 request.utils.set_sort_method(sort)
89 view_dic = {"latest":"-added_at", "active":"-last_activity_at", "hottest":"-extra_count", "mostvoted":"-score" }
91 questions=questions.order_by(view_dic.get(sort, '-added_at'))
93 if page_title is None:
94 page_title = _("Questions")
97 "questions" : questions,
98 "questions_count" : questions.count(),
99 #"tags_autocomplete" : _get_tags_cache_json(),
100 "list_description": list_description,
101 "base_path" : base_path,
102 "page_title" : page_title,
107 if request.method == "GET" and "q" in request.GET:
108 keywords = request.GET.get("q")
109 search_type = request.GET.get("t")
112 return HttpResponseRedirect(reverse(index))
113 if search_type == 'tag':
114 return HttpResponseRedirect(reverse('tags') + '?q=%s' % (keywords.strip()))
115 elif search_type == "user":
116 return HttpResponseRedirect(reverse('users') + '?q=%s' % (keywords.strip()))
117 elif search_type == "question":
118 return question_search(request, keywords)
120 return render_to_response("search.html", context_instance=RequestContext(request))
123 def do_question_search(keywords):
124 return Question.objects.filter(Q(title__icontains=keywords) | Q(body__icontains=keywords))
126 @decorators.render('questions.html')
127 def question_search(request, keywords):
128 initial = do_question_search(keywords)
130 return question_list(request, initial, _("questions matching '%(keywords)s'") % {'keywords': keywords},
131 base_path="%s?t=question&q=%s" % (reverse('search'), django_urlquote(keywords)), sort=False)
134 def tags(request):#view showing a listing of available tags - plain list
137 sortby = request.GET.get('sort', 'used')
139 page = int(request.GET.get('page', '1'))
143 if request.method == "GET":
144 stag = request.GET.get("q", "").strip()
146 objects_list = Paginator(Tag.objects.filter(deleted=False).exclude(used_count=0).extra(where=['name like %s'], params=['%' + stag + '%']), DEFAULT_PAGE_SIZE)
149 objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("name"), DEFAULT_PAGE_SIZE)
151 objects_list = Paginator(Tag.objects.all().filter(deleted=False).exclude(used_count=0).order_by("-used_count"), DEFAULT_PAGE_SIZE)
154 tags = objects_list.page(page)
155 except (EmptyPage, InvalidPage):
156 tags = objects_list.page(objects_list.num_pages)
158 return render_to_response('tags.html', {
164 'is_paginated' : is_paginated,
165 'pages': objects_list.num_pages,
167 'has_previous': tags.has_previous(),
168 'has_next': tags.has_next(),
169 'previous': tags.previous_page_number(),
170 'next': tags.next_page_number(),
171 'base_url' : reverse('tags') + '?sort=%s&' % sortby
173 }, context_instance=RequestContext(request))
175 def get_answer_sort_order(request):
176 view_dic = {"latest":"-added_at", "oldest":"added_at", "votes":"-score" }
178 view_id = request.GET.get('sort', request.session.get('answer_sort_order', None))
180 if view_id is None or not view_id in view_dic:
183 if view_id != request.session.get('answer_sort_order', None):
184 request.session['answer_sort_order'] = view_id
186 return (view_id, view_dic[view_id])
188 def update_question_view_times(request, question):
189 if not 'last_seen_in_question' in request.session:
190 request.session['last_seen_in_question'] = {}
192 last_seen = request.session['last_seen_in_question'].get(question.id,None)
194 if (not last_seen) or last_seen < question.last_activity_at:
195 QuestionViewAction(question, request.user, ip=request.META['REMOTE_ADDR']).save()
196 request.session['last_seen_in_question'][question.id] = datetime.datetime.now()
198 request.session['last_seen_in_question'][question.id] = datetime.datetime.now()
200 def match_question_slug(slug):
201 slug_words = slug.split('-')
202 qs = Question.objects.filter(node_type="question", title__istartswith=slug_words[0])
205 if slug == urlquote(slugify(q.title)):
210 def question(request, id, slug):
212 question = Question.objects.get(node_type="question", id=id)
214 question = match_question_slug(slug)
215 if question is not None:
216 return HttpResponsePermanentRedirect(question.get_absolute_url())
220 if slug != urlquote(slugify(question.title)):
221 return HttpResponsePermanentRedirect(question.get_absolute_url())
223 page = int(request.GET.get('page', 1))
224 view_id, order_by = get_answer_sort_order(request)
226 if question.deleted and not request.user.can_view_deleted_post(question):
229 answer_form = AnswerForm(question)
230 answers = request.user.get_visible_answers(question)
232 if answers is not None:
233 answers = [a for a in answers.order_by("-marked", order_by)
234 if not a.deleted or a.author == request.user]
236 objects_list = Paginator(answers, ANSWERS_PAGE_SIZE)
237 page_objects = objects_list.page(page)
239 update_question_view_times(request, question)
241 if request.user.is_authenticated():
243 subscription = QuestionSubscription.objects.get(question=question, user=request.user)
249 return render_to_response('question.html', {
250 "question" : question,
251 "answer" : answer_form,
252 "answers" : page_objects.object_list,
254 "similar_questions" : question.get_related_questions(),
255 "subscription": subscription,
257 'is_paginated' : True,
258 'pages': objects_list.num_pages,
260 'has_previous': page_objects.has_previous(),
261 'has_next': page_objects.has_next(),
262 'previous': page_objects.previous_page_number(),
263 'next': page_objects.next_page_number(),
264 'base_url' : request.path + '?sort=%s&' % view_id,
265 'extend_url' : "#sort-top"
267 }, context_instance=RequestContext(request))
270 REVISION_TEMPLATE = template.loader.get_template('node/revision.html')
272 def revisions(request, id):
273 post = get_object_or_404(Node, id=id).leaf
274 revisions = list(post.revisions.order_by('revised_at'))
278 for i, revision in enumerate(revisions):
279 rev_ctx.append(dict(inst=revision, html=REVISION_TEMPLATE.render(template.Context({
280 'title': revision.title,
281 'html': revision.html,
282 'tags': revision.tagname_list(),
286 rev_ctx[i]['diff'] = mark_safe(htmldiff(rev_ctx[i-1]['html'], rev_ctx[i]['html']))
288 rev_ctx[i]['diff'] = mark_safe(rev_ctx[i]['html'])
290 if not (revision.summary):
291 rev_ctx[i]['summary'] = _('Revision n. %(rev_number)d') % {'rev_number': revision.revision}
293 rev_ctx[i]['summary'] = revision.summary
295 return render_to_response('revisions.html', {
297 'revisions': rev_ctx,
298 }, context_instance=RequestContext(request))