def album(request, album_id = None):
if album_id is not None:
album = request.db_session.query(Album).get(album_id)
else:
album = Album()
if request.method == 'POST':
if 'cancel' in request.POST:
return redirect('index')
form = AlbumForm(request.POST)
if form.is_valid():
# hydrate album object
album.title = form.cleaned_data['title']
album.artist = form.cleaned_data['artist']
# save it
request.db_session.add(album)
request.db_session.commit()
# show flash message to confirm update is OK
messages.success(request, "Album saved successfully")
# redirect to list of albums
return redirect('index')
elif album_id is not None:
form = AlbumForm(album.__dict__)
else:
form = AlbumForm()
return render(request, "album.html", {'form': form, 'album_id': album_id})
def create_album(request):
form=AlbumForm(request.POST or None)
if form.is_valid():
form.save()
#use reverse always with the HttpResponseRedirect
return HttpResponseRedirect(reverse('home'))
return render(request,'app/createform.html',{'form':form})
def add_album(request):
"""
Add a new album by POST-ing a hashtag.
"""
album_form = AlbumForm(request.POST or None)
errors = []
if request.method == "POST":
if album_form.is_valid():
# sanitize data
value = album_form.cleaned_data
hashtag = value["hashtag"]
print hashtag
# get existing database albums
user = User.objects.get(username=request.user)
user_albums = Album.objects.get_user_posted_albums(user=user)
print user_albums
for album in user_albums:
if album.name == hashtag:
errors.append("Album already exists.")
break
# add album to user albums if it doesn't exist already.
if len(errors) == 0:
new_album = Album(name=hashtag, user=user)
new_album.save()
print hashtag
return HttpResponseRedirect(reverse("add_confirm", kwargs={"hashtag": hashtag}))
else:
context_instance = RequestContext(request, {"errors": errors})
return render_to_response("add_album.html", context_instance)
context_instance = RequestContext(request, {"album_form": album_form, "errors": errors})
return render_to_response("add_album.html", context_instance)
def edit(album_id):
form = AlbumForm(request.form)
if request.method == 'POST' and form.validate():
title = form.title.data
body = form.body.data
# create cursor
cur = mysql.connection.cursor()
update = """UPDATE albums
SET title = '{0}', body = '{1}'
WHERE id = '{2}'
""".format(title, body, album_id)
cur.execute(update)
# commit to db
mysql.connection.commit()
# close cursor connection
cur.close()
flash('album successfully updated', 'success')
return redirect(url_for('album', album_id=album_id))
return render_template('edit.html', form=form, album=find_by_id(album_id))
def album_create(request):
if request.method == 'POST':
form = AlbumForm(request.POST)
print 'submit album'
if form.is_valid(): # coming from save button click
q = Album()
for each in form:
if type(
each.field
) is forms.ModelChoiceField: # get the value from 'select' (artist)
# value_needed = form.cleaned_data[each.name].pk ---> this is the option number
value_needed = form.cleaned_data[each.name]
a = Artist.objects.get(
name=value_needed) # a is Artist instance
setattr(q, each.name, a)
else: # get the value from title or date
value_needed = form.cleaned_data[each.name]
setattr(q, each.name, value_needed)
q.save()
return redirect('index') # you won't see 'form' in url
else: # if a GET (or any other method, or when getting to this page at first - we'll create a blank form
form = AlbumForm()
print 'Initial album_create page '
return render(
request,
'mymusic/album_create.html',
{
'form':
form # render create album with empty form or with the form we already started to fill
})
def delete(id):
qry = db_session.query(Album).filter(Album.id==id)
album = qry.first()
if album:
form = AlbumForm(formdata=request.form, obj=album)
if request.method == 'DELETE' and form.validate():
db_session.delete(album)
db_session.commit()
def new_album():
form = AlbumForm(request.form)
if request.method == 'POST' and form.validate():
# save the album
al = Album()
album_save_changes(al, form, new=True)
flash('Album created successfully!')
return redirect('/albuminfo')
return render_template('new_album.html', form=form)
def new_album():
"""
Add a new album
"""
form = AlbumForm(request.form)
if request.method == 'POST' and form.validate():
# save the album
album = Album()
save_changes(album, form, new=True)
flash('Data inserted successfully!')
return redirect('/')
return render_template('new_album.html', form=form)
def edit(id):
qry = Album.query.filter(Album.id == id)
al = qry.first()
if Album:
form = AlbumForm(formdata=request.form, obj=al)
if request.method == 'POST' and form.validate():
# save edits
album_save_changes(al, form)
flash('Album updated successfully!')
return redirect('/Albuminfo')
return render_template('edit_Album.html', form=form)
else:
return 'Error loading #{id}'.format(id=id)
def edit(id):
qry = db_session.query(Album).filter(Album.id==id)
album = qry.first()
if album:
form = AlbumForm(formdata=request.form, obj=album)
if request.method == 'POST' and form.validate():
# save edits
save_changes(album, form)
return redirect('/')
return render_template('edit_album.html', form=form)
else:
return 'Error loading #{id}'.format(id=id)
def create_album_view(request):
''' Allows users to create new albums and upload photos '''
if request.POST:
album = Album(creator=request.user)
album_form = AlbumForm(request.POST, instance=album)
if album_form.is_valid():
album_form.save()
return HttpResponseRedirect('/edit/%s' % album.pk)
messages.info(request, 'Incomplete input.')
return HttpResponseRedirect(reverse('create'))
album_form, photo_form, c = AlbumForm(), PhotoForm(), {}
c.update(csrf(request))
context = {'album_form': album_form, 'photo_form': photo_form, 'c': c, }
return render(request, 'create.html', context)
def delet(id):
qry = Album.query.filter(Album.id == id)
al = qry.first()
if al:
form = AlbumForm(formdata=request.form, obj=al)
if request.method == 'POST' and form.validate():
# delete the item from the database
db.session.delete(al)
db.session.commit()
flash('Album deleted successfully!')
return redirect('/albuminfo')
return render_template('delete_album.html', form=form)
else:
return 'Error deleting #{id}'.format(id=id)
def album_create(request):
if request.method == 'POST':
form = AlbumForm(request.POST)
if form.is_valid():
album = form.save(commit=False)
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm()
return render(request, 'gallery/administration/album_create.html', {
'form': form
})
def post_album(username):
user = User.query.filter_by(username=username).first()
form = AlbumForm()
if request.method == 'POST' and form.validate():
new_album = Album(title=form.title.data,
image=form.image.data,
user_id=current_user.id)
db.session.add(new_album)
db.session.commit()
flash('Album successfully created')
album = Album.query.filter_by(title=new_album.title).first()
return redirect(
url_for('photos',
username=current_user.username,
album_id=album.id))
return render_template('new_album.html', user=user, form=form)
def album_edit(request, id):
album = get_object_or_404(Album, id=id)
if request.method == 'POST':
form = AlbumForm(request.POST, instance=album)
if form.is_valid():
album = form.save(commit=False)
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm(instance=album)
return render(request, 'gallery/administration/album_edit.html', {
'form': form
})
def new_album():
"""
Add a new album
"""
form = AlbumForm(request.form)
if request.method == 'POST' and form.validate():
# save the album
album = Album()
save_changes(album, form, new=True)
flash(
f'You have successfully created the album {album.title} by {album.artist}!'
)
return redirect('/')
return render_template('new_album.html', form=form)
def edit(id):
"""
Add / edit an item in the database
"""
qry = db_session.query(Album).filter(Album.id == id)
album = qry.first()
if album:
form = AlbumForm(formdata=request.form, obj=album)
if request.method == 'POST' and form.validate():
# save edits
save_changes(album, form)
flash('Album updated successfully!')
return redirect('/')
return render_template('edit_album.html', form=form)
else:
return 'Error loading #{id}'.format(id=id)
def album_edit(request, album_slug):
item_from_url = get_item_or_404(album_slug, None)
if request.method=='POST':
form = AlbumForm(request.POST, instance=item_from_url)
if form.is_valid():
item = form.save()
return HttpResponseRedirect(item.get_absolute_url())
else:
form = AlbumForm(instance=item_from_url)
return render_to_response('albums/edit_item.html', {
'item': item_from_url,
'form': form,
}, context_instance=RequestContext(request))
def create_album(request,album_id=1):
if request.POST:
form = AlbumForm(request.POST, request.FILES)
if form.is_valid():
form.save()
return HttpResponseRedirect('/galleries/albums/')
else:
form = AlbumForm()
args = {}
args.update(csrf(request))
args['form'] = form
return render(request,'create_album.html', args)
def create_album(request, artist_id, album_id=None):
if request.method != "POST":
return HttpResponse(
json.dumps({'error': 'Invalid http method for this uri'}))
SongFormset = inlineformset_factory(Album, Song)
if album_id is not None:
album = Album.objects.get(pk=album_id)
albumForm = AlbumForm(request.POST, request.FILES, instance=album)
songsForm = SongFormset(request.POST,
request.FILES,
instance=album,
prefix="form")
else:
albumForm = AlbumForm(request.POST, request.FILES)
songsForm = SongFormset(request.POST, request.FILES, prefix="form")
if songsForm.is_valid() and albumForm.is_valid():
albumForm.save()
songsForm.save()
return HttpResponse(json.dumps({'success': 'true'}))
else:
errors = {}
errors['song_errors'] = [dict(err.items()) for err in songsForm.errors]
errors['album_errors'] = dict(albumForm.errors.items())
resp = HttpResponse(json.dumps({'errors': errors}),
mimetype="application/json")
resp.status_code = 400
return resp
def delete(id):
"""
Delete the item in the database that matches the specified
id in the URL
"""
qry = db_session.query(Album).filter(Album.id == id)
album = qry.first()
if album:
form = AlbumForm(formdata=request.form, obj=album)
if request.method == 'POST' and form.validate():
# delete the item from the database
db_session.delete(album)
db_session.commit()
flash('Album deleted successfully!')
return redirect('/')
return render_template('delete_album.html', form=form)
else:
return 'Error deleting #{id}'.format(id=id)
def create_photo(request):
if request.POST:
album_form = AlbumForm(album_id=request.REQUEST.get("album_id"), user=request.user.user, data=request.POST)
if album_form.is_valid():
album = album_form.save()
else:
album = None
photo_formset = PhotoFormSet(album, request.POST, request.FILES)
if album and photo_formset.is_valid():
for form in photo_formset.forms:
if form.is_valid():
form.save()
return HttpResponseRedirect(album.get_absolute_url())
else:
album_form = AlbumForm(album_id=request.REQUEST.get("album_id"), user=request.user.user)
photo_formset = PhotoFormSet()
return {"album_form": album_form, "photo_forms": photo_formset}
def album_create(request):
if request.method == 'POST':
form = AlbumForm(request.POST)
if form.is_valid():
album = form.save(commit=False)
if 'album_form_avatar' in request.FILES:
avatar_img_name = handle_uploaded_file(request.FILES['album_form_avatar'])
album.avatar_img_name = avatar_img_name
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm()
return render(request, 'gallery/administration/album_create.html', {
'form': form
})
def new_album(request):
""" Deprecated """
error = None
if request.method == "POST": #submission of new album
form = AlbumForm(request.POST, user=request.user)
if form.is_valid():
album = form.save(commit=False)
album.user = request.user
try:
album.validate_unique()
album.set_order()
album.save()
return HttpResponse("<div title=\"%s\"><input type=\"hidden\" id=\"status\" value=\"%s\"/></div>" % (album.title, album.id))
except ValidationError:
error = _("You have used this album title before. Make sure to pick an unique title.")
else: #request for rendered form
album = Album(user=request.user)
form = AlbumForm(instance=album, user=request.user, initial={'user': request.user})
return render(request, 'albums/ajax/new_album.html', {'form': form, 'error': error})
def createalbum():
user = User.query.get(current_user.id)
form = AlbumForm()
if form.validate_on_submit():
album = Album(name=form.name.data,
picturelink=form.picturelink.data,
user_id=user.id,
songs=[])
user.albums.append(album)
db.session.add(album)
db.session.commit()
return redirect('albums')
return render_template('/home/createalbum.html',
action="Add",
form=form,
title="Add album")
def new_album_jquery_ui(request):
if request.method == "POST":
try:
from_page = request.POST['from-page']
except KeyError:
from_page = None
new_album = Album(user=request.user)
form = AlbumForm(request.POST, user=request.user, instance=new_album)
t = loader.get_template(u'albums/ajax/new_album_jquery-ui.html')
context = {'from_page': from_page}
if form.is_valid():
album = form.save()
context['form'] = AlbumForm(
instance = Album(user=request.user),
user=request.user
)
rendered_form = t.render(RequestContext(request, context))
output = {
'status': 1,
'form': rendered_form,
}
if from_page == u"upload": # return option to append to select
option = '<option value="%s" selected="selected">%s</option>' % (
album.id,
album.__unicode__()
)
output['option'] = mark_safe(option)
elif from_page == u"my-albums-list": # return li element to place in list
t2 = loader.get_template(u'albums/album_li.html')
album_li = t2.render(RequestContext(request, {'album': album}))
output['album_li'] = album_li
output['album_write_mode'] = album.writable_to
else:
context['form'] = form
rendered_form = t.render(RequestContext(request, context))
output = {'form': rendered_form, 'status': 0}
return HttpResponse(json.dumps(output), mimetype="application/json")
def new_album():
"""
Add a new album
"""
form = AlbumForm(request.form)
if request.method == 'POST':
# save the album
album = Album()
save_changes(album, form, new=True)
flash('Invoice created successfully!')
return redirect('/invoice/invoice')
return render_template('new_album.html', form=form)
def new_album():
"""
Add a new album
"""
form = AlbumForm(request.form)
if request.method == 'POST':
# save the album
album = Album()
save_changes(album, form, new=True)
return redirect('/')
return render_template('new_album.html', form=form)
def album_edit(request, id):
album = get_object_or_404(Album, id=id)
if request.method == 'POST':
form = AlbumForm(request.POST, instance=album)
if form.is_valid():
album = form.save(commit=False)
if 'album_form_avatar' in request.FILES:
if album.avatar_img_name:
handle_uploaded_file(request.FILES['album_form_avatar'], album.avatar_img_name)
else:
avatar_img_name = handle_uploaded_file(request.FILES['album_form_avatar'])
album.avatar_img_name = avatar_img_name
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm(instance=album)
return render(request, 'gallery/administration/album_edit.html', {
'form': form
})
def add_album(request, full_slug=None,
template='albums/add_album.html',
template_ajax='albums/add_album_ajax.html'):
if(request.is_ajax()):
template = template_ajax
if request.method == 'POST':
form = AlbumForm(request.POST)
if form.is_valid():
album = form.save(commit=False)
album.save()
album.owners.add(request.user)
album.save()
return HttpResponseRedirect(album.get_absolute_url())
else:
form = AlbumForm()
return render_to_response(template, {
'form': form,
},
context_instance=RequestContext(request))
def edit(id):
qry = db.session.query(Album).filter(
Album.id==id)
album = qry.first()
if album:
form = AlbumForm(formdata=request.form, obj=album)
if request.method == 'POST':
# save edits
save_changes(album, form)
flash('Invoice updated successfully!')
return redirect('/invoice/invoice')
return render_template('edit_album.html', form=form)
else:
return 'Error loading #{id}'.format(id=id)
def new():
form = AlbumForm(request.form)
if request.method == 'POST' and form.validate():
title = form.title.data
body = form.body.data
# create cursor
cur = mysql.connection.cursor()
insert = """INSERT INTO albums(title, author, body)
VALUES('{0}', '{1}', '{2}')
""".format(title, session['username'], body)
cur.execute(insert)
# commit to db
mysql.connection.commit()
# close cursor connection
cur.close()
flash('album successfully updated', 'success')
return redirect(url_for('albums'))
return render_template('new.html', form=form)
def create_album(request, artist_id, album_id=None):
if request.method != "POST":
return HttpResponse(json.dumps({ 'error': 'Invalid http method for this uri' }))
SongFormset = inlineformset_factory(Album, Song)
if album_id is not None:
album = Album.objects.get(pk=album_id)
albumForm = AlbumForm(request.POST, request.FILES, instance=album)
songsForm = SongFormset(request.POST, request.FILES, instance=album, prefix="form")
else:
albumForm = AlbumForm(request.POST, request.FILES)
songsForm = SongFormset(request.POST, request.FILES, prefix="form")
if songsForm.is_valid() and albumForm.is_valid():
albumForm.save()
songsForm.save()
return HttpResponse(json.dumps({ 'success': 'true' }))
else:
errors = {}
errors['song_errors'] = [dict(err.items()) for err in songsForm.errors]
errors['album_errors'] = dict(albumForm.errors.items())
resp = HttpResponse(json.dumps({ 'errors': errors }),
mimetype="application/json")
resp.status_code = 400
return resp
def album_create(request):
if request.method == 'POST':
form = AlbumForm(request.POST)
if form.is_valid():
album = form.save(commit=False)
if 'album_form_avatar' in request.FILES:
avatar_img_name = handle_uploaded_file(
request.FILES['album_form_avatar'])
album.avatar_img_name = avatar_img_name
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm()
return render(request, 'gallery/administration/album_create.html',
{'form': form})
def album_edit(request, id):
album = get_object_or_404(Album, id=id)
if request.method == 'POST':
form = AlbumForm(request.POST, instance=album)
if form.is_valid():
album = form.save(commit=False)
if 'album_form_avatar' in request.FILES:
if album.avatar_img_name:
handle_uploaded_file(request.FILES['album_form_avatar'],
album.avatar_img_name)
else:
avatar_img_name = handle_uploaded_file(
request.FILES['album_form_avatar'])
album.avatar_img_name = avatar_img_name
if not request.user.has_perm('gallery.public_album'):
album.public = False
album.save()
return redirect('gallery:administration:albums_list')
else:
form = AlbumForm(instance=album)
return render(request, 'gallery/administration/album_edit.html',
{'form': form})
def new():
"""
Create a new album.
---
tags:
- Albums
security:
- OAuth2:
- write
responses:
200:
description: Returns id and slug.
"""
current_user = current_token.user
if not current_user:
return jsonify({"error": "Unauthorized"}), 403
# Check artwork file size
if "artwork" in request.files:
artwork_uploaded = request.files["artwork"]
artwork_uploaded.seek(0, os.SEEK_END)
artwork_size = artwork_uploaded.tell()
artwork_uploaded.seek(0)
if artwork_size > Reel2bitsDefaults.artwork_size_limit:
return jsonify({"error": "artwork too big, 2MB maximum"
}), 413 # Request Entity Too Large
else:
artwork_uploaded = None
form = AlbumForm()
if form.validate_on_submit():
rec = Album()
rec.user_id = current_user.id
rec.title = form.title.data
rec.private = form.private.data
rec.description = form.description.data
rec.genre = form.genre.data
# Save the artwork
if artwork_uploaded:
artwork_filename = get_hashed_filename(artwork_uploaded.filename)
artworkalbums.save(artwork_uploaded,
folder=current_user.slug,
name=artwork_filename)
rec.artwork_filename = artwork_filename
# Handle tags
tags = form.tags.data.split(",")
# Clean
tags = [t.strip() for t in tags if t]
# For each tag get it or create it
for tag in tags:
dbt = SoundTag.query.filter(SoundTag.name == tag).first()
if not dbt:
dbt = SoundTag(name=tag)
db.session.add(dbt)
rec.tags.append(dbt)
db.session.add(rec)
db.session.commit()
# log
add_user_log(rec.id, rec.user_id, "albums", "info",
"Created {0} -- {1}".format(rec.id, rec.title))
return jsonify({"id": rec.flake_id, "slug": rec.slug})
return jsonify({"error": json.dumps(form.errors)}), 400
