def login(request): form = request.POST ## If not using SSL, try redirecting. #if not request.is_secure(): #url = 'https' + request.build_absolute_uri()[4:] #return HttpResponseRedirect(url) # First try SSL Authentication user = auth.authenticate(request=request) # Otherwise, treat this like a text login and show the login page if # necessary. if user is None: # If the user isn't trying to log in, then just display the login page. if not form.get('login', False): goto = request.GET.get('goto', None) if not goto: # The Django login_required decorator passes 'next' as the # redirect, so we look for that if 'goto' is missing. goto = request.GET.get('next', None) context = RequestContext(request) return render_html_template('login.html', request, {'redirect_to': goto}, context_instance=context) # Check if the username and password are correct. user = auth.authenticate(username=form.get('username', ''), password=form.get('password', '')) # If the username/password are invalid or SSL authentication failed tell # the user to try again. error_message = '' if user is None: error_message = 'Invalid username/password.' # If the user account is disabled, then no dice. elif not user.is_active: error_message = ('The user account for <tt>%s</tt> has been disabled.' % user.username) if error_message: return render_html_template('login.html', request, {'error_message': error_message, 'redirect_to': form.get('goto', None)}, context_instance=RequestContext(request)) # Otherwise, we're good to go, so log the user in. auth.login(request, user) # hack to try to pass them back to http land default_route = get_default_route() goto = request.REQUEST.get('goto', default_route) # hack to prevent infinite loop. if goto == '': goto = default_route if goto.startswith('https'): goto = goto.replace('^https', 'http') return HttpResponseRedirect(goto)
def submit_delete_requests(request): form = request.POST # Add the songs and redirect to the detail page for this playlist. message = 'The following delete request(s) were filed' if request.user.is_authenticated(): subject = 'Delete Request from ' + request.user.username message += ' by ' + request.user.username + ':\n' else: subject = 'Delete Request from Anonymous' message += ' by an unregistered user:\n' song_list = [] songs = get_song_list(form) for song in songs: song_string = (' * %(id)s - %(artist)s - %(album)s - %(title)s\n' % { 'id': str(song.id), 'artist': song.artist, 'album': song.album, 'title': song.title }) message += song_string song_list.append(song) uri = "%s?ids=%s" % (request.build_absolute_uri( reverse("aenclave-list")), '+'.join([str(song.id) for song in songs])) message += '\nView these songs here: %s\n' % uri mail_admins(subject, message, False) return render_html_template('aenclave/delete_requested.html', request, {'song_list': song_list}, context_instance=RequestContext(request))
def roulette(request): # Choose six songs randomly. queryset = Song.visibles.order_by('?')[:6] queryset = Song.annotate_favorited(queryset, request.user) return render_html_template('aenclave/roulette.html', request, {'song_list': queryset}, context_instance=RequestContext(request))
def home(request): channel = Channel.objects.get(pk=1) # 1 is the default channel. playlist_info = json_response.json_channel_info(request, channel) return render_html_template('aenclave/index.html', request, {'total_song_count': Song.visibles.count(), 'playlist_info': playlist_info}, context_instance=RequestContext(request))
def upload_http_fancy_receiver(request): logging.info("Got fancy receiver request.") audio = None # The key is generally 'Filedata' but this is just easier. for k,f in request.FILES.items(): audio = f # SWFUpload does not properly fill out the song's mimetype, so # just use the extension. if audio is None: logging.error("Did not find any file uploaded.") return html_error(request, 'No file was uploaded.', 'HTTP Upload') logging.info("Received upload of %s" % audio.name) if not processing.valid_song(audio.name): logging.error("Rejecting upload due to unsupported filetype") return html_error(request, 'This filetype is unsupported.', 'HTTP Upload') # Save the song into the database -- we'll fix the tags in a moment. song, audio = processing.process_song(audio.name, audio) return render_html_template('aenclave/songlist_song_row.html', request, {'song': song}, context_instance=RequestContext(request))
def upload_youtube_receiver(request): url = request.POST.get('youtube-url', '') if not url: return html_error(request, "URL required.") #try: #audio_pp = youtuberip.rip_video(url, path="/tmp/") #except Exception, e: #return html_error(request, e.message) audio_pp = youtuberip.rip_video(url, path="/tmp/") audio_file = audio_pp.audio_file song, audio = processing.process_song(audio_file, File(open(audio_file))) try: sketchy = audio.info.sketchy except AttributeError: sketchy = True # Fill in these defaults on the tags. It would be better to tag the file # as we rip it, but then we'd have to deal with teaching gstreamer to tag # MP3 and M4As. song.title = audio_pp.title song.artist = audio_pp.uploader song.album = 'YouTube' song.save() return render_html_template('aenclave/upload_http.html', request, {'song_list': [song], 'sketchy_upload': sketchy}, context_instance=RequestContext(request))
def upload_http_fancy_receiver(request): logging.info("Got fancy receiver request.") audio = None # The key is generally 'Filedata' but this is just easier. for k, f in request.FILES.items(): audio = f # SWFUpload does not properly fill out the song's mimetype, so # just use the extension. if audio is None: logging.error("Did not find any file uploaded.") return html_error(request, 'No file was uploaded.', 'HTTP Upload') logging.info("Received upload of %s" % audio.name) if not processing.valid_song(audio.name): logging.error("Rejecting upload due to unsupported filetype") return html_error(request, 'This filetype is unsupported.', 'HTTP Upload') # Save the song into the database -- we'll fix the tags in a moment. song, audio = processing.process_song(audio.name, audio) return render_html_template('aenclave/songlist_song_row.html', request, {'song': song}, context_instance=RequestContext(request))
def normal_search(request): # Get the query. query_string = request.GET.get('q', '') select_from = request.GET.get('from', 'all_songs') # Get the result set. queryset = get_search_results(query_string, request.user, select_from) # If we're feeling lucky, queue a random result. if request.GET.get('lucky', False): if queryset is (): queryset = Song.visibles song_id = queryset.order_by('?').values('id')[0]['id'] song = Song.objects.get(pk=song_id) channel = Channel.default() ctrl = channel.controller() ctrl.add_song(song) # Redirect to the channels page. return HttpResponseRedirect(reverse('aenclave-default-channel')) # Otherwise, display the search results. Limit to 500, and add favorite # hearts. queryset = Song.annotate_favorited(queryset[:500], request.user) return render_html_template('aenclave/search_results.html', request, { 'song_list': queryset, 'search_query': query_string, 'select_from': select_from }, context_instance=RequestContext(request))
def upload_sftp(request): song_list = [] sketchy = False sftp_upload_dir = settings.AENCLAVE_SFTP_UPLOAD_DIR # Figure out available MP3's in SFTP upload DIR for root, dirs, files in os.walk(sftp_upload_dir): for filename in files: if processing.valid_song(filename): full_path = root + '/' + filename content = File(open(full_path, 'r')) song, audio = processing.process_song(full_path, content) song_list.append(song) if audio.info.sketchy: sketchy = True #remove the file from the sftp-upload directory os.unlink(full_path) return render_html_template('aenclave/upload_sftp.html', request, { 'song_list': song_list, 'sketchy_upload': sketchy }, context_instance=RequestContext(request))
def upload_youtube_receiver(request): url = request.POST.get('youtube-url', '') if not url: return html_error(request, "URL required.") #try: #audio_pp = youtuberip.rip_video(url, path="/tmp/") #except Exception, e: #return html_error(request, e.message) audio_pp = youtuberip.rip_video(url, path="/tmp/") audio_file = audio_pp.audio_file song, audio = processing.process_song(audio_file, File(open(audio_file))) try: sketchy = audio.info.sketchy except AttributeError: sketchy = True # Fill in these defaults on the tags. It would be better to tag the file # as we rip it, but then we'd have to deal with teaching gstreamer to tag # MP3 and M4As. song.title = audio_pp.title song.artist = audio_pp.uploader song.album = 'YouTube' song.save() return render_html_template('aenclave/upload_http.html', request, { 'song_list': [song], 'sketchy_upload': sketchy }, context_instance=RequestContext(request))
def normal_search(request): # Get the query. query_string = request.GET.get('q','') select_from = request.GET.get('from', 'all_songs') # Get the result set. queryset = get_search_results(query_string, request.user, select_from) # If we're feeling lucky, queue a random result. if request.GET.get('lucky', False): if queryset is (): queryset = Song.visibles song_id = queryset.order_by('?').values('id')[0]['id'] song = Song.objects.get(pk=song_id) channel = Channel.default() ctrl = channel.controller() ctrl.add_song(song) # Redirect to the channels page. return HttpResponseRedirect(reverse('aenclave-default-channel')) # Otherwise, display the search results. Limit to 500, and add favorite # hearts. queryset = Song.annotate_favorited(queryset[:500], request.user) return render_html_template('aenclave/search_results.html', request, {'song_list': queryset, 'search_query': query_string, 'select_from': select_from}, context_instance=RequestContext(request))
def submit_delete_requests(request): form = request.POST # Add the songs and redirect to the detail page for this playlist. message = 'The following delete request(s) were filed' if request.user.is_authenticated(): subject = 'Delete Request from ' + request.user.username message += ' by ' + request.user.username + ':\n' else: subject = 'Delete Request from Anonymous' message += ' by an unregistered user:\n' song_list = [] songs = get_song_list(form) for song in songs: song_string = (' * %(id)s - %(artist)s - %(album)s - %(title)s\n' % {'id': str(song.id), 'artist': song.artist, 'album': song.album, 'title': song.title}) message += song_string song_list.append(song) uri = "%s?ids=%s" % (request.build_absolute_uri(reverse("aenclave-list")), '+'.join([str(song.id) for song in songs])) message += '\nView these songs here: %s\n' % uri mail_admins(subject,message,False) return render_html_template('aenclave/delete_requested.html', request, {'song_list': song_list}, context_instance=RequestContext(request))
def browse_index(request): total_albums = Song.visibles.values('album').distinct().count() total_artists = Song.visibles.values('artist').distinct().count() return render_html_template('aenclave/browse_index.html', request, {'total_albums': total_albums, 'total_artists': total_artists}, context_instance=RequestContext(request))
def roulette(request): # Choose six songs randomly. queryset = Song.visibles.order_by("?")[:6] queryset = Song.annotate_favorited(queryset, request.user) return render_html_template( "aenclave/roulette.html", request, {"song_list": queryset}, context_instance=RequestContext(request) )
def view_artist(request, artist_name): songs = Song.visibles.filter(artist__iexact=artist_name) songs = Song.annotate_favorited(songs, request.user) return render_html_template('aenclave/artist_detail.html', request, {'artist_name': artist_name, 'song_list': songs}, context_instance=RequestContext(request))
def upload_sftp(request): song_list = [] sketchy = False sftp_upload_dir = settings.AENCLAVE_SFTP_UPLOAD_DIR # Figure out available MP3's in SFTP upload DIR for root, dirs, files in os.walk(sftp_upload_dir): for filename in files: if processing.valid_song(filename): full_path = root + '/' + filename content = File(open(full_path, 'r')) song, audio = processing.process_song(full_path, content) song_list.append(song) if audio.info.sketchy: sketchy = True #remove the file from the sftp-upload directory os.unlink(full_path) return render_html_template('aenclave/upload_sftp.html', request, {'song_list': song_list, 'sketchy_upload': sketchy}, context_instance=RequestContext(request))
def speech_page(request): grammar = wami_grammar.generate() return render_html_template( "aenclave/speech_page.html", request, {"WAMI_KEY": settings.WAMI_API_KEY[request.META["HTTP_HOST"]], "grammar": grammar}, context_instance=RequestContext(request), )
def browse_index(request): total_albums = Song.visibles.values('album').distinct().count() total_artists = Song.visibles.values('artist').distinct().count() return render_html_template('aenclave/browse_index.html', request, { 'total_albums': total_albums, 'total_artists': total_artists }, context_instance=RequestContext(request))
def view_artist(request, artist_name): songs = Song.visibles.filter(artist__iexact=artist_name) songs = Song.annotate_favorited(songs, request.user) return render_html_template('aenclave/artist_detail.html', request, { 'artist_name': artist_name, 'song_list': songs }, context_instance=RequestContext(request))
def speech_page(request): grammar = wami_grammar.generate() return render_html_template( 'aenclave/speech_page.html', request, { 'WAMI_KEY' : settings.WAMI_API_KEY[request.META['HTTP_HOST']], 'grammar' : grammar }, context_instance=RequestContext(request))
def home(request): channel = Channel.objects.get(pk=1) # 1 is the default channel. playlist_info = json_response.json_channel_info(request, channel) return render_html_template( "aenclave/index.html", request, {"total_song_count": Song.visibles.count(), "playlist_info": playlist_info}, context_instance=RequestContext(request), )
def browse_artists(request, letter): if not letter.isalpha(): letter = '#' matches = Song.visibles.filter(artist__regex=r'^[^a-zA-Z]').order_by() else: letter = letter.upper() matches = Song.visibles.filter(artist__istartswith=letter).order_by() artists = [item['artist'] for item in matches.values('artist').distinct()] return render_html_template('aenclave/browse_artists.html', request, {'letter': letter, 'artists': artists}, context_instance=RequestContext(request))
def view_recommendations(request): form = request.REQUEST # Get the selected songs. #queued_songs = utils.get_song_list(form) # maybe better queued_songs = get_latest_cluster(10) # than this bc. they're queued. original_songs = ' '.join(str(song.id) for song in queued_songs) recommended_songs = recommend(queued_songs, 10) return render_html_template('aenclave/recommendations.html', request, {'song_list': recommended_songs, 'original_songs': original_songs}, context_instance=RequestContext(request))
def all_playlists(request): pls = Playlist.objects.all().annotate(Count('songs')) # Perform this hairy join so we can get the username without hitting the db # for every entry. pls = pls.extra(select={'owner_name': 'auth_user.username', 'lower_name': 'lower(aenclave_playlist.name)'}, tables=('auth_user',), where=('auth_user.id = aenclave_playlist.owner_id',)) pls = pls.order_by('lower_name') return render_html_template('aenclave/playlist_list.html', request, {'playlist_list': pls}, context_instance=RequestContext(request))
def view_recommendations(request): form = request.REQUEST # Get the selected songs. #queued_songs = utils.get_song_list(form) # maybe better queued_songs = get_latest_cluster(10) # than this bc. they're queued. original_songs = ' '.join(str(song.id) for song in queued_songs) recommended_songs = recommend(queued_songs, 10) return render_html_template('aenclave/recommendations.html', request, { 'song_list': recommended_songs, 'original_songs': original_songs }, context_instance=RequestContext(request))
def upload_http_fancy(request): # HTTPS is way slowed down.. if request.is_secure(): return HttpResponseRedirect("http://" + request.get_host() + reverse("aenclave-http-upload-fancy")) file_types = map(lambda s: "*.%s" % s, settings.SUPPORTED_AUDIO) return render_html_template('aenclave/upload_http_fancy.html', request, {'song_list': [], 'show_songlist': True, 'file_types': file_types, 'force_actions_bar':True}, context_instance=RequestContext(request))
def browse_artists(request, letter): if not letter.isalpha(): letter = '#' matches = Song.visibles.filter(artist__regex=r'^[^a-zA-Z]').order_by() else: letter = letter.upper() matches = Song.visibles.filter(artist__istartswith=letter).order_by() artists = [item['artist'] for item in matches.values('artist').distinct()] return render_html_template('aenclave/browse_artists.html', request, { 'letter': letter, 'artists': artists }, context_instance=RequestContext(request))
def all_playlists(request): pls = Playlist.objects.all().annotate(Count('songs')) # Perform this hairy join so we can get the username without hitting the db # for every entry. pls = pls.extra(select={ 'owner_name': 'auth_user.username', 'lower_name': 'lower(aenclave_playlist.name)' }, tables=('auth_user', ), where=('auth_user.id = aenclave_playlist.owner_id', )) pls = pls.order_by('lower_name') return render_html_template('aenclave/playlist_list.html', request, {'playlist_list': pls}, context_instance=RequestContext(request))
def upload_http_fancy(request): # HTTPS is way slowed down.. if request.is_secure(): return HttpResponseRedirect("http://" + request.get_host() + reverse("aenclave-http-upload-fancy")) file_types = map(lambda s: "*.%s" % s, settings.SUPPORTED_AUDIO) return render_html_template('aenclave/upload_http_fancy.html', request, { 'song_list': [], 'show_songlist': True, 'file_types': file_types, 'force_actions_bar': True }, context_instance=RequestContext(request))
def upload_http(request): # Nab the file and make sure it's legit. audio = request.FILES.get('audio', None) if audio is None: return html_error(request, 'No file was uploaded.', 'HTTP Upload') try: song, audio = processing.process_song(audio.name, audio) except processing.BadContent: return html_error(request, "You may only upload audio files.", "HTTP Upload") return render_html_template('aenclave/upload_http.html', request, {'song_list': [song], 'sketchy_upload': audio.info.sketchy}, context_instance=RequestContext(request))
def upload_http(request): # Nab the file and make sure it's legit. audio = request.FILES.get('audio', None) if audio is None: return html_error(request, 'No file was uploaded.', 'HTTP Upload') try: song, audio = processing.process_song(audio.name, audio) except processing.BadContent: return html_error(request, "You may only upload audio files.", "HTTP Upload") return render_html_template('aenclave/upload_http.html', request, { 'song_list': [song], 'sketchy_upload': audio.info.sketchy }, context_instance=RequestContext(request))
def playlist_detail(request, playlist_id): try: playlist = Playlist.objects.get(pk=playlist_id) except Playlist.DoesNotExist: raise Http404 can_cede = playlist.can_cede(request.user) can_edit = playlist.can_edit(request.user) # Using the PlaylistEntry default order_by makes a godawful query. songs = playlist.songs.order_by('playlistentry__position') songs = Song.annotate_favorited(songs, request.user) groups = Group.objects.all() return render_html_template('aenclave/playlist_detail.html', request, {'playlist': playlist, 'song_list': songs, 'force_actions_bar': can_cede, 'allow_cede': can_cede, 'allow_edit': can_edit, 'allow_dragging': can_edit, 'groups': groups}, context_instance=RequestContext(request))
def playlist_detail(request, playlist_id): try: playlist = Playlist.objects.get(pk=playlist_id) except Playlist.DoesNotExist: raise Http404 can_cede = playlist.can_cede(request.user) can_edit = playlist.can_edit(request.user) # Using the PlaylistEntry default order_by makes a godawful query. songs = playlist.songs.order_by('playlistentry__position') songs = Song.annotate_favorited(songs, request.user) groups = Group.objects.all() return render_html_template('aenclave/playlist_detail.html', request, { 'playlist': playlist, 'song_list': songs, 'force_actions_bar': can_cede, 'allow_cede': can_cede, 'allow_edit': can_edit, 'allow_dragging': can_edit, 'groups': groups }, context_instance=RequestContext(request))
def list_songs(request): songs = get_song_list(request.REQUEST) songs = Song.annotate_favorited(songs, request.user) return render_html_template('aenclave/list_songs.html', request, {'song_list': songs}, context_instance=RequestContext(request))
def help(request): channel = Channel.objects.get(pk=1) # 1 is the default channel. playlist_info = json_response.json_channel_info(request, channel) return render_html_template( "aenclave/help.html", request, {"playlist_info": playlist_info}, context_instance=RequestContext(request) )
def help(request): channel = Channel.objects.get(pk=1) # 1 is the default channel. playlist_info = json_response.json_channel_info(request, channel) return render_html_template('aenclave/help.html', request, {'playlist_info': playlist_info}, context_instance=RequestContext(request))
{'id': str(song.id), 'artist': song.artist, 'album': song.album, 'title': song.title}) message += song_string song_list.append(song) try: mail_admins(subject,message,False) except Exception, e: logging.error("Could not send deletion mail: %s" % e) # Do the dirty deed. delete_songs_by_policy(songs) return render_html_template('aenclave/delete_performed.html', request, {}, context_instance=RequestContext(request)) @permission_required('aenclave.request_delete_song', 'Request Delete') def submit_delete_requests(request): form = request.POST # Add the songs and redirect to the detail page for this playlist. message = 'The following delete request(s) were filed' if request.user.is_authenticated(): subject = 'Delete Request from ' + request.user.username message += ' by ' + request.user.username + ':\n' else: subject = 'Delete Request from Anonymous' message += ' by an unregistered user:\n' song_list = []
if unit == 'hour': delta = datetime.timedelta(0, 3600) elif unit == 'day': delta = datetime.timedelta(1) elif unit == 'week': delta = datetime.timedelta(7) elif unit == 'month': delta = datetime.timedelta(30.43685) elif unit == 'year': delta = datetime.timedelta(365.24220) date = datetime.datetime.now() - number * delta if rule == 'last': return Qu(kind, 'gte', date) else: return Qu(kind, 'lt', date) else: if rule == 'before': return Qu(kind, 'lt', data) elif rule == 'after': return Qu(kind, 'gt', data) elif rule == 'inside': return Qu(kind, 'range', data) elif rule == 'outside': return Qu(kind, 'lt', data[0]) | Qu(kind, 'gt', data[1]) def filter_search(request): try: (tree, total, errors) = _build_filter_tree(request.GET, 'k') except KeyError, err: return html_error(request, message=str(err)) # TODO error (human's fault) if errors: return html_error(request, message=str(errors)) if total == 0: queryset = () else: queryset = Song.visibles.filter(_build_filter_query(tree)) queryset = Song.annotate_favorited(queryset, request.user) return render_html_template('aenclave/filter_results.html', request, {'song_list':queryset[:500], 'criterion_count':total}, context_instance=RequestContext(request))
def channel_detail(request, channel_id=1): try: channel = Channel.objects.get(pk=channel_id) except Channel.DoesNotExist: raise Http404 try: snapshot = request.get_channel_snapshot(channel) except ControlError, e: msg = "Error while connecting to player: %s" % e.message return html_error(request, msg) songs = Song.annotate_favorited(snapshot.song_queue, request.user) return render_html_template('aenclave/channels.html', request, {'channel': channel, 'current_song': snapshot.current_song, 'song_list': songs, 'force_actions_bar': True, 'elapsed_time': snapshot.time_elapsed, 'playing': snapshot.status == 'playing', 'no_queuing': True, 'allow_dragging': True}, context_instance=RequestContext(request)) def channel_history(request, channel_id=1): try: channel = Channel.objects.get(pk=channel_id) except Channel.DoesNotExist: raise Http404 try: snapshot = request.get_channel_snapshot(channel) except ControlError, e: msg = "Error while connecting to player: %s" % e.message return html_error(request, msg)
def list_songs(request): songs = get_song_list(request.REQUEST) songs = Song.annotate_favorited(songs, request.user) return render_html_template('aenclave/list_songs.html', request, {'song_list': songs}, context_instance=RequestContext(request))
'album': song.album, 'title': song.title }) message += song_string song_list.append(song) try: mail_admins(subject, message, False) except Exception, e: logging.error("Could not send deletion mail: %s" % e) # Do the dirty deed. delete_songs_by_policy(songs) return render_html_template('aenclave/delete_performed.html', request, {}, context_instance=RequestContext(request)) @permission_required('aenclave.request_delete_song', 'Request Delete') def submit_delete_requests(request): form = request.POST # Add the songs and redirect to the detail page for this playlist. message = 'The following delete request(s) were filed' if request.user.is_authenticated(): subject = 'Delete Request from ' + request.user.username message += ' by ' + request.user.username + ':\n' else: subject = 'Delete Request from Anonymous' message += ' by an unregistered user:\n'
def sftp_info(request): return render_html_template('aenclave/sftp_info.html', request, {'GST_PLAYER_HOST': settings.GST_PLAYER_HOST}, context_instance=RequestContext(request))
def sftp_info(request): return render_html_template('aenclave/sftp_info.html', request, {'GST_PLAYER_HOST': settings.GST_PLAYER_HOST}, context_instance=RequestContext(request))
def user_playlists(request, username): plists = Playlist.objects.filter(owner__username=username) return render_html_template('aenclave/playlist_list.html', request, {'playlist_list': plists}, context_instance=RequestContext(request))
try: channel = Channel.objects.get(pk=channel_id) except Channel.DoesNotExist: raise Http404 try: snapshot = request.get_channel_snapshot(channel) except ControlError, e: msg = "Error while connecting to player: %s" % e.message return html_error(request, msg) songs = Song.annotate_favorited(snapshot.song_queue, request.user) return render_html_template('aenclave/channels.html', request, { 'channel': channel, 'current_song': snapshot.current_song, 'song_list': songs, 'force_actions_bar': True, 'elapsed_time': snapshot.time_elapsed, 'playing': snapshot.status == 'playing', 'no_queuing': True, 'allow_dragging': True }, context_instance=RequestContext(request)) def channel_history(request, channel_id=1): try: channel = Channel.objects.get(pk=channel_id) except Channel.DoesNotExist: raise Http404 try: snapshot = request.get_channel_snapshot(channel) except ControlError, e:
def user_playlists(request, username): plists = Playlist.objects.filter(owner__username=username) return render_html_template('aenclave/playlist_list.html', request, {'playlist_list': plists}, context_instance=RequestContext(request))
elif unit == 'month': delta = datetime.timedelta(30.43685) elif unit == 'year': delta = datetime.timedelta(365.24220) date = datetime.datetime.now() - number * delta if rule == 'last': return Qu(kind, 'gte', date) else: return Qu(kind, 'lt', date) else: if rule == 'before': return Qu(kind, 'lt', data) elif rule == 'after': return Qu(kind, 'gt', data) elif rule == 'inside': return Qu(kind, 'range', data) elif rule == 'outside': return Qu(kind, 'lt', data[0]) | Qu(kind, 'gt', data[1]) def filter_search(request): try: (tree, total, errors) = _build_filter_tree(request.GET, 'k') except KeyError, err: return html_error(request, message=str(err)) # TODO error (human's fault) if errors: return html_error(request, message=str(errors)) if total == 0: queryset = () else: queryset = Song.visibles.filter(_build_filter_query(tree)) queryset = Song.annotate_favorited(queryset, request.user) return render_html_template('aenclave/filter_results.html', request, { 'song_list': queryset[:500], 'criterion_count': total }, context_instance=RequestContext(request))