def test_activity_multiple_forums(self):
"""Checks links are correct when there is activity from >1 forum."""
jsocol = User.objects.get(username='******')
rrosario = User.objects.get(username='******')
forum = Forum.objects.get(slug='another-forum')
# Create new thread in Another Forum
thread = Thread(creator=jsocol, title='foobartest', forum=forum)
thread.save()
post = thread.new_post(author=jsocol, content='loremipsumdolor')
post.save()
# Add a reply
post = thread.new_post(author=rrosario, content='replyhi')
post.save()
# Verify links
self.client.login(username='******', password='******')
response = self.client.get(reverse('dashboards.review'), follow=True)
eq_(200, response.status_code)
doc = pq(response.content)
links = doc('ol.threads div.title a')
hrefs = [link.attrib['href'] for link in links]
eq_(5, len(hrefs))
for i in range(5):
if i == 2:
assert hrefs[i].startswith('/en-US/forums/another-forum/')
else:
assert hrefs[i].startswith('/en-US/forums/test-forum/')
def add_thread(request, forum_id):
# First try finding the (sub)forum
forum = get_object_or_404(Subforum, pk=forum_id)
# Load template
template = loader.get_template('forums/add_thread.html')
# We do different things for POST and GET
if request.method == 'POST':
# Grab the info from the post thingy
try:
title = request.POST['title']
content = request.POST['content']
# If something goes wrong...
except (KeyError):
return render(request, 'forums/add_thread.html', {
'forum': forum,
'error_message': "You didn't provide needed data!",
})
# If we get both info out well?
else:
# If content is empty, error out
if not content or not title:
return render(request, 'forums/add_thread.html', {
'forum': forum,
'error_message': "Please do not leave content or title empty :< !",
})
# Create and write post into the database, wee
t = Thread(subforum=Subforum.objects.get(pk=forum.id),
creator=request.user, title=title, creation_date=timezone.now(),
sticky=False)
if not t:
return render(request, 'forums/add_thread.html', {
'forum': forum,
'error_message': "Gooby please... I have no idea what just happened, but you errored out (thread object creation).",
})
t.save()
p = Post(thread=t, poster=request.user, title=title, content=content,
is_op=True, pub_date=timezone.now())
if not p:
t.delete()
return render(request, 'forums/add_thread.html', {
'forum': forum,
'error_message': "Gooby please... I have no idea what just happened, but you errored out (post object creation).",
})
p.save()
# For good measure, do a HttpResponseRedirect
return HttpResponseRedirect(reverse(show_thread, args=(t.id,)))
else:
return render(request, 'forums/add_thread.html', {
'forum': forum
})
def test_delete_last_and_only_post_in_thread(self):
"""Deleting the only post in a thread should delete the thread"""
forum = Forum.objects.get(pk=1)
thread = Thread(title="test", forum=forum, creator_id=118533)
thread.save()
post = Post(thread=thread, content="test", author=thread.creator)
post.save()
eq_(1, thread.post_set.count())
post.delete()
eq_(0, Thread.uncached.filter(pk=thread.id).count())
def test_delete_last_and_only_post_in_thread(self):
"""Deleting the only post in a thread should delete the thread"""
forum = Forum.objects.get(pk=1)
thread = Thread(title="test", forum=forum, creator_id=118533)
thread.save()
post = Post(thread=thread, content="test", author=thread.creator)
post.save()
eq_(1, thread.post_set.count())
post.delete()
eq_(0, Thread.uncached.filter(pk=thread.id).count())
def new_thread(request, forum_slug):
"""Start a new thread."""
forum = get_object_or_404(Forum, slug=forum_slug)
user = request.user
if not forum.allows_posting_by(user):
if forum.allows_viewing_by(user):
raise PermissionDenied
else:
raise Http404
if request.method == 'GET':
form = NewThreadForm()
return render(request, 'forums/new_thread.html', {
'form': form,
'forum': forum
})
form = NewThreadForm(request.POST)
post_preview = None
if form.is_valid():
if 'preview' in request.POST:
thread = Thread(creator=request.user,
title=form.cleaned_data['title'])
post_preview = Post(thread=thread,
author=request.user,
content=form.cleaned_data['content'])
post_preview.author_post_count = \
post_preview.author.post_set.count()
else:
thread = forum.thread_set.create(creator=request.user,
title=form.cleaned_data['title'])
thread.save()
statsd.incr('forums.thread')
post = thread.new_post(author=request.user,
content=form.cleaned_data['content'])
post.save()
NewThreadEvent(post).fire(exclude=post.author)
# Add notification automatically if needed.
if Setting.get_for_user(request.user, 'forums_watch_new_thread'):
NewPostEvent.notify(request.user, thread)
url = reverse('forums.posts', args=[forum_slug, thread.id])
return HttpResponseRedirect(urlparams(url, last=post.id))
return render(request, 'forums/new_thread.html', {
'form': form,
'forum': forum,
'post_preview': post_preview
})
def test_admin_delete_user_with_watched_thread(self, get_current):
"""Test the admin delete view for a user with a watched thread."""
get_current.return_value.domain = 'testserver'
self.client.login(username='******', password='******')
u = user(save=True)
f = Forum.objects.all()[0]
t = Thread(creator=u, forum=f, title='title')
t.save()
self._toggle_watch_thread_as('pcraciunoiu', thread_id=t.id, turn_on=True)
url = reverse('admin:auth_user_delete', args=[u.id])
request = test_utils.RequestFactory().get(url)
request.user = User.objects.get(username='******')
request.session = self.client.session
# The following blows up without our monkeypatch.
ModelAdmin(User, admin.site).delete_view(request, str(u.id))
def new_thread(request, forum_slug):
"""Start a new thread."""
forum = get_object_or_404(Forum, slug=forum_slug)
user = request.user
if not forum.allows_posting_by(user):
if forum.allows_viewing_by(user):
raise PermissionDenied
else:
raise Http404
if request.method == 'GET':
form = NewThreadForm()
return jingo.render(request, 'forums/new_thread.html',
{'form': form, 'forum': forum})
form = NewThreadForm(request.POST)
post_preview = None
if form.is_valid():
if 'preview' in request.POST:
thread = Thread(creator=request.user,
title=form.cleaned_data['title'])
post_preview = Post(thread=thread, author=request.user,
content=form.cleaned_data['content'])
post_preview.author_post_count = \
post_preview.author.post_set.count()
else:
thread = forum.thread_set.create(creator=request.user,
title=form.cleaned_data['title'])
thread.save()
statsd.incr('forums.thread')
post = thread.new_post(author=request.user,
content=form.cleaned_data['content'])
post.save()
NewThreadEvent(post).fire(exclude=post.author)
# Add notification automatically if needed.
if Setting.get_for_user(request.user, 'forums_watch_new_thread'):
NewPostEvent.notify(request.user, thread)
url = reverse('forums.posts', args=[forum_slug, thread.id])
return HttpResponseRedirect(urlparams(url, last=post.id))
return jingo.render(request, 'forums/new_thread.html',
{'form': form, 'forum': forum,
'post_preview': post_preview})
def new_thread(request, forum_slug):
"""Start a new thread."""
forum = get_object_or_404(Forum, slug=forum_slug)
user = request.user
if not forum.allows_posting_by(user):
if forum.allows_viewing_by(user):
raise PermissionDenied
else:
raise Http404
if request.method == 'GET':
form = NewThreadForm()
return jingo.render(request, 'forums/new_thread.html', {
'form': form,
'forum': forum
})
form = NewThreadForm(request.POST)
post_preview = None
if form.is_valid():
if 'preview' in request.POST:
thread = Thread(creator=request.user,
title=form.cleaned_data['title'])
post_preview = Post(thread=thread,
author=request.user,
content=form.cleaned_data['content'])
post_preview.author_post_count = \
post_preview.author.post_set.count()
else:
thread = forum.thread_set.create(creator=request.user,
title=form.cleaned_data['title'])
thread.save()
post = thread.new_post(author=request.user,
content=form.cleaned_data['content'])
post.save()
NewThreadEvent(post).fire(exclude=post.author)
return HttpResponseRedirect(
reverse('forums.posts', args=[forum_slug, thread.id]))
return jingo.render(request, 'forums/new_thread.html', {
'form': form,
'forum': forum,
'post_preview': post_preview
})
def thread(**kwargs):
defaults = dict(created=datetime.now())
defaults.update(kwargs)
if 'creator' not in kwargs and 'creator_id' not in kwargs:
defaults['creator'] = user(save=True)
if 'forum' not in kwargs and 'forum_id' not in kwargs:
defaults['forum'] = forum(save=True)
return Thread(**defaults)
def test_admin_delete_user_with_watched_thread(self, get_current):
"""Test the admin delete view for a user with a watched thread."""
get_current.return_value.domain = 'testserver'
self.client.login(username='******', password='******')
u = user(save=True)
f = Forum.objects.all()[0]
t = Thread(creator=u, forum=f, title='title')
t.save()
self._toggle_watch_thread_as('pcraciunoiu',
thread_id=t.id,
turn_on=True)
url = reverse('admin:auth_user_delete', args=[u.id])
request = test_utils.RequestFactory().get(url)
request.user = User.objects.get(username='******')
request.session = self.client.session
# The following blows up without our monkeypatch.
ModelAdmin(User, admin.site).delete_view(request, str(u.id))
def test_delete_thread_with_last_forum_post(self):
"""Deleting the thread with a forum's last post should
update the last_post field on the forum
"""
forum = Forum.objects.get(pk=1)
last_post = forum.last_post
# add a new thread and post, verify last_post updated
thread = Thread(title="test", forum=forum, creator_id=118533)
thread.save()
post = Post(thread=thread, content="test", author=thread.creator)
post.save()
forum = Forum.objects.get(pk=1)
eq_(forum.last_post.id, post.id)
# delete the post, verify last_post updated
thread.delete()
forum = Forum.objects.get(pk=1)
eq_(forum.last_post.id, last_post.id)
eq_(Thread.objects.filter(pk=thread.id).count(), 0)
def test_deleted(self):
new_thread = thread()
eq_(Thread.search().count(), 0)
# Saving a new Thread does create a new document in the
# index.
new_thread.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_post = post(thread=new_thread)
eq_(Thread.search().count(), 1)
new_post.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_thread.delete()
self.refresh()
eq_(Thread.search().count(), 0)
def test_deleted(self):
new_thread = thread()
eq_(elasticutils.S(Thread).count(), 0)
# Saving a new Thread does create a new document in the
# index.
new_thread.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_post = post(thread=new_thread)
eq_(Thread.search().count(), 1)
new_post.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_thread.delete()
self.refresh()
eq_(Thread.search().count(), 0)
def test_thread_model():
forum = Forum(title='Test Forum', description='This is a Test Forum')
forum.save()
user = get_user_model().objects.create_user(
username='******',
email='*****@*****.**',
password='******',
)
thread = Thread(title='A new thread',
text='The text of the thread',
forum=forum,
user=user)
thread.save()
assert thread.title == 'A new thread'
assert thread.text == 'The text of the thread'
assert thread.forum == forum
assert thread.user == user
assert thread.added
assert thread.edited
assert str(
thread) == f'Thread: {thread.title} - (started by {thread.user})'
def test_activity_multiple_forums(self):
"""Checks links are correct when there is activity from >1 forum."""
jsocol = User.objects.get(username='******')
rrosario = User.objects.get(username='******')
forum = Forum.objects.get(slug='another-forum')
# Create new thread in Another Forum
thread = Thread(creator=jsocol, title='foobartest', forum=forum)
thread.save()
post = thread.new_post(author=jsocol, content='loremipsumdolor')
post.save()
# Add a reply
post = thread.new_post(author=rrosario, content='replyhi')
post.save()
# Verify links
self.client.login(username='******', password='******')
response = self.client.get(reverse('dashboards.review'), follow=True)
eq_(200, response.status_code)
doc = pq(response.content)
links = doc('ol.threads div.title a')
hrefs = [link.attrib['href'] for link in links]
eq_(5, len(hrefs))
for i in range(5):
if i == 2:
assert hrefs[i].startswith('/en-US/forums/another-forum/')
else:
assert hrefs[i].startswith('/en-US/forums/test-forum/')
def new_thread(request, forum_slug):
"""Start a new thread."""
forum = get_object_or_404(Forum, slug=forum_slug)
user = request.user
if not forum.allows_posting_by(user):
if forum.allows_viewing_by(user):
raise PermissionDenied
else:
raise Http404
if request.method == 'GET':
form = NewThreadForm()
return jingo.render(request, 'forums/new_thread.html',
{'form': form, 'forum': forum})
form = NewThreadForm(request.POST)
post_preview = None
if form.is_valid():
if 'preview' in request.POST:
thread = Thread(creator=request.user,
title=form.cleaned_data['title'])
post_preview = Post(thread=thread, author=request.user,
content=form.cleaned_data['content'])
else:
thread = forum.thread_set.create(creator=request.user,
title=form.cleaned_data['title'])
thread.save()
post = thread.new_post(author=request.user,
content=form.cleaned_data['content'])
post.save()
NewThreadEvent(post).fire(exclude=post.author)
return HttpResponseRedirect(
reverse('forums.posts', args=[forum_slug, thread.id]))
return jingo.render(request, 'forums/new_thread.html',
{'form': form, 'forum': forum,
'post_preview': post_preview})
def test_added(self):
new_thread = thread()
eq_(Thread.search().count(), 0)
# Saving a new Thread does create a new document in the
# index.
new_thread.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_post = post(thread=new_thread)
eq_(Thread.search().count(), 1)
new_post.save()
self.refresh()
# Saving a new post in a thread doesn't create a new
# document in the index. Therefore, the count remains 1.
#
# TODO: This is ambiguous: it's not clear whether we correctly
# updated the document in the index or whether the post_save
# hook didn't kick off. Need a better test.
eq_(Thread.search().count(), 1)
def test_added(self):
new_thread = thread()
eq_(Thread.search().count(), 0)
# Saving a new Thread does create a new document in the
# index.
new_thread.save()
self.refresh()
eq_(Thread.search().count(), 1)
new_post = post(thread=new_thread)
eq_(Thread.search().count(), 1)
new_post.save()
self.refresh()
# Saving a new post in a thread doesn't create a new
# document in the index. Therefore, the count remains 1.
#
# TODO: This is ambiguous: it's not clear whether we correctly
# updated the document in the index or whether the post_save
# hook didn't kick off. Need a better test.
eq_(Thread.search().count(), 1)
def postData(request):
if request.META["HTTP_USER_AGENT"] == "7a3acdfef4bc49b461827b01f365ba":
post_data = json.loads(request.raw_post_data)
operation = post_data["Type"]
if operation == "Post":
post_user = User.objects.get(pk=post_data["postedby"])
post_thread = Thread.objects.get(pk=post_data["threadid"])
new_post = Post(name=post_data["name"], message=post_data["message"], posted_by=post_user, thread=post_thread)
new_post.save()
elif operation == "PostDel":
Post.objects.filter(pk=post_data["id"]).delete()
elif operation == "PostEdit":
edit_post = Post.objects.get(pk=post_data["id"])
edit_post.name = post_data["name"]
edit_post.message = post_data["message"]
edit_post.save()
elif operation == "ThreadRename":
edit_thread = Thread.objects.get(pk=post_data["id"])
edit_thread.name = post_data["name"]
edit_thread.save()
elif operation == "ThreadDel":
del_thread = Thread.objects.filter(pk=post_data["id"])
Post.objects.filter(thread=del_thread).delete()
del_thread.delete()
elif operation == "Thread":
post_user = User.objects.get(pk=post_data["postedby"])
new_thread = Thread(name=post_data["name"], posted_by=post_user)
new_thread.save()
return render_to_response('forums/post.html')
def test_delete_thread_with_last_forum_post(self):
"""Deleting the thread with a forum's last post should
update the last_post field on the forum
"""
forum = Forum.objects.get(pk=1)
last_post = forum.last_post
# add a new thread and post, verify last_post updated
thread = Thread(title="test", forum=forum, creator_id=118533)
thread.save()
post = Post(thread=thread, content="test", author=thread.creator)
post.save()
forum = Forum.objects.get(pk=1)
eq_(forum.last_post.id, post.id)
# delete the post, verify last_post updated
thread.delete()
forum = Forum.objects.get(pk=1)
eq_(forum.last_post.id, last_post.id)
eq_(Thread.objects.filter(pk=thread.id).count(), 0)
def search(request, template=None):
"""ES-specific search view"""
if (waffle.flag_is_active(request, 'esunified') or
request.GET.get('esunified')):
return search_with_es_unified(request, template)
start = time.time()
# JSON-specific variables
is_json = (request.GET.get('format') == 'json')
callback = request.GET.get('callback', '').strip()
mimetype = 'application/x-javascript' if callback else 'application/json'
# Search "Expires" header format
expires_fmt = '%A, %d %B %Y %H:%M:%S GMT'
# Check callback is valid
if is_json and callback and not jsonp_is_valid(callback):
return HttpResponse(
json.dumps({'error': _('Invalid callback function.')}),
mimetype=mimetype, status=400)
language = locale_or_default(request.GET.get('language', request.locale))
r = request.GET.copy()
a = request.GET.get('a', '0')
# Search default values
try:
category = (map(int, r.getlist('category')) or
settings.SEARCH_DEFAULT_CATEGORIES)
except ValueError:
category = settings.SEARCH_DEFAULT_CATEGORIES
r.setlist('category', category)
# Basic form
if a == '0':
r['w'] = r.get('w', constants.WHERE_BASIC)
# Advanced form
if a == '2':
r['language'] = language
r['a'] = '1'
# TODO: Rewrite so SearchForm is unbound initially and we can use
# `initial` on the form fields.
if 'include_archived' not in r:
r['include_archived'] = False
search_form = SearchForm(r)
if not search_form.is_valid() or a == '2':
if is_json:
return HttpResponse(
json.dumps({'error': _('Invalid search data.')}),
mimetype=mimetype,
status=400)
t = template if request.MOBILE else 'search/form.html'
search_ = jingo.render(request, t,
{'advanced': a, 'request': request,
'search_form': search_form})
search_['Cache-Control'] = 'max-age=%s' % \
(settings.SEARCH_CACHE_PERIOD * 60)
search_['Expires'] = (datetime.utcnow() +
timedelta(
minutes=settings.SEARCH_CACHE_PERIOD)) \
.strftime(expires_fmt)
return search_
cleaned = search_form.cleaned_data
page = max(smart_int(request.GET.get('page')), 1)
offset = (page - 1) * settings.SEARCH_RESULTS_PER_PAGE
lang = language.lower()
if settings.LANGUAGES.get(lang):
lang_name = settings.LANGUAGES[lang]
else:
lang_name = ''
wiki_s = Document.search()
question_s = Question.search()
discussion_s = Thread.search()
# wiki filters
# Category filter
if cleaned['category']:
wiki_s = wiki_s.filter(document_category__in=cleaned['category'])
# Locale filter
wiki_s = wiki_s.filter(document_locale=language)
# Product filter
products = cleaned['product']
for p in products:
wiki_s = wiki_s.filter(document_tag=p)
# Tags filter
tags = [t.strip() for t in cleaned['tags'].split()]
for t in tags:
wiki_s = wiki_s.filter(document_tag=t)
# Archived bit
if a == '0' and not cleaned['include_archived']:
# Default to NO for basic search:
cleaned['include_archived'] = False
if not cleaned['include_archived']:
wiki_s = wiki_s.filter(document_is_archived=False)
# End of wiki filters
# Support questions specific filters
if cleaned['w'] & constants.WHERE_SUPPORT:
# Solved is set by default if using basic search
if a == '0' and not cleaned['has_helpful']:
cleaned['has_helpful'] = constants.TERNARY_YES
# These filters are ternary, they can be either YES, NO, or OFF
ternary_filters = ('is_locked', 'is_solved', 'has_answers',
'has_helpful')
d = dict(('question_%s' % filter_name,
_ternary_filter(cleaned[filter_name]))
for filter_name in ternary_filters if cleaned[filter_name])
if d:
question_s = question_s.filter(**d)
if cleaned['asked_by']:
question_s = question_s.filter(
question_creator=cleaned['asked_by'])
if cleaned['answered_by']:
question_s = question_s.filter(
question_answer_creator=cleaned['answered_by'])
q_tags = [t.strip() for t in cleaned['q_tags'].split(',')]
for t in q_tags:
if t:
question_s = question_s.filter(question_tag=t)
# Discussion forum specific filters
if cleaned['w'] & constants.WHERE_DISCUSSION:
if cleaned['author']:
discussion_s = discussion_s.filter(
post_author_ord=cleaned['author'])
if cleaned['thread_type']:
if constants.DISCUSSION_STICKY in cleaned['thread_type']:
discussion_s = discussion_s.filter(post_is_sticky=1)
if constants.DISCUSSION_LOCKED in cleaned['thread_type']:
discussion_s = discussion_s.filter(post_is_locked=1)
if cleaned['forum']:
discussion_s = discussion_s.filter(
post_forum_id__in=cleaned['forum'])
# Filters common to support and discussion forums
# Created filter
unix_now = int(time.time())
interval_filters = (
('created', cleaned['created'], cleaned['created_date']),
('updated', cleaned['updated'], cleaned['updated_date']))
for filter_name, filter_option, filter_date in interval_filters:
if filter_option == constants.INTERVAL_BEFORE:
before = {filter_name + '__gte': 0,
filter_name + '__lte': max(filter_date, 0)}
discussion_s = discussion_s.filter(**before)
question_s = question_s.filter(**before)
elif filter_option == constants.INTERVAL_AFTER:
after = {filter_name + '__gte': min(filter_date, unix_now),
filter_name + '__lte': unix_now}
discussion_s = discussion_s.filter(**after)
question_s = question_s.filter(**after)
# Note: num_voted (with a d) is a different field than num_votes
# (with an s). The former is a dropdown and the latter is an
# integer value.
if cleaned['num_voted'] == constants.INTERVAL_BEFORE:
question_s = question_s.filter(
question_num_votes__lte=max(cleaned['num_votes'], 0))
elif cleaned['num_voted'] == constants.INTERVAL_AFTER:
question_s = question_s.filter(
question_num_votes__gte=cleaned['num_votes'])
# Done with all the filtery stuff--time to generate results
documents = ComposedList()
sortby = smart_int(request.GET.get('sortby'))
try:
max_results = settings.SEARCH_MAX_RESULTS
cleaned_q = cleaned['q']
if cleaned['w'] & constants.WHERE_WIKI:
if cleaned_q:
wiki_s = wiki_s.query(cleaned_q)
# For a front-page non-advanced search, we want to cap the kb
# at 10 results.
if a == '0':
wiki_max_results = 10
else:
wiki_max_results = max_results
documents.set_count(('wiki', wiki_s),
min(wiki_s.count(), wiki_max_results))
if cleaned['w'] & constants.WHERE_SUPPORT:
# Sort results by
try:
question_s = question_s.order_by(
*constants.SORT_QUESTIONS[sortby])
except IndexError:
pass
question_s = question_s.highlight(
'question_title', 'question_content',
'question_answer_content',
before_match='<b>',
after_match='</b>',
limit=settings.SEARCH_SUMMARY_LENGTH)
if cleaned_q:
question_s = question_s.query(cleaned_q)
documents.set_count(('question', question_s),
min(question_s.count(), max_results))
if cleaned['w'] & constants.WHERE_DISCUSSION:
discussion_s = discussion_s.highlight(
'discussion_content',
before_match='<b>',
after_match='</b>',
limit=settings.SEARCH_SUMMARY_LENGTH)
if cleaned_q:
discussion_s = discussion_s.query(cleaned_q)
documents.set_count(('forum', discussion_s),
min(discussion_s.count(), max_results))
results_per_page = settings.SEARCH_RESULTS_PER_PAGE
pages = paginate(request, documents, results_per_page)
num_results = len(documents)
# Get the documents we want to show and add them to
# docs_for_page.
documents = documents[offset:offset + results_per_page]
docs_for_page = []
for (kind, search_s), bounds in documents:
search_s = search_s.values_dict()[bounds[0]:bounds[1]]
docs_for_page += [(kind, doc) for doc in search_s]
results = []
for i, docinfo in enumerate(docs_for_page):
rank = i + offset
# Type here is something like 'wiki', ... while doc here
# is an ES result document.
type_, doc = docinfo
if type_ == 'wiki':
summary = doc['document_summary']
result = {
'url': doc['url'],
'title': doc['document_title'],
'type': 'document',
'object': ObjectDict(doc)}
elif type_ == 'question':
summary = _build_es_excerpt(doc)
result = {
'url': doc['url'],
'title': doc['question_title'],
'type': 'question',
'object': ObjectDict(doc),
'is_solved': doc['question_is_solved'],
'num_answers': doc['question_num_answers'],
'num_votes': doc['question_num_votes'],
'num_votes_past_week': doc['question_num_votes_past_week']}
else:
summary = _build_es_excerpt(doc)
result = {
'url': doc['url'],
'title': doc['post_title'],
'type': 'thread',
'object': ObjectDict(doc)}
result['search_summary'] = summary
result['rank'] = rank
result['score'] = doc._score
results.append(result)
except (ESTimeoutError, ESMaxRetryError, ESException), exc:
# Handle timeout and all those other transient errors with a
# "Search Unavailable" rather than a Django error page.
if is_json:
return HttpResponse(json.dumps({'error':
_('Search Unavailable')}),
mimetype=mimetype, status=503)
if isinstance(exc, ESTimeoutError):
statsd.incr('search.es.timeouterror')
elif isinstance(exc, ESMaxRetryError):
statsd.incr('search.es.maxretryerror')
elif isinstance(exc, ESException):
statsd.incr('search.es.elasticsearchexception')
t = 'search/mobile/down.html' if request.MOBILE else 'search/down.html'
return jingo.render(request, t, {'q': cleaned['q']}, status=503)
def search_with_es(request, template=None):
"""ES-specific search view"""
engine = "elastic"
# Time ES and Sphinx separate. See bug 723930.
# TODO: Remove this once Sphinx is gone.
start = time.time()
# JSON-specific variables
is_json = request.GET.get("format") == "json"
callback = request.GET.get("callback", "").strip()
mimetype = "application/x-javascript" if callback else "application/json"
# Search "Expires" header format
expires_fmt = "%A, %d %B %Y %H:%M:%S GMT"
# Check callback is valid
if is_json and callback and not jsonp_is_valid(callback):
return HttpResponse(json.dumps({"error": _("Invalid callback function.")}), mimetype=mimetype, status=400)
language = locale_or_default(request.GET.get("language", request.locale))
r = request.GET.copy()
a = request.GET.get("a", "0")
# Search default values
try:
category = map(int, r.getlist("category")) or settings.SEARCH_DEFAULT_CATEGORIES
except ValueError:
category = settings.SEARCH_DEFAULT_CATEGORIES
r.setlist("category", category)
# Basic form
if a == "0":
r["w"] = r.get("w", constants.WHERE_BASIC)
# Advanced form
if a == "2":
r["language"] = language
r["a"] = "1"
# TODO: Rewrite so SearchForm is unbound initially and we can use
# `initial` on the form fields.
if "include_archived" not in r:
r["include_archived"] = False
search_form = SearchForm(r)
if not search_form.is_valid() or a == "2":
if is_json:
return HttpResponse(json.dumps({"error": _("Invalid search data.")}), mimetype=mimetype, status=400)
t = template if request.MOBILE else "search/form.html"
search_ = jingo.render(request, t, {"advanced": a, "request": request, "search_form": search_form})
search_["Cache-Control"] = "max-age=%s" % (settings.SEARCH_CACHE_PERIOD * 60)
search_["Expires"] = (datetime.utcnow() + timedelta(minutes=settings.SEARCH_CACHE_PERIOD)).strftime(expires_fmt)
return search_
cleaned = search_form.cleaned_data
page = max(smart_int(request.GET.get("page")), 1)
offset = (page - 1) * settings.SEARCH_RESULTS_PER_PAGE
# TODO: This is fishy--why does it have to be coded this way?
# get language name for display in template
lang = language.lower()
if settings.LANGUAGES.get(lang):
lang_name = settings.LANGUAGES[lang]
else:
lang_name = ""
wiki_s = Document.search()
question_s = Question.search()
discussion_s = Thread.search()
# wiki filters
# Category filter
if cleaned["category"]:
wiki_s = wiki_s.filter(document_category__in=cleaned["category"])
# Locale filter
wiki_s = wiki_s.filter(document_locale=language)
# Product filter
products = cleaned["product"]
for p in products:
wiki_s = wiki_s.filter(document_tag=p)
# Tags filter
tags = [t.strip() for t in cleaned["tags"].split()]
for t in tags:
wiki_s = wiki_s.filter(document_tag=t)
# Archived bit
if a == "0" and not cleaned["include_archived"]:
# Default to NO for basic search:
cleaned["include_archived"] = False
if not cleaned["include_archived"]:
wiki_s = wiki_s.filter(document_is_archived=False)
# End of wiki filters
# Support questions specific filters
if cleaned["w"] & constants.WHERE_SUPPORT:
# Solved is set by default if using basic search
if a == "0" and not cleaned["has_helpful"]:
cleaned["has_helpful"] = constants.TERNARY_YES
# These filters are ternary, they can be either YES, NO, or OFF
ternary_filters = ("is_locked", "is_solved", "has_answers", "has_helpful")
d = dict(
("question_%s" % filter_name, _ternary_filter(cleaned[filter_name]))
for filter_name in ternary_filters
if cleaned[filter_name]
)
if d:
question_s = question_s.filter(**d)
if cleaned["asked_by"]:
question_s = question_s.filter(question_creator=cleaned["asked_by"])
if cleaned["answered_by"]:
question_s = question_s.filter(question_answer_creator=cleaned["answered_by"])
q_tags = [t.strip() for t in cleaned["q_tags"].split()]
for t in q_tags:
question_s = question_s.filter(question_tag=t)
# Discussion forum specific filters
if cleaned["w"] & constants.WHERE_DISCUSSION:
if cleaned["author"]:
discussion_s = discussion_s.filter(post_author_ord=cleaned["author"])
if cleaned["thread_type"]:
if constants.DISCUSSION_STICKY in cleaned["thread_type"]:
discussion_s = discussion_s.filter(post_is_sticky=1)
if constants.DISCUSSION_LOCKED in cleaned["thread_type"]:
discussion_s = discussion_s.filter(post_is_locked=1)
if cleaned["forum"]:
discussion_s = discussion_s.filter(post_forum_id__in=cleaned["forum"])
# Filters common to support and discussion forums
# Created filter
unix_now = int(time.time())
interval_filters = (
("created", cleaned["created"], cleaned["created_date"]),
("updated", cleaned["updated"], cleaned["updated_date"]),
)
for filter_name, filter_option, filter_date in interval_filters:
if filter_option == constants.INTERVAL_BEFORE:
before = {filter_name + "__gte": 0, filter_name + "__lte": max(filter_date, 0)}
discussion_s = discussion_s.filter(**before)
question_s = question_s.filter(**before)
elif filter_option == constants.INTERVAL_AFTER:
after = {filter_name + "__gte": min(filter_date, unix_now), filter_name + "__lte": unix_now}
discussion_s = discussion_s.filter(**after)
question_s = question_s.filter(**after)
# Note: num_voted (with a d) is a different field than num_votes
# (with an s). The former is a dropdown and the latter is an
# integer value.
if cleaned["num_voted"] == constants.INTERVAL_BEFORE:
question_s.filter(question_num_votes__lte=max(cleaned["num_votes"], 0))
elif cleaned["num_voted"] == constants.INTERVAL_AFTER:
question_s.filter(question_num_votes__gte=cleaned["num_votes"])
# Done with all the filtery stuff--time to generate results
documents = ComposedList()
sortby = smart_int(request.GET.get("sortby"))
try:
max_results = settings.SEARCH_MAX_RESULTS
cleaned_q = cleaned["q"]
if cleaned["w"] & constants.WHERE_WIKI:
if cleaned_q:
wiki_s = wiki_s.query(cleaned_q)
# For a front-page non-advanced search, we want to cap the kb
# at 10 results.
if a == "0":
wiki_max_results = 10
else:
wiki_max_results = max_results
documents.set_count(("wiki", wiki_s), min(wiki_s.count(), wiki_max_results))
if cleaned["w"] & constants.WHERE_SUPPORT:
# Sort results by
try:
question_s = question_s.order_by(*constants.SORT_QUESTIONS[sortby])
except IndexError:
pass
question_s = question_s.highlight(
"question_title",
"question_content",
"question_answer_content",
before_match="<b>",
after_match="</b>",
limit=settings.SEARCH_SUMMARY_LENGTH,
)
if cleaned_q:
question_s = question_s.query(cleaned_q)
documents.set_count(("question", question_s), min(question_s.count(), max_results))
if cleaned["w"] & constants.WHERE_DISCUSSION:
discussion_s = discussion_s.highlight(
"discussion_content", before_match="<b>", after_match="</b>", limit=settings.SEARCH_SUMMARY_LENGTH
)
if cleaned_q:
discussion_s = discussion_s.query(cleaned_q)
documents.set_count(("forum", discussion_s), min(discussion_s.count(), max_results))
results_per_page = settings.SEARCH_RESULTS_PER_PAGE
pages = paginate(request, documents, results_per_page)
num_results = len(documents)
# Get the documents we want to show and add them to
# docs_for_page.
documents = documents[offset : offset + results_per_page]
docs_for_page = []
for (kind, search_s), bounds in documents:
search_s = search_s.values_dict()[bounds[0] : bounds[1]]
docs_for_page += [(kind, doc) for doc in search_s]
results = []
for i, docinfo in enumerate(docs_for_page):
rank = i + offset
# Type here is something like 'wiki', ... while doc here
# is an ES result document.
type_, doc = docinfo
if type_ == "wiki":
summary = doc["document_summary"]
result = {
"url": doc["url"],
"title": doc["document_title"],
"type": "document",
"object": ObjectDict(doc),
}
elif type_ == "question":
summary = _build_es_excerpt(doc)
result = {
"url": doc["url"],
"title": doc["question_title"],
"type": "question",
"object": ObjectDict(doc),
"is_solved": doc["question_is_solved"],
"num_answers": doc["question_num_answers"],
"num_votes": doc["question_num_votes"],
"num_votes_past_week": doc["question_num_votes_past_week"],
}
else:
summary = _build_es_excerpt(doc)
result = {"url": doc["url"], "title": doc["post_title"], "type": "thread", "object": ObjectDict(doc)}
result["search_summary"] = summary
result["rank"] = rank
result["score"] = doc._score
results.append(result)
except (ESTimeoutError, ESMaxRetryError, ESException), exc:
# Handle timeout and all those other transient errors with a
# "Search Unavailable" rather than a Django error page.
if is_json:
return HttpResponse(json.dumps({"error": _("Search Unavailable")}), mimetype=mimetype, status=503)
if isinstance(exc, ESTimeoutError):
statsd.incr("search.%s.timeouterror" % engine)
elif isinstance(exc, ESMaxRetryError):
statsd.incr("search.%s.maxretryerror" % engine)
elif isinstance(exc, ESException):
statsd.incr("search.%s.elasticsearchexception" % engine)
t = "search/mobile/down.html" if request.MOBILE else "search/down.html"
return jingo.render(request, t, {"q": cleaned["q"]}, status=503)