def get_queryset(self):
self.q = self.request.GET.get('term', None)
template_cats = VideoCat.objects.all()
tags = Tag.objects.all()
if not self.q:
qs = QuerySetSequence().none()
else:
template_cats = template_cats.filter(name__icontains=self.q)
tags = tags.filter(name__icontains=self.q)
#
# Get Haystack search results and convert to pks for local
#
content = SearchQuerySet().filter(content=AutoQuery(self.q))
content_pks = [i.pk for i in content]
content = Vid.objects.filter(pk__in=content_pks)
# Aggregate querysets
qs = QuerySetSequence(content, template_cats, tags)
if self.q:
# This would apply the filter on all the querysets
qs = qs.filter(name__icontains=self.q)
# This will limit each queryset so that they show an equal number
# of results.
qs = self.mixup_querysets(qs)
return qs
def get_context(self, request):
# Обновляем контекст для внесения только опубликованных постов в обратном хронологическом порядке
context = super().get_context(request)
featured_posts = QuerySetSequence(BlogPage.objects.all()[:6],
ReviewPage.objects.all()[:6])
latest_posts = QuerySetSequence(BlogPage.objects.all()[:6],
ReviewPage.objects.all()[:6])
context['featured_posts'] = featured_posts
context['latest_posts'] = latest_posts
return context
def test_slicing(self):
for i in range(10):
Author.objects.create(name="{:02d}".format(2*i))
Publisher.objects.create(name="(:02d)".format(2*i + 1))
unsliced = list(QuerySetSequence(
Author.objects.all(),
Publisher.objects.all()
).order_by("name"))
sliced = list(QuerySetSequence(
Author.objects.all(),
Publisher.objects.all()
).order_by("name")[:5])
assert unsliced[:5] == sliced
def test_slicing_single_queryset_source(self):
for i in range(5):
Author.objects.create(name="{:02d}".format(i))
Publisher.objects.create(name="(:02d)".format(i + 5))
unsliced = list(QuerySetSequence(
Author.objects.all(),
Publisher.objects.all()
).order_by("name"))
sliced = list(QuerySetSequence(
Author.objects.all(),
Publisher.objects.all()
).order_by("name")[:5])
assert unsliced[:5] == sliced
def category(self, request, cat_slug):
context = super(BlogIndexPage, self).get_context(request)
result = None
try:
cat = home_models.Node.objects.get(name__iexact=cat_slug)
blogs = cat.blogpage_set.all()
reviews = cat.reviewpage_set.all()
result = QuerySetSequence(blogs, reviews)
except:
return HttpResponseRedirect('/')
# page = request.GET.get('page')
# paginator = Paginator(blogs, 6)
# try:
# paginated_blogs = paginator.page(page)
# except PageNotAnInteger:
# paginated_blogs = paginator.page(1)
# except EmptyPage:
# paginated_blogs = paginator.page(paginator.num_pages)
context['blogs'] = result
context['filter_term'] = cat_slug.capitalize()
return render(request, 'blog/category_page.html', context)
def get_queryset(self):
articles = Article.objects.all()
custompage = CustomPage.objects.all()
events = Event.objects.all()
persons = Person.objects.all()
medias = Media.objects.all()
if self.q:
articles = articles.filter(title__icontains=self.q)\
.order_by("-publish_date")
custompage = custompage.filter(title__icontains=self.q)\
.order_by("-publish_date")
events = events.filter(title__icontains=self.q).order_by("-start")
persons = persons.filter(title__icontains=self.q)
medias = medias.filter(
title__icontains=self.q).order_by("-publish_date")
qs = autocomplete.QuerySetSequence(articles, custompage, events,
persons, medias)
# Unlimited queryset
# https://django-autocomplete-light.readthedocs.io/en/master/_modules/dal_queryset_sequence/views.html
# qs = self.mixup_querysets(qs)
querysets = list(qs.get_querysets())
qs = QuerySetSequence(*[q for q in querysets])
return qs
def all_categories(self, request):
context = super(BlogIndexPage, self).get_context(request)
context['categories'] = home_models.Node.objects.get(
pk=1).get_children()
search_query = request.GET.get('q', None)
if search_query:
context['blogs'] = BlogPage.objects.search(
search_query, fields=['title', 'body'])
context['search_term'] = search_query
context['search_type'] = 'search'
return render(request, 'blog/category_page.html', context)
allblogs = QuerySetSequence(self.blogs, self.reviews)
page = request.GET.get('page')
paginator = Paginator(allblogs, 6)
try:
blogs = paginator.page(page)
except PageNotAnInteger:
blogs = paginator.page(1)
except EmptyPage:
blogs = paginator.page(paginator.num_pages)
context['blogs'] = blogs
return render(request, 'blog/category_page.html', context)
def mixup_querysets(self, qs):
"""Return a queryset with different model types."""
if len(list(qs.query._querysets)):
limit = int(self.paginate_by / len(qs.query._querysets))
qs.query._querysets[0][:2]
qs = QuerySetSequence(*[q[:limit] for q in qs.query._querysets])
return qs
def test_duplicates(self):
"""Ensure that pagination works over an 'extreme' number of duplicates."""
PAGES = 100 # This must be unique from other fixture data.
# Create a bunch of books that are the same.
for i in range(15):
Book.objects.create(title=str(i),
author=self.author,
publisher=self.publisher,
pages=PAGES,
release=date(2018, 10, 5))
# And use only those duplicate books.
self.queryset = QuerySetSequence(Book.objects.filter(pages=PAGES))
titles = [item.title for item in self.queryset]
# Look at both the pages (which should all be 1) and the IDs.
next_url = '/'
for i in range(3):
request = Request(factory.get(next_url))
queryset = self.pagination.paginate_queryset(self.queryset, request)
titles, pages = zip(*[(item.title, item.pages) for item in queryset])
self.assertEqual(titles, tuple(map(lambda d: str(d + (i * 5)), [0, 1, 2, 3, 4])))
self.assertEqual(pages, (PAGES, ) * 5)
next_url = self.pagination.get_next_link()
self.assertIsNone(next_url)
def __init__(self,
*args,
model_choice=None,
widget=None,
view=None,
field_id=None,
**kwargs):
"""Initialize GenericForeignKeyModelField."""
self.field_id = field_id if field_id else id(self)
if model_choice:
self.model_choice = model_choice
models_queryset = [
model[0].objects.all() for model in model_choice
]
kwargs['queryset'] = QuerySetSequence(*models_queryset)
# check if they are classes
if isinstance(widget, type) and isinstance(view, type):
self.widget_obj = widget
self.view_obj = view
else:
raise AttributeError(
"Class object are required (not instantiated)")
super().__init__(*args, **kwargs)
def dashboard(self, request):
from itertools import chain
from operator import attrgetter
from queryset_sequence import QuerySetSequence
from django.db.models import F, Value
news_query_set = News.objects.filter(
date_published__isnull=False, status='LIVE').annotate(
item_type=Value("NEWS", output_field=CharField()))
event_query_set = Event.objects.filter(
date_published__isnull=False,
status='LIVE').exclude(type__code__in=[
LKUPEventType.EVENT_TYPE_MEETING,
LKUPEventType.EVENT_TYPE_ONE_ON_ONE
]).annotate(image=F('banner')).annotate(
item_type=Value("EVENT", output_field=CharField()))
combine_queryset = QuerySetSequence(news_query_set, event_query_set)
# query_set = sorted(
# chain(news_query_set, event_query_set),
# key=attrgetter('date_published'), reverse=True)
query_set = combine_queryset.order_by('-date_published').filter(
date_published__lte=datetime.datetime.today())
# query_set = sorted(
# combine_queryset,
# key=attrgetter('date_published'), reverse=True)
# for a in query_set:
# print(str(a.date_published) + a.item_type)
page = self.paginate_queryset(query_set)
if page is not None:
data = StorySerializer(page, many=True).data
return self.get_paginated_response(data)
return construct_response(CODE_SUCCESS,
StorySerializer(list, many=True).data)
def get_queryset(self):
articles = Article.objects.all()
custompage = CustomPage.objects.all()
events = Event.objects.all()
briefs = Brief.objects.all()
medias = Media.objects.all()
persons = Person.objects.all()
projects = Project.objects.all()
playlists = Playlist.objects.all()
if self.q:
articles = articles.filter(title__icontains=self.q)\
.order_by("-publish_date")
custompage = custompage.filter(title__icontains=self.q)\
.order_by("-publish_date")
events = events.filter(title__icontains=self.q).order_by("-start")
briefs = briefs.filter(title__icontains=self.q)
medias = medias.filter(title__icontains=self.q)
persons = persons.filter(title__icontains=self.q)
projects = projects.filter(title__icontains=self.q)
playlists = playlists.filter(title__icontains=self.q)
qs = autocomplete.QuerySetSequence(articles, custompage, briefs,
events, medias, persons, projects,
playlists)
querysets = list(qs.get_querysets())
qs = QuerySetSequence(*[q for q in querysets])
return qs
def get_queryset(self):
querysets = [
Resource.objects.all(),
ConceptEntity.objects.all(),
]
qs = QuerySetSequence(*querysets)
if self.q:
qs = qs.filter(name__icontains=self.q)
# In addition to filtering existing Entities, we should also
# consider Concepts provided by registered authority services.
if len(self.q) > 3: # To avoid frivolous authority calls, we only
# consider Concepts once the user has entered
# four characters.
extra_choices = self._suggest_concept(self.q)
if not self.request.user.is_authenticated():
qs = qs.filter(private=False)
field_id = self.request.GET.get('in_range_of', None)
if field_id:
qs = qs.filter(entity_type__in_range_of__in=[field_id])
qs = self.mixup_querysets(qs)
return qs
def message(request):
if "username" not in request.session:
return HttpResponse("<h1>Hey you must login first</h1>")
if request.method == "POST" and "message" in request.POST:
sender = request.session['username']
receiver = request.POST.get('receiver')
message = request.POST.get('message')
new = Message(sender_id=sender, receiver_id=receiver, message=message)
new.save()
if request.method == "GET" and "show_msg" in request.GET:
notify = Logic().Message(request.session['username'],
request.GET.get('show_msg'))
return render(request, 'popup.html', {'Message': notify})
if request.method == "GET" and "receiver" in request.GET:
receiver = request.GET.get('receiver')
message = QuerySetSequence(
Message.objects.filter(sender_id=request.session['username'],
receiver_id=receiver),
Message.objects.filter(
sender_id=receiver,
receiver_id=request.session['username'])).order_by('-uploaded_at')
if message.exists() == False:
message = "Empty"
return render(request, 'messaging.html', {
'Message': message,
'receiver': User.objects.get(user_id=receiver)
})
def test_query_keyword(self):
"""Test constructing a QuerySetSequence with the query keyword."""
clone = self.all._clone()
qss = QuerySetSequence(query=clone.query)
data = [it.title for it in qss]
self.assertEqual(data, self.EXPECTED)
def mixup_querysets(self, qs):
"""Return a queryset with different model types."""
querysets = list(qs.get_querysets())
queryset_count = len(querysets)
if queryset_count:
limit = int(self.paginate_by / queryset_count)
qs = QuerySetSequence(*[q[:limit] for q in querysets])
return qs
def test_same_model(self):
"""
If a QuerySetSequence is made of the same model multiple times, the #
attribute must be different on each.
"""
queryset = QuerySetSequence(Book.objects.all(), Book.objects.all())
data = list(map(attrgetter('#'), queryset))
self.assertEqual([0, 0, 1, 1], data)
def test_open_slice(self):
"""Test slicing without an end."""
articles = Article.objects.all()
qs = articles[1:]
qss = QuerySetSequence(articles)[1:]
self.assertEqual(len(qs), len(qss))
self.assertEqual(list(qs), list(qss))
def test_without_model_keyword_args(self):
"""Test constructing a QuerySetSequence without the model keyword."""
qss = QuerySetSequence(
Book.objects.filter(title="Fiction"),
Book.objects.filter(title="Biography"),
)
data = [it.title for it in qss]
self.assertEqual(data, self.EXPECTED_WITH_BOOK_MODEL)
def test_validate(self):
fixture = self.model.objects.create(name=self.id())
form = self.form(http.QueryDict('name=%s&test=%s' % (
self.id(), self.get_value(fixture))))
form.fields['test'].queryset = QuerySetSequence(
self.model.objects.exclude(pk=fixture.pk))
self.assertFalse(form.is_valid())
def __init__(self, *args, model_choice=None, field_id=None, **kwargs):
self.field_id = field_id if field_id else id(self)
if model_choice:
self.model_choice = model_choice
models_queryset = [
model[0].objects.all() for model in model_choice
]
kwargs['queryset'] = QuerySetSequence(*models_queryset)
super().__init__(*args, **kwargs)
def _get_queryset_for_pks(self, pks):
querysets = []
for content_type_id, object_ids in pks.items():
queryset = self.get_queryset_for_content_type(content_type_id)
if queryset is None:
self.raise_invalid_choice(params=dict(
value='%s-%s' % (content_type_id, object_ids[0])))
querysets.append(queryset.filter(pk__in=object_ids))
return QuerySetSequence(*querysets)
def test_closed_slice_single_qs(self):
"""Test slicing if the start and end are within the same QuerySet."""
Article.objects.create(title='Another Article', author=self.bob,
publisher=self.mad_magazine)
articles = Article.objects.all()
qs = articles[1:3]
qss = QuerySetSequence(articles)[1:3]
# The length should be the same.
self.assertEqual(len(qs), len(qss))
def mixup_querysets(self, qs):
"""Return a queryset with different model types."""
try:
querysets = qs._querysets
except AttributeError:
querysets = qs.query._querysets
if len(list(querysets)):
limit = int(self.paginate_by / len(querysets))
querysets[0][:2]
qs = QuerySetSequence(*[q[:limit] for q in querysets])
return qs
def test_validate(self):
# Create an option to select
fixture = TestModel.objects.create(name=self.id())
# Instanciate the form with the fixture selected
form = TestForm(http.QueryDict('name=%s&test=%s' % (
self.id(), self.get_value(fixture))))
# Remove the option from field queryset choices
form.fields['test'].queryset = QuerySetSequence(
TestModel.objects.exclude(pk=fixture.pk))
# Form should not validate
self.assertFalse(form.is_valid())
def setUp(self):
self.author = Author.objects.create(name="Jane Doe")
self.publisher = Publisher.objects.create(
name="Pablo's Publishing", address="123 Publishing Street")
for d in range(1, 15):
book = Book.objects.create(title='Book %s' % (d % 2),
author=self.author,
publisher=self.publisher,
pages=d)
self.pagination = _TestPagination()
self.queryset = QuerySetSequence(Book.objects.filter(pages__lte=7),
Book.objects.filter(pages__gt=7))
def filtering_ajax(self, request, *args, **kwargs):
if request.is_ajax():
form_data = json.loads(request.GET.get('form_data'))
# print(form_data)
# Deserialization JSON object
form_data = {
key: value
for (key, value) in [o.values() for o in form_data]
}
# print(form_data)
# Categories(All, Fitness....)
if 'categories-input' in form_data and form_data[
'categories-input'] != 'all':
cat = home_models.Node.objects.get(
pk=form_data['categories-input'])
blogs = cat.blogpage_set.all()
reviews = cat.reviewpage_set.all()
else:
blogs = self.blogs
reviews = self.reviews
# Post Type(All, Product, Review)
if 'post-input' in form_data and form_data['post-input'] != 'all':
if form_data['post-input'] == 'product':
result = blogs
elif form_data['post-input'] == 'review':
result = reviews
else:
result = QuerySetSequence(blogs, reviews)
# checking
# if 'license' in parsed_JSON:
# blogs = result_queryset.filter(cls._FILTER_LIST['license'])
# Sorting. Sorting gotta occurs after all filters in the order
# blogs = result_queryset.order_by(cls._FILTER_LIST['sorting'][parsed_JSON['sorting']])
# context = super(BlogIndexPage, self).get_context(request)
data = {}
data['html_from_view'] = render_to_string(
template_name="blog/includes/cards.html",
context={
'blogs': result,
})
return JsonResponse(data=data)
return JsonResponse({'result': None})
def find(ans, likes):
notify = []
like_q = []
ans_q = []
objects = QuerySetSequence(ans, likes).order_by('-uploaded_at')
for obj in objects:
if hasattr(obj, 'type1'): #type1 xa vani tyo like ma parxa
if obj.question_id not in like_q:
like_q.append(obj.question_id)
notify.append(["like", obj])
else:
if obj.question_id not in ans_q:
ans_q.append(obj.question_id)
notify.append(["ans", obj])
return notify
def test_order_by_relation_with_different_ordering(self):
"""
Apply order_by() with a field that returns a model with different
ordering on sub-QuerySets.
"""
# Both of these have publishers with the same fields, but different
# ordering.
all = QuerySetSequence(Article.objects.all(), BlogPost.objects.all())
# Order by publisher and ensure it takes.
with self.assertNumQueries(0):
qss = all.order_by('publisher')
self.assertEqual(qss.query.order_by, ['publisher'])
self.assertRaises(FieldError, list, qss)
def get_queryset(self):
playlists = Playlist.objects.all()
if self.q:
playlists = playlists.filter(title__icontains=self.q)
qs = autocomplete.QuerySetSequence(playlists, )
if self.q:
qs = qs.filter(title__icontains=self.q)
querysets = list(qs.get_querysets())
qs = QuerySetSequence(*[q for q in querysets])
return qs
