def index(request):
if request.method == 'POST':
form = BookmarkForm(request.POST)
if form.is_valid():
new_bookmark = form.save()
raw_tags = form.cleaned_data['tags'].split(',')
if raw_tags:
for raw_tag in raw_tags:
raw_tag = raw_tag.strip().replace(' ', '-').lower()
tag_slug = urllib.quote(raw_tag)
tag, created = Tag.objects.get_or_create(slug=tag_slug)
tag.save()
tag.bookmarks.add(new_bookmark)
if request.is_ajax():
return render(request, 'bookmark.html', {'bookmark': new_bookmark})
return redirect(index)
else:
response = 'Errors: '
for key in form.errors.keys():
value = form.errors[key]
errors = ''
for error in value:
errors = errors + error + ' '
response = response + ' ' + key + ': ' + errors
return HttpResponse('<li class="error">' + response + '</li>')
else:
bookmarks = Bookmark.objects.all().order_by('-timestamp')[:10]
current_user = request.user
form = BookmarkForm(initial={'author': current_user})
context = {
'bookmarks': bookmarks,
'form': form,
}
return render(request, 'index.html', context)
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 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 bookmark_save(request):
if request.method == 'POST':
form = BookmarkForm(request.POST)
if form.is_valid():
#Create or get link
link,dummy = Link.objects.get_or_create(url=form.cleaned_data['url'])
#create or get bookmark
bookmark,created = Bookmark.objects.get_or_create(
user = request.user,link=link
)
#update bookmark title
bookmark.title = form.cleaned_data['title']
#if bookmark is being updated clear old tag list
if not created:
bookmark.tag_set.clear()
#create new tag list
tag_names = form.cleaned_data['tags'].split()
for tag_name in tag_names:
tag,dummy = Tag.objects.get_or_create(name=tag_name)
bookmark.tag_set.add(tag)
#share bookmark on main page if requested
if form.cleaned_data['share']:
shared,created = SharedBookmark.objects.get_or_create(bookmark=bookmark)
if created:
shared.users_voted.add(request.user)
shared.save()
#save bookmark to database
bookmark.save()
return HttpResponseRedirect('/bookmarks/user/%s'% request.user.username)
else:
form = BookmarkForm()
variables = RequestContext(request,{'form':form})
return render_to_response('bookmark_save.html',variables)
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 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 add_bookmark(request):
if request.method == 'POST':
form = BookmarkForm(request.POST)
if form.is_valid():
bookmark = form.save(commit=False)
bookmark.author = request.user
bookmark.save()
return render_to_response('add_bookmark_thanks.html',
context_instance=RequestContext(request))
else:
form = BookmarkForm()
return render_to_response('add_bookmark.html',
{'form':form},
context_instance=RequestContext(request))
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 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 bookmarks_ajax(request):
response_data = {}
response_data['success'] = False
response_data['errors'] = ''
if not request.method == 'POST'or not request.is_ajax():
return http.HttpResponseForbidden('Forbidden.')
data = request.POST
files = request.FILES
form = BookmarkForm(data, files, user=request.user)
if form.is_valid():
try:
b = Bookmark.objects.get(article_id=form.cleaned_data.get('article_id'),
user=request.user)
b.delete()
except Bookmark.DoesNotExist:
b = Bookmark(article_id=form.cleaned_data.get('article_id'),
user=request.user)
b.save()
# Delete bookmarks session key so they get rebuilt on next request
# via middleware
if request.session.get('bookmarks'):
del request.session['bookmarks']
# Delete article instance cache
a = Article.objects.get(pk=form.cleaned_data.get('article_id'))
a.clear_cache()
# Delete user dashboard cache if possible
try:
urlpath = URLPath.objects.get(slug=request.user.username)
urlpath.article.clear_cache()
except:
pass
response_data['success'] = True
else:
response_data['errors'] = dict((k, map(unicode, v))
for (k, v) in form.errors.iteritems())
return http.HttpResponse(simplejson.dumps(response_data),
mimetype='application/json; charset=UTF-8')
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(request):
if request.method == 'POST':
form = BookmarkForm(request.POST)
if form.is_valid():
bookmark = Bookmark.objects.get(url=form.cleaned_data['url'])
profile = Profile.objects.get(user_id = request.user.id)
if bookmark is None:
bookmark = form.save(commit = False)
bookmark.author = profile
bookmark.save()
bookmark.subscribers.add(profile)
return redirect(reverse('bookmarks:index'))
else:
form = BookmarkForm()
return render(request, 'bookmarks/add.html', {
'form' : form
})
def modify(request, bookmark_id):
bookmark = get_object_or_404(Bookmark, pk=bookmark_id, author=request.user)
if request.method == 'POST':
form = BookmarkForm(request.POST, instance=bookmark)
if form.is_valid():
bookmark = form.save(commit=False)
bookmark.author = request.user
bookmark.save()
messages.success(request, 'Bookmark details updated.')
return HttpResponseRedirect('/bookmark/%s/'%bookmark_id)
else:
return render_to_response('bookmark_modify.html',
{'bookmark_id': bookmark_id, 'form': form},
context_instance=RequestContext(request))
else:
form = BookmarkForm(instance=bookmark)
return render_to_response('bookmark_modify.html',
{'bookmark_id': bookmark_id, 'form': form},
context_instance=RequestContext(request))
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 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 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]))
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]))
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,
})
