def bookmark(request, id):
try:
bookmark = Bookmark.objects.get(user=request.user, event_id=id)
except Bookmark.DoesNotExist:
bookmark = Bookmark(user=request.user, event_id=id)
bookmark.save()
return redirect(bookmark)
def save_bookmark_to_note(request, note):
saved_bookmarks = 0
if request.method == 'POST':
if 'bookmarks' in request.POST:
for bookmark_id in request.POST['bookmarks'].split(","):
if bookmark_id != '':
bookmark = get_object_or_None(Bookmark, pk=bookmark_id)
if bookmark:
bookmark.note = note
bookmark.save()
chart = False
tags = []
if 'chart_id' in request.POST:
chart = get_object_or_None(Chart, pk=request.POST['chart_id'])
if 'tags' in request.POST:
for short in request.POST['tags'].split(','):
if short != '':
tag = get_object_or_None(Tag, short=short)
if tag:
tags.append(tag)
if chart:
bookmark = Bookmark()
bookmark.chart = chart
bookmark.note = note
bookmark.save()
bookmark.tags = tags
return saved_bookmarks
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
destination = form.destination.data
outbound_date = form.outbound_date.data
outbound_time = form.outbound_time.data
inbound_date = form.inbound_date.data
inbound_time = form.inbound_time.data
tags = form.tags.data
bm = Bookmark(user=current_user,
url=url,
description=description,
destination=destination,
tags=tags,
outbound_date=outbound_date,
outbound_time=outbound_time,
inbound_date=inbound_date,
inbound_time=inbound_time)
db.session.add(bm)
db.session.commit()
flash("Stored trip '{}'".format(description))
return redirect(url_for('index'))
return render_template('bookmark_form.html', form=form, title="Add a Trip")
def get_bookmarks_from_api_response_items(items: List[Dict]) -> List[Bookmark]:
'''
Get bookmark model from API response dict
'''
bookmarks: List[Bookmark] = []
for item in items:
items_tags: List[Tag] = []
bookmark_tag_mappings: List[BookmarkTagMapping] = []
for item_tag_str in item['tags']:
bookmark_tag_mappings.append(
BookmarkTagMapping(item['_id'], item_tag_str))
items_tags.append(Tag(item_tag_str))
bookmarks.append(
Bookmark(
_id=item['_id'],
created_at=item['created'],
updated_at=item['lastUpdate'],
link=item['link'],
title=item['title'],
tags=items_tags,
mappings=bookmark_tag_mappings)
)
return bookmarks
def bookmarks():
form_add = AddBookmarkForm()
form_remove = RemoveBookmarkForm()
action = request.form.get('submit', '').lower()
if action == 'add':
if form_add.validate_on_submit():
bookmark = Bookmark(current_user, form_add.bookmark.data)
db.session.add(bookmark)
db.session.commit()
flash('Saved.', 'success')
return redirect(url_for('bookmarks'))
elif action == 'remove':
if form_remove.validate_on_submit():
for email in form_remove.bookmarks.data:
bookmark = current_user.bookmarks.filter_by(
email=email).first()
db.session.delete(bookmark)
db.session.commit()
flash('Removed.', 'success')
return redirect(url_for('bookmarks'))
return render_template('bookmarks.html',
form_add=form_add,
form_remove=form_remove)
def save_bookmark(request, bookmark_id=False):
if request.is_ajax:
return ajax_save_bookmark(request, bookmark_id)
form = BookmarkForm()
bookmark = get_object_or_None(Bookmark, pk=bookmark_id)
if bookmark:
form = BookmarkForm(instance=bookmark)
if not request.user.is_authenticated() or (
not request.user.is_staff and
(bookmark.note.author == request.user)):
return HttpResponseRedirect(reverse(list, args=(note.id, )))
if request.method == "POST":
if bookmark:
form = BookmarkForm(request.POST, instance=bookmark)
else:
form = BookmarkForm(request.POST)
if form.is_valid():
if not bookmark:
bookmark = Bookmark()
bookmark.save()
if 'text' in form.cleaned_data:
bookmark.text = form.cleaned_data['text']
if 'chart' in form.cleaned_data:
bookmark.chart = form.cleaned_data['chart']
if 'tags' in form.cleaned_data:
bookmark.tags = form.cleaned_data['tags']
if 'note' in form.cleaned_data:
bookmark.note = form.cleaned_data['note']
bookmark.save()
return HttpResponseRedirect(
reverse(save_bookmark, kwargs={
"bookmark_id": bookmark.id,
}))
return render_to_response('notes/form_page.html', {'form': form},
context_instance=RequestContext(request))
def upload(request, usrid):
if request.method == "POST":
this = AudioMeta()
try:
this.name = request.POST['title']
except:
this.name = "NONE"
try:
this.user_id = User.objects.get(id=usrid)
except:
try:
this.user_id = User.objects.get(id=1)
except:
pass
this.annotations = 0
this.transcriptions = 0
this.plays = 0
this.likes = 0
if request.FILES:
this.bytes = request.FILES['file'].size
a = open("/home/leegao/webapps/notetag/notetag/audio/a.txt", "w")
a.write(str(request.FILES))
a.close()
try:
this.type = extension_re.search(
request.FILES['file'].name).group(1).lower()
except:
this.type = "wav"
this.save()
try:
marks = request.POST['marks']
for secs in [int(i.strip()) for i in marks.split(",") if i]:
m = Bookmark(aud_id=this, time=secs)
m.save()
except:
pass
handle_uploaded_file(request.FILES['file'], this.id, this.type)
else:
return HttpResponseForbidden()
return HttpResponse(content="1")
else:
form = UploadFileForm()
return render_to_response('upload.html', {
'form': form,
'usrid': usrid
})
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
b = Bookmark(url=url, description=description)
db.session.add(b)
db.session.commit()
flash("Stored '{}'".format(description))
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
bm = Bookmark(user=logged_in_user(), url=url, description=description)
db.session.add(bm)
db.session.commit()
flash("Stored bookmak '{}'.".format(description))
return redirect(url_for("index"))
return render_template("add.html", form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = request.form['url']
bm = Bookmark(user=current_user, url=url)
db.session.add(bm)
db.session.commit()
application.logger.debug('URL:' + url)
flash("Stored url: {}".format(url))
return redirect(url_for('return_200'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
db.session.add(
Bookmark(user=logged_in_user(),
url=form.obj.data,
description=form.description.data))
db.session.commit()
flash("Stored description {}".format(form.description.data))
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add_bookmark():
form = BookmarkForm()
# checks http request and form
if form.validate_on_submit():
url = form.url.data
description = form.description.data
bm = Bookmark(url=url, description=description)
db.session.add(bm)
db.session.commit()
flash(f"stored bookmark: {url}")
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
bm = Bookmark(url=url, description=description, user=current_user)
db.session.add(bm)
db.session.commit()
flash('Stored bookmark: {}'.format(url))
return redirect(url_for('index'))
return render_template('bookmark_form.html',
form=form,
title='Add Bookmark')
def add(user=None):
if 'url' not in request.form:
return jsonify(errors=[
'Dude, what\'s wrong with you ?', 'You are missing Bookmark Url'
]), 400
if not is_url_valid(request.form['url']):
return jsonify(
errors=['Dude, what\'s wrong with you ?', 'Invalid Bookmark Url'
]), 400
bookmark = Bookmark(url=request.form['url'], user=user)
if bookmark.save():
return jsonify(bookmark=bookmark.to_dict()), 200
return jsonify(errors=[bookmark.to_dict()]), 400
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()
#store_bookmark(url, description)
#app.logger.debug('stored url: ' + url)
flash("Stored '{}'".format(description))
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
bm = Bookmark(url=url, description=description, user=current_user)
db.session.add(bm)
db.session.commit()
app.logger.debug('stored url ' + url)
flash("Stored '{0}'".format(description))
return redirect(url_for('index'))
return render_template('bookmark_form.html',
form=form,
title='Add new bookmark')
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
bm = Bookmark(user=current_user, url=url, description=description)
db.session.add(bm)
db.session.commit()
# app.logger.debug("Stored url: " + url)
flash("Stored bookmark '{}'".format(description))
return redirect(url_for("index"))
return render_template("add.html", form=form)
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("Bookmark Successfully Added")
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm()
if form.validate_on_submit():
url = form.url.data
description = form.description.data
with open('test.txt', 'w') as f:
f.write(url)
f.write(description)
bm = Bookmark(user=current_user, url=url, description=description)
db.session.add(bm)
db.session.commit()
app.logger.debug('stored url: {} {}'.format(url, description))
flash("Stored '{}'".format(description))
return redirect(url_for('index'))
return render_template('add.html', form=form)
def add():
form = BookmarkForm(
) # On a GET request, the fields are empty and the form variables are also empty. On a POST request, the variables are full. This will likely only work because the action was "", as that means it referring to a still available form to read the values of
if form.validate_on_submit(
): # This line also checks to make sure the method is not GET
url = form.url.data
description = form.description.data
bm = Bookmark(user=current_user, url=url, description=description)
db.session.add(bm)
db.session.commit()
flash("Stored '{}'".format(bm.description))
return redirect(url_for('index'))
return render_template(
'bookmark_form.html', form=form, title="Add a bookmark"
) # form=form is sent because the template is actually using the form to populate the DOM with form fields
def ajax_save_bookmark(request, bookmark_id=False):
bookmark = get_object_or_None(Bookmark, pk=bookmark_id)
if request.method == "POST":
if 'chart_id' not in request.POST or 'tags' not in request.POST:
return HttpResponse(
json.dumps({
"message": {
'type': 'error',
'text': "Can't save bookmark",
},
}), 'application/json')
if not bookmark:
bookmark = Bookmark()
bookmark.save()
if 'chart_id' in request.POST:
chart = get_object_or_None(Chart, pk=request.POST['chart_id'])
if chart:
bookmark.chart = chart
if 'tags' in request.POST:
for short in request.POST['tags'].split(','):
tag = get_object_or_None(Tag, short=short)
if tag:
bookmark.tags.add(tag)
if 'note_id' in request.POST:
note = get_object_or_None(Note, pk=request.POST['note_id'])
if note:
bookmark.note = note
else:
bookmark.note = False
bookmark.save()
_bookmark = bookmark.as_json()
_bookmark['url'] = 'http://' + request.get_host() + reverse(
save_bookmark, args=(bookmark.id, ))
return HttpResponse(
json.dumps({
"message": {
'type': 'success',
'text': "Bookmark saved",
},
"bookmarks": [_bookmark],
}), 'application/json')
return HttpResponse(
json.dumps({
"message": {
'type': 'error',
'text': "Use post",
},
}), 'application/json')
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(bm.description))
return redirect(url_for('index'))
return render_template('bookmark_form.html',
form=form,
title="Add a bookmark")
def new_bookmark():
form = BookmarkForm()
if form.validate_on_submit():
b = Bookmark()
form.populate_obj(b)
b.owner_id = g.user.id
b.created = datetime.utcnow()
b.tags = ' '.join(
[t.strip() for t in form.tags.data.strip().split(',')])\
.lower()
b.clicks = 0
if not form.title.data:
soup = BSoup(urlopen(form.url.data))
b.title = soup.title.string
db.session.add(b)
db.session.commit()
flash('New bookmark %s added' % (b.title), category='info')
return redirect(url_for('index'))
return render_template('new.html', title='New', form=form)
def upload(request, usrid):
if request.method == "POST":
this = AudioMeta()
this.name = request.POST['title']
#try:
this.user_id = User.objects.get(id=usrid)
#except:
#return HttpResponseForbidden()
this.annotations = 0
this.transcriptions = 0
this.plays = 0
this.likes = 0
if request.FILES:
this.bytes = request.FILES['file'].size
try:
this.type = extension_re.search(
request.FILES['file'].name).group(1).lower()
except:
this.type = "wav"
this.save()
try:
marks = request.POST['marks']
for secs in [int(i.strip()) for i in marks.split(",")]:
m = Bookmark(aud_id=this, time=secs)
m.save()
except:
pass
handle_uploaded_file(request.FILES['file'], this.id, this.type)
else:
return HttpResponseForbidden()
return HttpResponseRedirect('/')
else:
form = UploadFileForm()
return render_to_response('upload.html', {
'form': form,
'usrid': usrid
})
def bookmark_team(team_number):
# check if logged in w/ google
if not google_auth.is_logged_in():
return (redirect(url_for("google_auth.login")))
user_info = google_auth.get_user_info()
user = User.query.filter(User.user_id == user_info["id"]).first()
bookmark = Bookmark.query.filter(Bookmark.team_number == team_number,
Bookmark.user_id == user.id).first()
if bookmark:
db.session.delete(bookmark)
db.session.commit()
else:
bookmark = Bookmark(team_number=team_number, user_id=user.id)
db.session.add(bookmark)
db.session.commit()
return (redirect(url_for("team.profile", team_number=team_number)))
True, None, None, 1)
event2 = Event(2, 'testVancouver',
to_datetime('Tue, 12 Aug 2013 17:17:17 GMT'),
to_datetime('Tue, 12 Aug 2013 18:18:18 GMT'), 49.267132,
-122.968941, True, None, "6511 Sumas Dr Burnaby,BC V5B 2V1",
1)
event3 = Event(3, 'testAustralia',
to_datetime('Tue, 12 Aug 2013 17:17:17 GMT'),
to_datetime('Tue, 12 Aug 2013 18:18:18 GMT'), -33.870943,
151.190311, True,
to_datetime('Tue, 12 Aug 2013 17:00:00 GMT'),
"Western Distributor Pyrmont NSW 2009 Australia", 1)
db_session.add_all([event1, event2, event3])
# Example locations:
bookmark1 = Bookmark(1, -33.866891, 151.200814,
'45a27fd8d56c56dc62afc9b49e1d850440d5c403', 'oneName',
'oneAddress', 'oneType', 1, None)
bookmark2 = Bookmark(2, -33.870943, 151.190311,
'30bee58f819b6c47bd24151802f25ecf11df8943', 'twoName',
'twoAddress', 'twoType', 1, 3)
db_session.add_all([bookmark1, bookmark2])
db_session.commit()
print_database()
# TODO: All of the following should go into a testing file.
"""
db_session = create_db_session()
# DELETING:
query = db_session.query(User).filter(User.userName=='admin').first()
db_session.delete(query)
def bookmarks(bookmarkID=None):
if request.method == POST:
try:
post_tripID = int(request.json['tripID'])
post_bookmarks = request.json['bookmarks']
except KeyError:
return bad_request()
db = create_db_session()
try:
trip = db.query(Trip).filter(Trip.tripID == post_tripID).first()
if trip is None:
return make_response('Trip not found.', 404)
if trip.userName != session.get(KEY__USERNAME):
return make_response(
'User not authorized to add Bookmark to this Trip.', 401)
finally:
close_session(db)
if len(post_bookmarks) == 0:
# There should be at least one Bookmark to work with.
return bad_request()
db = create_db_session()
try:
max_id = db.query(func.max(
Bookmark.bookmarkID).label('max_id')).first().max_id
if max_id is None:
max_id = 0 # No entries created yet.
bookmark_list = []
for bookmark in post_bookmarks:
max_id += 1
bookmark_list.append(
Bookmark(max_id, bookmark['lat'], bookmark['lon'],
bookmark['placeID'], bookmark['name'],
bookmark.get('address', None),
bookmark.get('type', None), post_tripID,
bookmark.get('eventID', None)))
except KeyError as ke:
close_session(db)
return bad_request(ke)
try:
db.add_all(bookmark_list)
db.commit()
bookmarks_dict = {
'bookmarks':
[bookmark.to_dict() for bookmark in bookmark_list]
}
return make_response(jsonify(bookmarks_dict), 201)
except IntegrityError:
db.rollback()
# This should not occur given that we auto increment max EventID.
# This might occur if multiple users are adding at the same time.
return make_response('Conflict - BookmarkID taken.', 409)
finally:
close_session(db)
elif request.method == GET:
post_tripID = request.args.get('tripID', None)
if post_tripID is not None:
db = create_db_session()
try:
trip = db.query(Trip).filter(
Trip.tripID == post_tripID).first()
if trip is None:
return make_response('Trip not found.', 404)
bookmark_list = db.query(Bookmark).filter(
Bookmark.tripID == post_tripID).all()
if len(bookmark_list) == 0:
return make_response(
'No Bookmarks found for the given Trip.', 404)
if trip.userName != session.get(KEY__USERNAME):
return make_response(
'User not authorized to view these Bookmarks.', 401)
bookmarks_dict = {
'bookmarks': [bm.to_dict() for bm in bookmark_list]
}
return make_response(jsonify(bookmarks_dict), 200)
finally:
close_session(db)
post_bookmarkID = request.args.get('bookmarkID', None)
if post_bookmarkID is not None:
db = create_db_session()
try:
bookmark = db.query(Bookmark).filter(
Bookmark.bookmarkID == post_bookmarkID).first()
if bookmark is None:
return make_response('Bookmark not found.', 404)
trip = db.query(Trip).filter(
Trip.tripID == bookmark.tripID).first()
if trip is None:
return make_response(
'Trip associated to given Bookmark not found.', 404)
if trip.userName != session.get(KEY__USERNAME):
return make_response(
'User not authorized to view this Bookmark.', 401)
return make_response(jsonify({'bookmark': bookmark.to_dict()}),
200)
finally:
close_session(db)
return bad_request()
elif bookmarkID:
db = create_db_session()
curr_userName = session.get(KEY__USERNAME)
bookmark = db.query(Bookmark).filter(
Bookmark.bookmarkID == bookmarkID).first()
if bookmark is None:
close_session(db)
return make_response('Bookmark not found.', 404)
trip = db.query(Trip).filter(Trip.tripID == bookmark.tripID).first()
if trip is None:
close_session(db)
return make_response('Trip for given Bookmark not found.', 404)
userName = trip.userName
if request.method == DELETE:
if userName != curr_userName:
close_session(db)
return make_response('User not authorized to delete Bookmark.',
401)
db.delete(bookmark)
close_session(db)
return make_response('Bookmark deleted successfully', 200)
return bad_request()
