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))
