def similar(request, page=None):
'''
Show users most similar to the logged in user.
'''
if request.user.is_authenticated():
if page is None:
page = 1
else:
page = int(page)
n = 10
similarity_max = get_max_similarity(request.user)
similar_users = request.user.similar()
count = similar_users.count()
# pagination
similar_users, paginator, current_page, page_range = paginate(similar_users, page, n)
likes = likes_gen(similar_users, request.user)
return render_to_response('user/similar.html', locals(), context_instance=RequestContext(request))
else:
return render_to_response('user/similar_anonymous.html', context_instance=RequestContext(request))
def reviews(request, username, page=None):
if page is None:
page = 1
else:
page = int(page)
n = 10
review_user = get_object_or_404(User, username=username)
reviews = Review.objects.filter(user=review_user).extra(
select={
'rating': 'SELECT rating FROM main_opinion WHERE main_opinion.item_id=main_review.item_id AND main_opinion.user_id=main_review.user_id',
'time': 'SELECT time FROM main_action WHERE main_review.id=main_action.review_id AND type=2',
},
).select_related('item').order_by('-time')
# pagination
reviews, paginator, current_page, page_range = paginate(reviews, page, n)
for review in reviews:
review.rating_verbose = Opinion(rating=review.rating).get_third_person()
single = False
return render_to_response('user/reviews.html', locals(), context_instance=RequestContext(request))
def query(request, query=None, page=None, json=False, autocomplete=False):
def invalid_search():
if json:
return render_to_response(
"search/invalid.json", locals(), context_instance=RequestContext(request), mimetype="application/json"
)
else:
return render_to_response("search/invalid.html", locals(), context_instance=RequestContext(request))
if "q" in request.GET:
query = request.GET["q"]
if page is None:
page = 1
else:
page = int(page)
n = 10
modifiers = {"tag": []}
words = query.split()
if autocomplete:
json = True
if len(words) > 1 and words[0] == "!":
modifiers["bang"] = True
words = words[1:]
words_cleaned = []
for word in words:
mod, colon, arg = word.partition(":")
if not colon:
words_cleaned.append(word)
continue
if mod == "in":
modifiers["in"] = arg
elif mod == "tag":
modifiers["tag"].append(arg)
else:
words_cleaned.append(word)
words = words_cleaned
title = " ".join(words)
results = Item.search.query(title).order_by("-opinion_count", "@weight").select_related("category")
if request.user.is_authenticated() and not json:
results = results.extra(
select={
"rating": "SELECT COALESCE((SELECT rating FROM main_opinion mo WHERE mo.user_id=%s AND mo.item_id=main_item.id))"
},
select_params=[request.user.id],
)
tags = Tag.objects.filter(name__in=modifiers["tag"])
for tag in tags:
results = results.filter(tag=tag.id)
results_pre_categories = results
if "in" in modifiers:
cat_name = modifiers["in"]
try:
category = Category.objects.get(
Q(name__iexact=cat_name)
| Q(element_singular__iexact=cat_name)
| Q(element_plural__iexact=cat_name)
| Q(slug__iexact=cat_name)
)
results = results.filter(category_id=category.id)
except Category.DoesNotExist:
return invalid_search()
if "bang" in modifiers and not json:
try:
result = results[0]
from django.shortcuts import redirect
from django.utils.http import int_to_base36
from django.core.urlresolvers import reverse
from django.template.defaultfilters import slugify
return redirect(result.get_absolute_url())
except IndexError:
from django.http import Http404
raise Http404
except SearchError:
return invalid_search()
results_categories = results_pre_categories.group_by("category_id", djangosphinx_api.SPH_GROUPBY_ATTR)
cats = map(lambda x: x._sphinx["attrs"]["@groupby"], results_categories)
categories = Category.objects.in_bulk(cats)
category_counts = []
for r in results_categories:
cat_id = r._sphinx["attrs"]["@groupby"]
cat_count = r._sphinx["attrs"]["@count"]
category_counts.append({"category": categories[cat_id], "count": cat_count})
category_counts.sort(key=lambda x: x["count"], reverse=True)
try:
count = results.count()
except SearchError:
return invalid_search()
results, paginator, current_page, page_range = paginate(results, page, n)
if json:
if autocomplete:
for result in results:
result.highlighted_name = result.name
return render_to_response(
"search/results.json", locals(), context_instance=RequestContext(request), mimetype="application/json"
)
else:
return render_to_response("search/results.html", locals(), context_instance=RequestContext(request))
def overview(request, username, category_slug=None, page=None, json=None):
viewed_user = get_object_or_404(User, username=username)
if page is None:
page = 1
else:
page = int(page)
n = 100
if category_slug is not None and category_slug:
category = Category.objects.get(slug=category_slug)
else:
category = None
hide = False
if viewed_user.id == 1:
# don't show drx's links
hide = True
categories = viewed_user.categories(hide=hide)
your_profile = False
if request.user==viewed_user:
your_profile = True
select=[
('review', 'SELECT EXISTS (SELECT 1 FROM main_review WHERE main_review.user_id = %s AND main_review.item_id = main_item.id)'),
('action_time', 'SELECT time FROM main_action WHERE main_action.opinion_id = main_opinion.id')
]
select_params=[viewed_user.id]
if request.user.is_authenticated():
select += [('your_rating', 'SELECT rating FROM main_opinion mo2 WHERE mo2.user_id = %s AND mo2.item_id = main_item.id')]
select_params += [request.user.id]
show_controversial = False
select = SortedDict(select)
opinions = Opinion.objects.filter(user__exact=viewed_user).select_related('item__category').order_by('-action__time', '-rating','item__name').extra(
select=select, select_params=select_params
)
if category is not None:
opinions = opinions.filter(item__category=category)
else:
opinions = opinions.exclude(item__category__name='Lists')
if hide:
opinions = opinions.filter(item__category__hide=False)
category_counts = viewed_user.categories(hide=hide)
if request.user==viewed_user or not request.user.is_authenticated():
similarity = 0
similarity_max = 10
else:
similarity_max = get_max_similarity(request.user)
try:
similarity = viewed_user.similarity_set.get(
user2=request.user.id).value
except ObjectDoesNotExist:
similarity = 0
lists = viewed_user.list_set.all()
# pagination
opinions, paginator, current_page, page_range = paginate(opinions, page, n)
if json:
return render_to_response('user/overview.json', locals(), context_instance=RequestContext(request), mimetype='application/json')
else:
return render_to_response('user/overview.html', locals(), context_instance=RequestContext(request))
