def get_queryset(self, **kwargs):
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
if q:
qs = Station.objects.filter(Q(name__istartswith=q)).distinct()
else:
qs = Station.objects.all()
order_by = self.request.GET.get('order_by', None)
direction = self.request.GET.get('direction', None)
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
# apply filters
self.filter = StationFilter(self.request.GET, queryset=qs)
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
tstags.append(int(stag))
# rebuild filter after applying tags
self.filter = StationFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
tagcloud = Tag.objects.usage_for_queryset(qs, counts=True, min_count=0)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
# return render_to_response('my_app/template.html', {'filter': f})
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
if q:
# haystack version
#sqs = SearchQuerySet().models(Profile).filter(SQ(content__contains=q) | SQ(content_auto=q))
sqs = SearchQuerySet().models(Profile).filter(
text_auto=AutoQuery(q))
qs = Profile.objects.filter(
id__in=[result.object.pk for result in sqs]).distinct()
# qs = Profile.objects.filter(Q(user__username__istartswith=q) \
# | Q(user__first_name__istartswith=q) \
# | Q(user__last_name__istartswith=q)) \
# .distinct()
else:
qs = Profile.objects.all()
order_by = self.request.GET.get('order_by', None)
direction = self.request.GET.get('direction', None)
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
else:
qs = qs.order_by('user__first_name', 'user__last_name')
# special relation filters
# TODO: maybe implement for profiles
self.relation_filter = []
# apply filters
self.filter = ProfileFilter(self.request.GET, queryset=qs)
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
tstags.append(int(stag))
if stags:
qs = Profile.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = ProfileFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(qs,
counts=True,
min_count=0)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
if q:
# sqs = SearchQuerySet().models(Release).filter(SQ(content__contains=q) | SQ(content_auto=q))
# sqs = SearchQuerySet().models(Release).filter(content=AutoQuery(q))
sqs = SearchQuerySet().models(Release).filter(
text_auto=AutoQuery(q))
qs = Release.objects.filter(
id__in=[result.object.pk for result in sqs]).distinct()
else:
qs = Release.objects.select_related('license').prefetch_related(
'media_release').all()
order_by = self.request.GET.get('order_by', 'created')
direction = self.request.GET.get('direction', 'descending')
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
# special relation filters
self.relation_filter = []
artist_filter = self.request.GET.get('artist', None)
if artist_filter:
#qs = qs.filter(Q(media_release__artist__slug=artist_filter) | Q(media_release__media_artists__slug=artist_filter) | Q(album_artists__slug=artist_filter)).distinct()
a = get_object_or_404(Artist, slug=artist_filter)
qs = qs.filter(pk__in=(r.id for r in a.get_releases())).distinct()
f = {'item_type': 'artist', 'item': a, 'label': _('Artist')}
self.relation_filter.append(f)
label_filter = self.request.GET.get('label', None)
if label_filter:
l = get_object_or_404(Label, slug=label_filter)
qs = qs.filter(label__pk=l.pk).distinct()
f = {'item_type': 'label', 'item': l, 'label': _('Label')}
self.relation_filter.append(f)
# filter by import session
import_session = self.request.GET.get('import', None)
if import_session:
from importer.models import Import
from django.contrib.contenttypes.models import ContentType
import_session = get_object_or_404(Import, pk=int(import_session))
ctype = ContentType.objects.get(model='release')
ids = import_session.importitem_set.filter(
content_type=ctype.pk).values_list('object_id', )
qs = qs.filter(pk__in=ids).distinct()
# filter by user
creator_filter = self.request.GET.get('creator', None)
if creator_filter:
from django.contrib.auth.models import User
creator = get_object_or_404(User, username='******' % creator_filter)
qs = qs.filter(creator=creator).distinct()
f = {
'item_type': 'release',
'item': creator,
'label': _('Added by')
}
self.relation_filter.append(f)
# filter by user
creator_exclude_filter = self.request.GET.get('creator_exclude', None)
if creator_exclude_filter:
from django.contrib.auth.models import User
creator = get_object_or_404(User,
username='******' % creator_exclude_filter)
qs = qs.exclude(creator__id=creator.id).distinct()
f = {
'item_type': 'release',
'item': creator,
'label': _('Not added by')
}
self.relation_filter.append(f)
# filter by promo flag
# TODO: refactor query, publish_date is depreciated
promo_filter = self.request.GET.get('promo', None)
if promo_filter and promo_filter.isnumeric() and int(
promo_filter) == 1:
#qs = qs.filter(releasedate__gte=F('publish_date')).distinct()
qs = qs.filter(
releasedate__gt=datetime.datetime.now().date()).distinct()
f = {
'item_type': 'release',
'item': _('Promotional Releases'),
'label': 'Filter'
}
self.relation_filter.append(f)
# filter by new flag
# TODO: refactor query, publish_date is depreciated
new_filter = self.request.GET.get('new', None)
if new_filter and new_filter.isnumeric() and int(new_filter) == 1:
#qs = qs.filter(releasedate__gte=F('publish_date')).distinct()
qs = qs.filter(releasedate__range=(
datetime.datetime.now() - timedelta(days=14),
datetime.datetime.now().date())).distinct()
f = {
'item_type': 'release',
'item': _('New Releases'),
'label': 'Filter'
}
self.relation_filter.append(f)
# "extra-filters" (to provide some arbitary searches)
extra_filter = self.request.GET.get('extra_filter', None)
if extra_filter:
if extra_filter == 'no_cover':
qs = qs.filter(main_image='').distinct()
if extra_filter == 'has_cover':
qs = qs.exclude(main_image='').distinct()
if extra_filter == 'possible_duplicates':
from django.db.models import Count
dupes = Release.objects.values('name').annotate(
Count('id')).order_by().filter(id__count__gt=1)
qs = qs.filter(name__in=[item['name'] for item in dupes])
if not order_by:
qs = qs.order_by('name')
# apply filters
self.filter = ReleaseFilter(self.request.GET, queryset=qs)
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
tstags.append(int(stag))
if stags:
qs = Release.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = ReleaseFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(
qs, counts=True, min_count=TAGCLOUD_MIN_COUNT)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
# haystack version
if q:
#sqs = SearchQuerySet().models(Media).filter(SQ(content__contains=q) | SQ(content_auto=q))
#sqs = SearchQuerySet().models(Media).filter(content=AutoQuery(q))
sqs = SearchQuerySet().models(Media).filter(text_auto=AutoQuery(q))
pk_list = [result.object.pk for result in sqs]
preserved = Case(
*[When(pk=pk, then=pos) for pos, pk in enumerate(pk_list)])
qs = Media.objects.filter(
id__in=pk_list).order_by(preserved).distinct()
else:
qs = Media.objects.all()
# if q:
# #qs = Media.objects.filter(Q(name__icontains=q)\
# #| Q(release__name__icontains=q)\
# #| Q(artist__name__icontains=q))\
# #.distinct()
# qs = Media.objects.filter(name__icontains=q).distinct()
# else:
# qs = Media.objects.all()
order_by = self.request.GET.get('order_by', 'created')
direction = self.request.GET.get('direction', 'descending')
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
# special relation filters
self.relation_filter = []
artist_filter = self.request.GET.get('artist', None)
if artist_filter:
a = get_object_or_404(Artist, slug=artist_filter)
qs = qs.filter(pk__in=(r.id for r in a.get_media())).distinct()
f = {'item_type': 'artist', 'item': a, 'label': _('Artist')}
self.relation_filter.append(f)
release_filter = self.request.GET.get('release', None)
if release_filter:
r = get_object_or_404(Release, slug=release_filter)
qs = qs.filter(release__pk=r.pk).distinct()
f = {'item_type': 'release', 'item': r, 'label': _('Release')}
self.relation_filter.append(f)
# filter by import session
import_session = self.request.GET.get('import', None)
if import_session:
from importer.models import Import
from django.contrib.contenttypes.models import ContentType
import_session = get_object_or_404(Import, pk=int(import_session))
ctype = ContentType.objects.get(model='media')
ids = import_session.importitem_set.filter(
content_type=ctype.pk).values_list('object_id', )
qs = qs.filter(pk__in=ids).distinct()
# filter by user
creator_filter = self.request.GET.get('creator', None)
if creator_filter:
from django.contrib.auth.models import User
creator = get_object_or_404(User, username='******' % creator_filter)
qs = qs.filter(creator=creator).distinct()
f = {
'item_type': 'release',
'item': creator,
'label': _('Added by')
}
self.relation_filter.append(f)
# "extra-filters" (to provide some arbitary searches)
extra_filter = self.request.GET.get('extra_filter', None)
if extra_filter:
if extra_filter == 'unassigned':
qs = qs.filter(release=None).distinct()
if extra_filter == 'possible_duplicates':
from django.db.models import Count
dupes = Media.objects.values('name').annotate(
Count('id')).filter(id__count__gt=1)
qs = qs.filter(name__in=[item['name'] for item in dupes])
if not order_by:
qs = qs.order_by('name')
if extra_filter == 'possible_duplicates_incl_artists':
from django.db.models import Count
dupes = Media.objects.values('name').annotate(
Count('id')).filter(id__count__gt=1)
qs = qs.filter(name__in=[item['name'] for item in dupes])
if not order_by:
qs = qs.order_by('name')
# apply filters
self.filter = MediaFilter(self.request.GET, queryset=qs)
# self.filter = ReleaseFilter(self.request.GET, queryset=Release.objects.active().filter(**kwargs))
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
#print int(stag)
tstags.append(int(stag))
if stags:
qs = Media.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = MediaFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(qs,
counts=True,
min_count=0)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
# haystack version
if q:
#sqs = SearchQuerySet().models(Artist).filter(SQ(content__contains=q) | SQ(content_auto=q))
#sqs = SearchQuerySet().models(Artist).filter(content=AutoQuery(q))
sqs = SearchQuerySet().models(Artist).filter(
text_auto=AutoQuery(q))
qs = Artist.objects.filter(
id__in=[result.object.pk for result in sqs]).distinct()
else:
qs = Artist.objects.all().prefetch_related('media_artist')
# if q:
# # qs = Artist.objects.filter(Q(name__istartswith=q) | Q(namevariations__name__istartswith=q)).distinct()
# # https://lab.hazelfire.com/issues/1477
# qs = Artist.objects.filter(Q(name__icontains=q) | Q(namevariations__name__icontains=q)).distinct()
# qs = qs.prefetch_related('media_artist')
# else:
# # only display artists with tracks a.t.m.
# qs = Artist.objects.all().prefetch_related('media_artist')
order_by = self.request.GET.get('order_by', 'created')
direction = self.request.GET.get('direction', 'descending')
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
# special relation filters
self.relation_filter = []
artist_filter = self.request.GET.get('artist', None)
if artist_filter:
qs = qs.filter(
media_release__artist__slug=artist_filter).distinct()
fa = Artist.objects.filter(slug=artist_filter)[0]
f = {'item_type': 'artist', 'item': fa, 'label': _('Artist')}
self.relation_filter.append(f)
label_filter = self.request.GET.get('label', None)
if label_filter:
qs = qs.filter(label__slug=label_filter).distinct()
fa = Label.objects.filter(slug=label_filter)[0]
f = {'item_type': 'label', 'item': fa, 'label': _('Label')}
self.relation_filter.append(f)
date_start_filter = self.request.GET.get('date_start', None)
if date_start_filter:
qs = qs.filter(date_start__lte='%s-12-31' % date_start_filter,
date_start__gte='%s-00-00' %
date_start_filter).distinct()
f = {
'item_type': 'label',
'item': '%s-12-31' % date_start_filter,
'label': _('Date start')
}
self.relation_filter.append(f)
# "extra-filters" (to provide some arbitary searches)
extra_filter = self.request.GET.get('extra_filter', None)
if extra_filter:
if extra_filter == 'possible_duplicates':
from django.db.models import Count
dupes = Artist.objects.values('name').annotate(
Count('id')).order_by().filter(id__count__gt=1)
qs = qs.filter(name__in=[item['name'] for item in dupes])
if not order_by:
qs = qs.order_by('name')
# filter by import session
import_session = self.request.GET.get('import', None)
if import_session:
from importer.models import Import
from django.contrib.contenttypes.models import ContentType
import_session = get_object_or_404(Import, pk=int(import_session))
ctype = ContentType.objects.get(model='artist')
ids = import_session.importitem_set.filter(
content_type=ctype.pk).values_list('object_id', )
qs = qs.filter(pk__in=ids).distinct()
# apply filters
self.filter = ArtistFilter(self.request.GET, queryset=qs)
# self.filter = ReleaseFilter(self.request.GET, queryset=Release.objects.active().filter(**kwargs))
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
#print int(stag)
tstags.append(int(stag))
if stags:
qs = Release.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = ArtistFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(qs,
counts=True,
min_count=10)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
# return render_to_response('my_app/template.html', {'filter': f})
kwargs = {}
self.tagcloud = None
q = self.request.GET.get('q', None)
if q:
# haystack version
#sqs = SearchQuerySet().models(Label).filter(SQ(content__contains=q) | SQ(content_auto=q))
#sqs = SearchQuerySet().models(Label).filter(content=AutoQuery(q))
sqs = SearchQuerySet().models(Label).filter(text_auto=AutoQuery(q))
qs = Label.objects.filter(
id__in=[result.object.pk for result in sqs]).distinct()
# ORM
# qs = qs.filter(name__icontains=q).distinct()
else:
qs = Label.objects.all()
order_by = self.request.GET.get('order_by', 'created')
direction = self.request.GET.get('direction', 'descending')
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
# special relation filters
self.relation_filter = []
label_filter = self.request.GET.get('label', None)
if label_filter:
qs = qs.filter(media_release__label__slug=label_filter).distinct()
# add relation filter
fa = Label.objects.filter(slug=label_filter)[0]
f = {'item_type': 'label', 'item': fa, 'label': _('Label')}
self.relation_filter.append(f)
label_filter = self.request.GET.get('label', None)
if label_filter:
qs = qs.filter(label__slug=label_filter).distinct()
# add relation filter
fa = Label.objects.filter(slug=label_filter)[0]
f = {'item_type': 'label', 'item': fa, 'label': _('Label')}
self.relation_filter.append(f)
# filter by import session
import_session = self.request.GET.get('import', None)
if import_session:
from importer.models import Import
from django.contrib.contenttypes.models import ContentType
import_session = get_object_or_404(Import, pk=int(import_session))
ctype = ContentType.objects.get(model='label')
ids = import_session.importitem_set.filter(
content_type=ctype.pk).values_list('object_id', )
qs = qs.filter(pk__in=ids).distinct()
# "extra-filters" (to provide some arbitary searches)
extra_filter = self.request.GET.get('extra_filter', None)
if extra_filter:
if extra_filter == 'possible_duplicates':
from django.db.models import Count
dupes = Label.objects.values('name').annotate(
Count('id')).order_by().filter(id__count__gt=1)
qs = qs.filter(name__in=[item['name'] for item in dupes])
if not order_by:
qs = qs.order_by('name')
# apply filters
self.filter = LabelFilter(self.request.GET, queryset=qs)
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
#print "** STAGS:"
#print stags
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
#print int(stag)
tstags.append(int(stag))
#print "** TSTAGS:"
#print tstags
#stags = ('Techno', 'Electronic')
#stags = (4,)
if stags:
qs = Label.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = LabelFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(qs,
counts=True,
min_count=2)
self.tagcloud = calculate_cloud(tagcloud)
return qs
def get_queryset(self, **kwargs):
self.tagcloud = None
q = self.request.GET.get('q', None)
#qs = Playlist.objects.all()
if self.request.user.is_authenticated():
qs = Playlist.objects.filter(~Q(type='basket')
| Q(user__pk=self.request.user.pk))
else:
qs = Playlist.objects.exclude(type='basket')
if q:
# haystack version
#sqs = SearchQuerySet().models(Playlist).filter(SQ(content__contains=q) | SQ(content_auto=q))
#sqs = SearchQuerySet().models(Playlist).filter(content=AutoQuery(q))
sqs = SearchQuerySet().models(Playlist).filter(
text_auto=AutoQuery(q))
qs = qs.filter(id__in=[result.object.pk
for result in sqs]).distinct()
# ORM version
# qs = qs.filter(Q(name__icontains=q)\
# | Q(series__name__icontains=q)\
# | Q(user__username__istartswith=q))\
# .distinct()
order_by = self.request.GET.get('order_by', None)
direction = self.request.GET.get('direction', None)
if order_by and direction:
if direction == 'descending':
qs = qs.order_by('-%s' % order_by)
else:
qs = qs.order_by('%s' % order_by)
if 'type' in self.kwargs:
qs = qs.filter(type=self.kwargs['type'])
if 'user' in self.kwargs:
user = get_object_or_404(User, username=self.kwargs['user'])
if 'type' in self.kwargs:
qs = qs.filter(type=self.kwargs['type'], user=user)
else:
qs = qs.filter(type__in=['playlist', 'broadcast', 'basket'],
user=user)
# special relation filters
self.relation_filter = []
user_filter = self.request.GET.get('user', None)
if user_filter:
user = get_object_or_404(User, username=user_filter)
#qs = qs.filter(media_release__artist__slug=artist_filter).distinct()
# incl album_artists
qs = qs.filter(user=user).distinct()
# add relation filter
fa = user # for consistency
f = {'item_type': 'user', 'item': fa, 'label': _('User')}
self.relation_filter.append(f)
# apply filters
self.filter = PlaylistFilter(self.request.GET, queryset=qs)
qs = self.filter.qs
stags = self.request.GET.get('tags', None)
tstags = []
if stags:
stags = stags.split(',')
for stag in stags:
tstags.append(int(stag))
if stags:
qs = Release.tagged.with_all(tstags, qs)
# rebuild filter after applying tags
self.filter = PlaylistFilter(self.request.GET, queryset=qs)
# tagging / cloud generation
if qs.exists():
tagcloud = Tag.objects.usage_for_queryset(qs,
counts=True,
min_count=0)
self.tagcloud = calculate_cloud(tagcloud)
return qs