2011-10-12 08:29:21 -07:00
|
|
|
from annoying.decorators import render_to
|
2015-07-24 18:39:25 -07:00
|
|
|
from annoying.functions import get_object_or_None
|
2012-06-04 17:57:20 -07:00
|
|
|
from blogs.views import blog_list
|
2012-04-22 20:51:52 -07:00
|
|
|
from django.conf import settings
|
2015-07-24 18:39:25 -07:00
|
|
|
from django.contrib.auth.models import User
|
2016-03-31 07:27:56 -07:00
|
|
|
from django.core.mail import send_mail
|
2015-07-24 18:39:25 -07:00
|
|
|
from django.core.paginator import Paginator, InvalidPage
|
|
|
|
from django.db.models import Count
|
2012-02-13 19:36:59 -08:00
|
|
|
from django.db.models import Q
|
2016-04-02 09:36:57 -07:00
|
|
|
from django.http import Http404, HttpResponse, HttpResponseRedirect, HttpResponseBadRequest
|
2016-11-01 09:59:35 -07:00
|
|
|
from django.shortcuts import get_object_or_404, render
|
2015-07-24 18:39:25 -07:00
|
|
|
from django.template import RequestContext
|
2015-10-27 11:08:28 -07:00
|
|
|
from django.views.decorators.cache import never_cache
|
2012-04-22 20:51:52 -07:00
|
|
|
from haystack.forms import ModelSearchForm
|
|
|
|
from haystack.query import EmptySearchQuerySet, SearchQuerySet
|
2015-07-24 18:39:25 -07:00
|
|
|
from pygments.lexers import get_lexer_by_name
|
2016-05-12 08:47:07 -07:00
|
|
|
from snipts.models import Favorite, Snipt, SniptSecureView
|
2015-07-24 18:39:25 -07:00
|
|
|
from taggit.models import Tag
|
2015-10-24 17:55:58 -07:00
|
|
|
from teams.models import Team
|
2012-04-22 20:51:52 -07:00
|
|
|
|
2016-11-01 11:30:33 -07:00
|
|
|
import os
|
|
|
|
|
|
|
|
|
2013-10-18 21:04:23 -07:00
|
|
|
RESULTS_PER_PAGE = getattr(settings, 'HAYSTACK_SEARCH_RESULTS_PER_PAGE', 20)
|
|
|
|
|
2012-04-22 20:51:52 -07:00
|
|
|
|
2012-05-31 19:32:32 -07:00
|
|
|
@render_to('snipts/detail.html')
|
|
|
|
def detail(request, username, snipt_slug):
|
|
|
|
|
|
|
|
snipt = get_object_or_404(Snipt, user__username=username, slug=snipt_slug)
|
|
|
|
user = snipt.user
|
|
|
|
|
2012-07-23 07:09:26 -07:00
|
|
|
if snipt.lexer != 'markdown':
|
|
|
|
if 'linenos' not in snipt.stylized:
|
|
|
|
snipt.save()
|
2012-07-23 07:05:56 -07:00
|
|
|
|
2012-05-31 19:32:32 -07:00
|
|
|
if user != request.user:
|
|
|
|
if not snipt.public:
|
|
|
|
if 'key' not in request.GET:
|
|
|
|
raise Http404
|
|
|
|
else:
|
|
|
|
if request.GET.get('key') != snipt.key:
|
|
|
|
raise Http404
|
|
|
|
|
2016-05-12 08:47:07 -07:00
|
|
|
if snipt.secure and not request.user.is_authenticated():
|
|
|
|
raise Http404
|
|
|
|
|
2013-10-15 07:23:50 -07:00
|
|
|
snipt.views = snipt.views + 1
|
|
|
|
snipt.save()
|
2012-09-17 10:26:54 -07:00
|
|
|
|
2016-05-12 08:47:07 -07:00
|
|
|
if snipt.secure:
|
|
|
|
secure_view = SniptSecureView(user=request.user, snipt=snipt)
|
|
|
|
secure_view.save()
|
|
|
|
|
2012-05-31 19:32:32 -07:00
|
|
|
tags = Tag.objects
|
|
|
|
|
|
|
|
if user == request.user:
|
|
|
|
tags = tags.filter(snipt__user=user)
|
|
|
|
public = False
|
|
|
|
else:
|
|
|
|
tags = tags.filter(snipt__user=user, snipt__public=True)
|
|
|
|
public = True
|
|
|
|
|
|
|
|
tags = tags.annotate(count=Count('taggit_taggeditem_items__id'))
|
|
|
|
tags = tags.order_by('-count', 'name')
|
|
|
|
|
|
|
|
return {
|
|
|
|
'detail': True,
|
|
|
|
'has_snipts': True,
|
|
|
|
'public': public,
|
|
|
|
'snipt': snipt,
|
|
|
|
'tags': tags,
|
|
|
|
'user': user,
|
|
|
|
}
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-05-19 10:33:44 -07:00
|
|
|
def download(request, snipt_key):
|
|
|
|
snipt = get_object_or_404(Snipt, key=snipt_key)
|
|
|
|
return HttpResponse(snipt.code, content_type='application/x-download')
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2012-05-31 19:32:32 -07:00
|
|
|
def embed(request, snipt_key):
|
|
|
|
snipt = get_object_or_404(Snipt, key=snipt_key)
|
|
|
|
|
|
|
|
lines = snipt.embedded.split('\n')
|
2016-11-01 09:59:35 -07:00
|
|
|
return render(request,
|
|
|
|
'snipts/embed.html',
|
|
|
|
{'lines': lines, 'snipt': snipt},
|
|
|
|
content_type='application/javascript')
|
2012-05-31 19:32:32 -07:00
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-02-08 18:01:23 -08:00
|
|
|
@render_to('snipts/list-user.html')
|
|
|
|
def blog_posts(request, username):
|
|
|
|
|
|
|
|
if request.blog_user:
|
|
|
|
raise Http404
|
|
|
|
|
|
|
|
if request.user.username == username:
|
|
|
|
public = False
|
|
|
|
public_user = False
|
|
|
|
user = request.user
|
2013-02-13 07:52:08 -08:00
|
|
|
snipts = Snipt.objects.filter(user=request.user, blog_post=True)
|
2013-02-08 18:01:23 -08:00
|
|
|
tags = Tag.objects.filter(snipt__user=request.user).distinct()
|
|
|
|
else:
|
|
|
|
public = True
|
|
|
|
public_user = True
|
2013-02-13 07:15:54 -08:00
|
|
|
user = get_object_or_404(User, username=username)
|
2013-02-13 07:52:08 -08:00
|
|
|
snipts = Snipt.objects.filter(blog_post=True, user=user, public=True)
|
2015-07-24 18:28:31 -07:00
|
|
|
tags = Tag.objects.filter(snipt__user=user,
|
|
|
|
snipt__public=True).distinct()
|
2013-02-08 18:01:23 -08:00
|
|
|
|
|
|
|
tags = tags.order_by('name')
|
|
|
|
snipts = snipts.order_by('-created')
|
|
|
|
|
|
|
|
context = {
|
|
|
|
'has_snipts': True,
|
|
|
|
'public': public,
|
|
|
|
'public_user': public_user,
|
|
|
|
'snipts': snipts,
|
|
|
|
'tags': tags,
|
|
|
|
'user': user,
|
|
|
|
}
|
|
|
|
|
|
|
|
if 'rss' in request.GET:
|
|
|
|
context['snipts'] = context['snipts'][:20]
|
|
|
|
return rss(request, context)
|
|
|
|
|
|
|
|
return context
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2012-10-17 17:52:12 -07:00
|
|
|
@render_to('snipts/list-user.html')
|
|
|
|
def favorites(request, username):
|
|
|
|
|
|
|
|
if request.user.username != username:
|
|
|
|
raise Http404
|
|
|
|
|
|
|
|
if request.blog_user:
|
|
|
|
raise Http404
|
|
|
|
|
|
|
|
public = False
|
|
|
|
|
|
|
|
favorites = Favorite.objects.filter(user=request.user).values('snipt')
|
|
|
|
favorites = [f['snipt'] for f in favorites]
|
|
|
|
snipts = Snipt.objects.filter(Q(pk__in=favorites))
|
|
|
|
|
|
|
|
tags = Tag.objects.filter(snipt__user=request.user).distinct()
|
|
|
|
|
|
|
|
tags = tags.order_by('name')
|
|
|
|
snipts = snipts.order_by('-created')
|
|
|
|
|
|
|
|
context = {
|
|
|
|
'favorites': favorites,
|
|
|
|
'has_snipts': True,
|
|
|
|
'public': public,
|
|
|
|
'public_user': False,
|
|
|
|
'snipts': snipts,
|
|
|
|
'tags': tags,
|
|
|
|
'user': request.user,
|
|
|
|
}
|
|
|
|
|
|
|
|
if 'rss' in request.GET:
|
|
|
|
context['snipts'] = context['snipts'][:20]
|
|
|
|
return rss(request, context)
|
|
|
|
|
|
|
|
return context
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2011-10-12 13:34:01 -07:00
|
|
|
@render_to('snipts/list-public.html')
|
2012-01-16 15:47:09 -08:00
|
|
|
def list_public(request, tag_slug=None):
|
2011-10-12 08:29:21 -07:00
|
|
|
|
2012-06-01 08:41:06 -07:00
|
|
|
if request.blog_user:
|
|
|
|
return blog_list(request)
|
|
|
|
|
2013-07-31 17:17:05 -07:00
|
|
|
snipts = Snipt.objects.filter(public=True).order_by('-created')
|
2011-10-12 08:29:21 -07:00
|
|
|
|
2012-01-16 15:47:09 -08:00
|
|
|
if tag_slug:
|
2012-03-10 18:52:46 -08:00
|
|
|
snipts = snipts.filter(tags__slug__in=[tag_slug])
|
|
|
|
tag = get_object_or_404(Tag, slug=tag_slug)
|
2012-03-10 20:36:44 -08:00
|
|
|
else:
|
|
|
|
tag = None
|
2011-12-02 21:19:01 -08:00
|
|
|
|
2012-04-13 20:30:23 -07:00
|
|
|
context = {
|
2012-03-06 08:29:43 -08:00
|
|
|
'has_snipts': True,
|
2012-02-12 18:13:13 -08:00
|
|
|
'public': True,
|
2011-10-12 08:29:21 -07:00
|
|
|
'snipts': snipts,
|
2012-03-10 18:52:46 -08:00
|
|
|
'tag': tag,
|
2011-10-12 08:29:21 -07:00
|
|
|
}
|
|
|
|
|
2012-04-13 20:30:23 -07:00
|
|
|
if 'rss' in request.GET:
|
|
|
|
context['snipts'] = context['snipts'][:20]
|
|
|
|
return rss(request, context)
|
|
|
|
|
|
|
|
return context
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2011-10-12 13:34:01 -07:00
|
|
|
@render_to('snipts/list-user.html')
|
2012-05-03 19:19:05 -07:00
|
|
|
def list_user(request, username_or_custom_slug, tag_slug=None):
|
|
|
|
|
2012-06-01 08:41:06 -07:00
|
|
|
if request.blog_user:
|
2012-06-01 18:05:25 -07:00
|
|
|
return blog_list(request, username_or_custom_slug)
|
2012-06-01 08:41:06 -07:00
|
|
|
|
2012-05-03 19:19:05 -07:00
|
|
|
user = get_object_or_None(User, username=username_or_custom_slug)
|
|
|
|
|
|
|
|
if user is None:
|
|
|
|
snipt = get_object_or_404(Snipt, custom_slug=username_or_custom_slug)
|
|
|
|
return detail(request, snipt.user, snipt.slug)
|
2011-10-12 08:29:21 -07:00
|
|
|
|
2011-10-12 13:34:01 -07:00
|
|
|
tags = Tag.objects
|
|
|
|
snipts = Snipt.objects
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
if user == request.user or \
|
2015-10-18 07:35:44 -07:00
|
|
|
(request.GET.get('api_key') == user.api_key.key) or \
|
2015-10-18 08:52:44 -07:00
|
|
|
(user.profile.is_a_team and
|
|
|
|
user.team.user_is_member(request.user)):
|
2015-10-18 07:35:44 -07:00
|
|
|
|
2012-02-12 21:42:25 -08:00
|
|
|
public = False
|
2012-02-13 19:36:59 -08:00
|
|
|
|
|
|
|
favorites = Favorite.objects.filter(user=user).values('snipt')
|
|
|
|
favorites = [f['snipt'] for f in favorites]
|
|
|
|
snipts = snipts.filter(Q(user=user) | Q(pk__in=favorites))
|
2012-04-12 19:04:37 -07:00
|
|
|
|
2012-10-17 17:52:12 -07:00
|
|
|
tags = tags.filter(snipt__user=user).distinct()
|
|
|
|
|
2011-10-12 13:34:01 -07:00
|
|
|
else:
|
2012-10-17 17:52:12 -07:00
|
|
|
tags = tags.filter(snipt__user=user, snipt__public=True).distinct()
|
2011-10-12 13:34:01 -07:00
|
|
|
snipts = snipts.filter(user=user, public=True)
|
2012-02-12 21:42:25 -08:00
|
|
|
public = True
|
2011-10-12 13:34:01 -07:00
|
|
|
|
2012-04-29 07:55:06 -07:00
|
|
|
tags = tags.order_by('name')
|
2011-10-12 13:34:01 -07:00
|
|
|
snipts = snipts.order_by('-created')
|
2011-10-10 21:13:18 -07:00
|
|
|
|
2012-01-16 15:47:09 -08:00
|
|
|
if tag_slug:
|
2012-03-10 18:52:46 -08:00
|
|
|
snipts = snipts.filter(tags__slug__in=[tag_slug])
|
|
|
|
tag = get_object_or_404(Tag, slug=tag_slug)
|
2012-03-10 20:36:44 -08:00
|
|
|
else:
|
|
|
|
tag = None
|
2011-12-02 21:19:01 -08:00
|
|
|
|
2012-07-05 17:07:49 -07:00
|
|
|
if tag is None:
|
|
|
|
snipts = snipts.exclude(tags__name__in=['tmp'])
|
|
|
|
|
2012-04-13 20:30:23 -07:00
|
|
|
context = {
|
2012-03-06 08:29:43 -08:00
|
|
|
'has_snipts': True,
|
2012-02-12 21:42:25 -08:00
|
|
|
'public': public,
|
2012-04-13 13:26:58 -07:00
|
|
|
'public_user': (public and user),
|
2011-10-10 21:13:18 -07:00
|
|
|
'snipts': snipts,
|
|
|
|
'tags': tags,
|
2012-03-10 18:52:46 -08:00
|
|
|
'tag': tag,
|
2011-10-12 13:34:01 -07:00
|
|
|
'user': user,
|
2016-11-01 07:03:12 -07:00
|
|
|
'users_for_full_page': ['robertbanh'],
|
2011-10-10 20:30:56 -07:00
|
|
|
}
|
2012-01-16 15:04:24 -08:00
|
|
|
|
2012-04-13 20:30:23 -07:00
|
|
|
if 'rss' in request.GET:
|
|
|
|
context['snipts'] = context['snipts'][:20]
|
|
|
|
return rss(request, context)
|
|
|
|
|
|
|
|
return context
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-03-21 09:48:25 -07:00
|
|
|
def raw(request, snipt_key, lexer=None):
|
2012-05-10 18:34:11 -07:00
|
|
|
snipt = get_object_or_404(Snipt, key=snipt_key)
|
|
|
|
|
2013-03-21 09:48:25 -07:00
|
|
|
if request.user == snipt.user:
|
|
|
|
if lexer:
|
|
|
|
lexer = lexer.strip('/')
|
|
|
|
|
|
|
|
if lexer != snipt.lexer:
|
|
|
|
|
|
|
|
try:
|
|
|
|
lexer_obj = get_lexer_by_name(lexer)
|
|
|
|
except:
|
|
|
|
lexer_obj = None
|
|
|
|
|
|
|
|
if lexer_obj:
|
|
|
|
snipt.lexer = lexer
|
|
|
|
snipt.save()
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
content_type = 'text/plain'
|
2012-05-10 18:34:11 -07:00
|
|
|
|
2013-03-15 11:58:56 -07:00
|
|
|
if 'nice' in request.GET:
|
2015-07-24 18:28:31 -07:00
|
|
|
content_type = 'text/html'
|
2013-03-15 11:58:56 -07:00
|
|
|
|
2016-11-01 09:59:35 -07:00
|
|
|
return render(request,
|
|
|
|
'snipts/raw.html',
|
|
|
|
{'snipt': snipt},
|
|
|
|
content_type=content_type)
|
2012-05-10 18:34:11 -07:00
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2012-04-13 20:30:23 -07:00
|
|
|
def rss(request, context):
|
2016-11-01 09:59:35 -07:00
|
|
|
return render(request,
|
|
|
|
'rss.xml',
|
|
|
|
context,
|
|
|
|
content_type="application/rss+xml")
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2012-04-22 20:51:52 -07:00
|
|
|
|
2015-10-27 11:08:28 -07:00
|
|
|
@never_cache
|
2013-05-08 21:38:24 -07:00
|
|
|
def search(request, template='search/search.html', load_all=True,
|
|
|
|
form_class=ModelSearchForm, searchqueryset=None,
|
|
|
|
context_class=RequestContext, extra_context=None,
|
|
|
|
results_per_page=None):
|
|
|
|
|
2012-04-22 20:51:52 -07:00
|
|
|
query = ''
|
|
|
|
results = EmptySearchQuerySet()
|
|
|
|
|
|
|
|
if request.GET.get('q'):
|
2013-05-08 21:38:24 -07:00
|
|
|
|
2015-10-24 17:55:58 -07:00
|
|
|
searchqueryset = SearchQuerySet() \
|
|
|
|
.filter(Q(public=True) | Q(author=request.user)) \
|
|
|
|
.order_by('-pub_date')
|
|
|
|
|
|
|
|
if request.user.is_authenticated() and \
|
|
|
|
'mine-only' in request.GET:
|
2015-07-24 18:28:31 -07:00
|
|
|
searchqueryset = SearchQuerySet().filter(author=request.user) \
|
|
|
|
.order_by('-pub_date')
|
2015-10-24 17:55:58 -07:00
|
|
|
|
|
|
|
elif request.user.is_authenticated() and \
|
|
|
|
('author' in request.GET and
|
|
|
|
request.GET.get('author')):
|
|
|
|
|
|
|
|
author = request.GET.get('author')
|
|
|
|
|
|
|
|
if author == request.user.username:
|
|
|
|
searchqueryset = SearchQuerySet().filter(author=request.user) \
|
|
|
|
.order_by('-pub_date')
|
|
|
|
|
|
|
|
else:
|
|
|
|
team = get_object_or_None(Team, slug=author)
|
|
|
|
|
|
|
|
if team and team.user_is_member(request.user):
|
|
|
|
searchqueryset = SearchQuerySet().filter(author=team) \
|
|
|
|
.order_by('-pub_date')
|
2013-05-08 21:38:24 -07:00
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
form = ModelSearchForm(request.GET,
|
|
|
|
searchqueryset=searchqueryset,
|
|
|
|
load_all=load_all)
|
2012-04-22 20:51:52 -07:00
|
|
|
|
|
|
|
if form.is_valid():
|
|
|
|
query = form.cleaned_data['q']
|
|
|
|
results = form.search()
|
|
|
|
else:
|
|
|
|
form = form_class(searchqueryset=searchqueryset, load_all=load_all)
|
|
|
|
|
|
|
|
paginator = Paginator(results, results_per_page or RESULTS_PER_PAGE)
|
|
|
|
|
|
|
|
try:
|
|
|
|
page = paginator.page(int(request.GET.get('page', 1)))
|
|
|
|
except InvalidPage:
|
|
|
|
raise Http404("No such page of results!")
|
|
|
|
|
|
|
|
context = {
|
|
|
|
'form': form,
|
2012-06-05 20:06:58 -07:00
|
|
|
'has_snipts': True,
|
2012-04-22 20:51:52 -07:00
|
|
|
'page': page,
|
|
|
|
'paginator': paginator,
|
|
|
|
'query': query,
|
|
|
|
'suggestion': None,
|
|
|
|
}
|
|
|
|
|
|
|
|
if results.query.backend.include_spelling:
|
|
|
|
context['suggestion'] = form.get_suggestion()
|
|
|
|
|
|
|
|
if extra_context:
|
|
|
|
context.update(extra_context)
|
|
|
|
|
2016-11-01 09:59:35 -07:00
|
|
|
return render(request, template, context)
|
2012-05-15 17:10:50 -07:00
|
|
|
|
2013-03-26 10:18:40 -07:00
|
|
|
|
|
|
|
def redirect_snipt(request, snipt_key, lexer=None):
|
|
|
|
snipt = get_object_or_404(Snipt, key=snipt_key)
|
|
|
|
return HttpResponseRedirect(snipt.get_absolute_url())
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-03-26 10:18:40 -07:00
|
|
|
def redirect_public_tag_feed(request, tag_slug):
|
|
|
|
return HttpResponseRedirect('/public/tag/{}/?rss'.format(tag_slug))
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-03-26 10:18:40 -07:00
|
|
|
def redirect_user_feed(request, username):
|
|
|
|
user = get_object_or_404(User, username=username)
|
|
|
|
return HttpResponseRedirect(user.get_absolute_url() + '?rss')
|
|
|
|
|
2015-07-24 18:28:31 -07:00
|
|
|
|
2013-03-26 10:18:40 -07:00
|
|
|
def redirect_user_tag_feed(request, username, tag_slug):
|
2013-05-19 08:08:20 -07:00
|
|
|
return HttpResponseRedirect(u'/{}/tag/{}/?rss'.format(username, tag_slug))
|