def add(request):
if request.method == "POST":
bookmark_form = BookmarkForm(request.user, request.POST)
if bookmark_form.is_valid():
bookmark_instance = bookmark_form.save()
if bookmark_form.should_redirect():
return HttpResponseRedirect(bookmark.page.url)
else:
return HttpResponseRedirect(reverse("all_bookmarks"))
else:
initial = {}
if "url" in request.GET:
initial["url"] = request.GET["url"]
if "title" in request.GET:
initial["title"] = request.GET["title"]
if "redirect" in request.GET:
initial["redirect"] = request.GET["redirect"]
if initial:
bookmark_form = BookmarkForm(initial=initial)
else:
bookmark_form = BookmarkForm()
bookmarks_add_url = "http://" + Site.objects.get_current(
).domain + reverse("add_bookmark")
bookmarklet = "javascript:location.href='%s?url='+encodeURIComponent(location.href)+';title='+encodeURIComponent(document.title)+';redirect=on'" % bookmarks_add_url
return render(request, ["bookmarks/add.html"], {
"bookmarklet": bookmarklet,
"bookmark_form": bookmark_form,
})
def get_form_for_sound(request, sound_id):
sound = Sound.objects.get(id=sound_id)
form = BookmarkForm(instance=Bookmark(name=sound.original_filename),
prefix=sound.id)
form.fields['category'].queryset = BookmarkCategory.objects.filter(
user=request.user)
categories_already_containing_sound = BookmarkCategory.objects.filter(
user=request.user, bookmarks__sound=sound).distinct()
add_bookmark_url = '/'.join(
reverse('add-bookmark', args=[sound_id]).split('/')[:-2]) + '/'
add_bookmark_url = '/'.join(
request.build_absolute_uri(reverse(
'add-bookmark', args=[sound_id])).split('/')[:-2]) + '/'
data_dict = {
'bookmarks':
Bookmark.objects.filter(user=request.user, sound=sound).count() != 0,
'sound_id':
sound.id,
'form':
form,
'categories_aready_containing_sound':
categories_already_containing_sound,
'add_bookmark_url':
add_bookmark_url
}
template = 'bookmarks/bookmark_form.html'
return render_to_response(template,
data_dict,
context_instance=RequestContext(request))
def test_form_does_not_validate_with_no_url(self):
form_data = {
'name': '',
'url': 'https://www.google.com',
}
form = BookmarkForm(data=form_data)
self.assertFalse(form.is_valid())
def add_bookmark():
form = BookmarkForm(link='http://')
if form.validate_on_submit() and request.method == 'POST':
# Get form data
link = form.link.data
follow_redirects = form.follow_redirects.data # T/F for following link redirects
# Test that link works, or return error to user
try:
r = requests.get(link,
headers={'user-agent': USER_AGENT},
allow_redirects=follow_redirects,
timeout=TIMEOUT)
r.raise_for_status()
# Exceptions for 400 or 500 errors
except requests.exceptions.HTTPError as e:
flash('Please check your link. It leads to this error: {}.'.format(
e),
category='danger')
# Missing schema
except requests.exceptions.MissingSchema as e:
flash('No schema. Did you mean http://{}?'.format(link),
category='danger')
# Timeout errors
except requests.exceptions.Timeout:
flash('There was a timeout error. Please check URL.',
category='danger')
# Connection errors
except requests.exceptions.ConnectionError:
flash('Could not connect to your link. Please check URL.',
category='danger')
# Too many redirects
except requests.exceptions.TooManyRedirects:
flash('Exceeded max number of redirects. Please check URL.',
category='danger')
# All other requests-related exceptions
except requests.exceptions.RequestException as e:
flash('Please check your link. It leads to this error: {}.'.format(
e),
category='danger')
# No errors when requesting link, so add to database
else:
# Generate a possible id
b_id = hex_gen()
# If it exists, keep regenerating
while (Bookmark.query.filter(Bookmark.id == b_id).one_or_none()
is not None):
b_id = hex_gen()
url = r.url # Get final url (from redirects)
url_root = request.url_root
b = Bookmark(b_id, link=url, user_id=flask_login.current_user.id)
db_session.add(b)
db_session.commit()
msg_uf = ('Successfully added {0}. Your short link is ' +
'<a target="_blank" href="{1}">{1}</a>.')
msg = msg_uf.format(url, url_root + b_id)
flash(Markup(msg), category='success')
return redirect(url_for('add_bookmark'), 303)
return render_template('add_bookmark.html', form=form)
def test_form_validates(self):
form_data = {
'name': 'Bookmark 1',
'url': 'https://www.google.com',
'notes': 'This is the first note.',
}
form = BookmarkForm(data=form_data)
self.assertTrue(form.is_valid())
def test_form_does_not_validate_with_empty_data(self):
form_data = {
'name': '',
'url': '',
'notes': '',
}
form = BookmarkForm(data=form_data)
self.assertFalse(form.is_valid())
def create_bookmarks(request):
if request.method == "POST":
form = BookmarkForm(request.POST)
if form.is_valid():
url = form.cleaned_data['url']
urlname = form.cleaned_data['urlname']
course = form.cleaned_data['course']
Bookmark.add_bookmark(course, url, urlname)
messages.success(request, "Bookmark saved successfully!")
return redirect('bookmarks:create')
else:
form = BookmarkForm()
form.fields["course"].queryset = Course.objects.filter(user=request.user)
bookmarks = Bookmark.objects.select_related('course').filter(
course__user=request.user)
return render(request, 'bookmarks/bookmarks.html', {
'bookmarks': bookmarks,
'form': form,
})
def bookmark_edit(id):
bookmark = Bookmark.query.filter_by(id=id).first()
if not bookmark:
return abort(404)
form = BookmarkForm(request.form, obj=bookmark)
if form.validate_on_submit():
form.populate_obj(bookmark)
db.session.add(bookmark)
db.session.commit()
flash(u'Done!')
return redirect('%d' % bookmark.id)
flash_errors(form)
return render_template('bookmark-form.html', form=form)
def edit_bookmark(bookmark_id):
bookmark = Bookmark.query.get_or_404(bookmark_id)
if current_user != bookmark.user:
return render_template('403.html')
form = BookmarkForm(obj=bookmark)
if form.validate_on_submit():
form.populate_obj(bookmark)
db.session.commit()
flash("Stored '{}'".format(bookmark.description))
return redirect(url_for('user', username=current_user.username))
return render_template('bookmark_form.html',
form=form,
title="Edit bookmark")
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
tags = form.tags.data
bm = Bookmark(user=current_user,
url=url,
description=description,
tags=tags)
db.session.add(bm)
db.session.commit()
flash("Stored '{}'".format(description))
return redirect(url_for('index'))
return render_template('bookmark_form.html',
form=form,
title="Add a bookmark")
def bookmark_new():
form = BookmarkForm(request.form)
if form.validate_on_submit():
try:
bookmark = Bookmark(form.url.data,
form.title.data,
description=form.description.data,
tags=form.tags.data,
public=form.public.data)
db.session.add(bookmark)
db.session.commit()
except IntegrityError:
flash(u'Boomark for "%s" exists already.' % form.url.data, 'error')
return render_template('bookmark-form.html', form=form)
flash(u'Done!')
return redirect('%d' % bookmark.id)
flash_errors(form)
return render_template('bookmark-form.html', form=form)
def add_bookmark(request, sound_id):
sound = get_object_or_404(Sound, id=sound_id)
if request.POST:
form = BookmarkForm(request.POST, instance=Bookmark(user=request.user, sound=sound))
form.fields['category'].queryset = BookmarkCategory.objects.filter(user=request.user)
if form.is_valid():
form.save()
if request.is_ajax():
return HttpResponse()
else:
msg = "Added new bookmark for sound \"" + sound.original_filename + "\"."
messages.add_message(request, messages.WARNING, msg)
next = request.GET.get("next", "")
if next:
return HttpResponseRedirect(next)
else:
return HttpResponseRedirect(reverse("sound", args=[sound.user.username, sound.id]))
