def search(request):
if request.is_ajax():
term = request.GET.get('term', '')
results = []
if str(term[0]) == '@':
queries = User.objects.filter(username__icontains=term[1:])[:NUM]
for query in queries:
results.append("@" + query.username)
else:
queries = Thread.objects.filter(title__icontains=term,
lang=lang())[:NUM]
for query in queries:
results.append(query.title)
res = json.dumps(results)
mimetype = 'application/json'
return HttpResponse(res, mimetype)
else:
get = request.GET.get('q')
data = get.strip()
if data[0] == '@':
user = User.objects.get(username=data[1:])
return redirect(reverse("user:profile", args=[user.username]))
elif data[0] == '#' and data[1:].isnumeric():
return redirect("entry:read", pk=data[1:])
else:
title = re.sub(' +', ' ', data)
try:
thread = Thread.objects.get(title=title, lang=lang())
return redirect(thread)
except ObjectDoesNotExist:
eform = EntryForm()
tform = ThreadForm({'title': title})
eform.fields['body'].widget.attrs['placeholder'] = \
"write something to create this thread"
if tform.is_valid():
return render(request, 'threads/store.html', {
'title': title,
'eform': eform,
'tform': tform
})
return render(request, 'threads/store.html', {
'title': title,
'error': True
})
def get(self, request, *args, **kwargs):
self.last_request = request
self.object_list = self.get_queryset()
allow_empty = self.get_allow_empty()
if not allow_empty:
# When pagination is enabled and object_list is a queryset,
# it's better to do a cheap query than to load the unpaginated
# queryset in memory.
if self.get_paginate_by(self.object_list) is not None and hasattr(self.object_list, 'exists'):
is_empty = not self.object_list.exists()
else:
is_empty = not self.object_list
if is_empty:
raise Http404(lang('Empty list and “%(class_name)s.allow_empty” is False.') % {
'class_name': self.__class__.__name__,
})
serializer = my_serializer
if self.standard_serializer:
serializer = self.standard_serializer
elif hasattr(self.model, 'serializer'):
serializer = self.model.serializer
context = serialize_queryset(self.object_list, self.last_page_info, custom_serializer=serializer,
serialize_config=self.serialized_fields, form_complex_response=True)
add_context = self.get_additional_context_attribute()
if add_context:
context.update(**add_context)
if self.additional_static_attribute:
context.update(**self.additional_static_attribute)
return JsonResponse(context)
def formfield_for_manytomany(self, db_field, request, **kwargs):
item = request.path.split("/")[-3]
thread = self.get_object(request, item)
if thread:
kwargs["queryset"] = Tag.objects.filter(lang=thread.lang)
else:
kwargs["queryset"] = Tag.objects.filter(lang=lang())
return super().formfield_for_manytomany(db_field, request, **kwargs)
def get_queryset(self, **kwargs):
queryset = super().get_queryset().with_favs(self.request.user)\
.filter(user=self.user).filter(lang=lang())\
.annotate(title=F('thread__title'),
slug=F('thread__slug'),
username=F('user__username')).order_by("-created_at")
return queryset
def api_thread(request, *args, **kwargs):
if request.GET.get("week", None):
cnt = Count("entries",
filter=Q(entries__created_at__gt=timezone.now() -
timezone.timedelta(days=30))
& Q(entries__deleted_at=None),
distinct=True)
queries = Thread.objects.filter(lang=lang()) \
.annotate(cnt=cnt).filter(cnt__gt=0) \
.order_by("-last_entry").only('title', 'slug')[:20]
else:
cnt = Count("entries",
filter=Q(entries__deleted_at=None),
distinct=True)
queries = Thread.objects.filter(lang=lang()) \
.annotate(cnt=cnt).filter(cnt__gt=0) \
.order_by("-cnt").only('title', 'slug')[:20]
return api(queries)
def get_queryset(self, **kwargs):
if self.request.GET.get("week", None):
cnt = Count("entries",
filter=Q(entries__created_at__gt=dt.date.today() -
dt.timedelta(days=7))
& Q(entries__deleted_at=None),
distinct=True)
queries = Thread.objects.filter(lang=lang()) \
.annotate(cnt=cnt).filter(cnt__gt=0) \
.order_by("-last_entry").only('title', 'slug')
else:
cnt = Count("entries",
filter=Q(entries__deleted_at=None),
distinct=True)
queries = Thread.objects.filter(lang=lang()) \
.annotate(cnt=cnt) \
.order_by("-cnt").only('title', 'slug')
return queries
def newt(request):
if request.method == "GET":
return render(request, "threads/new.html") # TODO :düzelt
elif request.method == "POST":
thread_form = ThreadForm(request.POST)
entry_form = BodyForm(request.POST)
title = thread_form.clean_title()
try:
thread = Thread.objects.get(title=title, lang=lang())
return add_entry(request, thread.slug)
except ObjectDoesNotExist:
if thread_form.is_valid() and entry_form.is_valid():
thread = Thread(title=title, user=request.user, lang=lang())
# thread = thread_form.save(commit=False)
# thread.user = request.user
# thread.lang = lang()
thread.save()
add_entry(request, thread.slug)
messages.success(request, _('and the thread was created'))
return redirect(thread)
def language_change(request):
languages = {}
current_lang = lang()
if request.is_secure():
scheme = 'https'
else:
scheme = 'http'
base_url = ''.join([scheme, '://', request.META['HTTP_HOST'], '/'])
path = str(request.path).replace('/' + str(current_lang) + '/', '')
for language in Languages.objects.all():
languages[language.code] = {
'path': base_url + '/'.join([language.code, path]),
'active': True if language.code == current_lang else False
}
return {'languages': languages, 'current_lang': current_lang}
def contact(request):
if request.method == 'GET':
sub = request.GET.get("subject", "")
# print(type)
message = request.GET.get("message", None)
# print(message)
form = ContactMessageForm(initial={"subject": str(sub),
"message": message})
else:
form = ContactMessageForm(request.POST)
if form.is_valid():
contact_message = form.save(commit=False)
if request.user.is_authenticated:
contact_message.user = request.user
contact_message.lang = lang()
contact_message.save()
messages.success(request, _('your message sent successfully'))
return redirect("/")
return render(request, "app/contact.html", {'form': form})
def get_queryset(self, **kwargs):
queryset = super(LangMixin, self).get_queryset(**kwargs)
queryset = queryset.filter(lang=lang())
return queryset
def random_thread(request):
thread = Thread.objects.all().filter(lang=lang()).order_by("?")[:1]
return redirect(thread.get())
def trans(self):
try:
return self.translation.get(language__code=lang())
except:
return self
def get_queryset(self):
return Tag.objects.filter(lang=lang())\
.annotate(tcnt=Count("threads")).all()
def get_queryset(self):
queryset = super().get_queryset().filter(lang=lang())
return queryset
def index(request):
entries = Entry.objects.all().with_favs(request.user).filter(lang=lang()).\
annotate(title=F('thread__title'), slug=F('thread__slug'),
username=F('user__username')).order_by("?")[:5]
return render(request, 'threads/idx.html', context={'entries': entries})
