def restore_bookmark(request, bookmark_id): # Moves back to bookmarks!
print(bookmark_id)
current = Trash.objects.get(id=bookmark_id)
bookmarks = Bookmark.objects.filter(category=current.category)
row_number = get_max_row_number(bookmarks) + 1
bookmark = Bookmark(category=current.category, name=current.name, link=current.link,
row_number=row_number, glyphicon=current.glyphicon)
bookmark.save()
current.delete()
return HttpResponseRedirect('/b/trash')
def import_db_from_json():
"""Imports a collection of links from a 'db.json' file (DESTRUCTIVE)."""
app.logger.info(app.config.get('SQLALCHEMY_DATABASE_URI'))
with open('db.json') as f:
if prompt_bool("May I import links from 'db.json'"):
app.logger.info('dropping all tables...')
db.drop_all()
app.logger.info('creating all tables...')
db.create_all()
content = json.load(f)
app.logger.info('importing users...')
if 'users' in content:
for u in content['users']:
user = User(email=u['email'])
g.user = user
user.locale = u.get('locale', '')
user.timezone = u.get('timezone', '')
user.is_active = u.get('is_active', True)
db.session.add(user)
db.session.commit()
app.logger.info('importing tags...')
tags = []
for t in content.get('links', []):
tagname = t.get('tag', '')
if not tagname in tags:
tags.append(tagname)
for tagname in tags:
tag = Tag.query.filter_by(name=tagname).first()
if tag is None:
try:
tag = Tag(name=tagname)
db.session.add(tag)
except Exception, e:
app.logger.error('error creating tag "%s"' % e)
continue
db.session.commit()
app.logger.info('importing bookmarks...')
for l in content.get('links', []):
link = Bookmark(name=l['name'], url=l['url'])
link.menu = l.get('menu', None)
link.public = l.get('public', False)
link.clicks = l.get('clicks', 0)
if 'user_email' in l:
user = User.query.filter_by(email=l['user_email']).first()
link.user_id = user.id
# for tagname in l.get('tags', []):
tagname = l.get('tag', '')
tag = Tag.query.filter_by(name=tagname).first()
link.tags.append(tag)
db.session.add(link)
db.session.commit()
def add_bookmark(request, category_id):
category = Category.objects.get(id=category_id)
bookmarks = Bookmark.objects.filter(category=category)
name = request.POST['name']
link = request.POST['link']
row_number = get_max_row_number(bookmarks) + 1
bookmark = Bookmark(category=category, name=name, link=link, row_number=row_number, glyphicon='')
bookmark.save()
return HttpResponseRedirect('/b/edit')
def bookmark(request, school_id):
latitude, longitude, has_coordinate = utils.get_coordinate_from_request(
request)
user = request.user
school = get_object_or_404(SecondarySchoolProxy, id=school_id)
new_bookmark = Bookmark(user=user, school=school)
new_bookmark.save()
if has_coordinate:
redirect_url = '{}?latitude={}&longitude={}'.format(
reverse('app:school_list'), latitude, longitude)
else:
redirect_url = reverse('app:school_list')
return HttpResponseRedirect(redirect_url)
def add_bookmark(request, category_id):
category = Category.objects.get(id=category_id)
bookmarks = Bookmark.objects.filter(category=category)
name = request.POST['name']
link = request.POST['link']
row_number = get_max_row_number(bookmarks) + 1
bookmark = Bookmark(category=category,
name=name,
link=link,
row_number=row_number,
glyphicon='')
bookmark.save()
return HttpResponseRedirect('/b/edit')
def add_ten_random_bookmarks(request):
categories = list(Category.objects.filter(user=request.user))
if categories == []:
# Give a message perhaps??
return HttpResponseRedirect('/b/edit')
for _ in range(10):
category = random.choice(categories)
raw_name = list(string.ascii_lowercase)
random.shuffle(raw_name)
name = ''.join(raw_name[:6])
row_number = get_max_row_number(Bookmark.objects.filter(category=category)) + 1
if random.random() < 0.1:
glyphicon = random.choice(constants.GLYPHICONS)
else:
glyphicon = ''
bookmark = Bookmark(category=category, name=name, link=name, row_number=row_number, glyphicon=glyphicon)
bookmark.save()
return HttpResponseRedirect('/b/edit')
def AddBookmark():
url = request.args.get('url')
title = request.args.get('title')
bookmark = Bookmark(title=title,
link=url,
owner=User.query.get(current_user.id))
db.session.add(bookmark)
db.session.commit()
return redirect(url)
def bookmark(book_id):
if Bookmark.query.filter_by(user_id=current_user.get_id(),
book_id=int(book_id)).first() is None:
bookmark = Bookmark(user_id=current_user.get_id(),
book_id=int(book_id))
db.session.add(bookmark)
db.session.commit()
return redirect(url_for('show_book', book_id=book_id))
def bookmark(bk, chp, vrs):
currVersion = text.getCurrentVersion()
bookmark = Bookmark(book=bk, chapter=chp, verses=vrs, version=currVersion,
author=current_user)
db.session.add(bookmark)
db.session.commit()
flash('Your bookmark is now saved!')
text2 = text.displayText(bk, int(chp), int(vrs))
verses2 = text2[2]
return render_template('index.html', title=_('Home'),text=text2,
verses=verses2, bookmark=1, vrs=int(vrs))
def add_starter_bookmarks(request):
old_categories = Category.objects.filter(user=request.user)
for category in old_categories:
category.delete()
# Delete or not?
for (name, column_number, row_number, progress_bar_color) in predefined_category_details:
category = Category(user=request.user, name=name, column_number=column_number,
row_number=row_number, progress_bar_color=progress_bar_color)
category.save()
categories = Category.objects.filter(user=request.user)
for category_name in predefined_category_names:
category = categories.filter(name=category_name)[0]
for (name, link, row_number, glyphicon) in predefined_bookmarks[category_name]:
bookmark = Bookmark(category=category, name=name, link=link, row_number=row_number, glyphicon=glyphicon)
bookmark.save()
return HttpResponseRedirect('/b/')
def add():
# if get, form is empty, but if post, form has data
form = BookmarkForm()
# if request.method == "POST":
if form.validate_on_submit():
# url = request.form['url']
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 {0}'.format(description))
return redirect(url_for('index'))
return render_template("add.html", form=form)
def bookmark(idd):
#check if user has bookmarked before and unbookmark
check_user = Bookmark.query.filter(
Bookmark.blogpost_bookmarks.has(id=int(idd)))
for user in check_user:
if user.user_bookmark.name == current_user.name:
db.session.delete(user)
db.session.commit()
flash("Removed from bookmarks")
return redirect(url_for("main.blog", idd=idd))
get_blog = Blogpost.query.get(int(idd))
new_bookmark = Bookmark(user_bookmark=current_user,
blogpost_bookmarks=get_blog)
db.session.add(new_bookmark)
db.session.commit()
flash("Bookmarked!")
return redirect(url_for("main.blog", idd=idd))
def add_bookmark_from_dict(bookmark_dictionary):
'''
Import data from dictionary to db
---------------------------------
Accepted keys:
dict['url']
dict['title']
dict['description']
dict['date'] / datetime object
dict['tags'] / ["tag 1", "tag 2", "tag 3"]
'''
new_bookmark = Bookmark(url=bookmark_dictionary.get('url'),
title=bookmark_dictionary.get('title'),
description=bookmark_dictionary.get('description'),
date=bookmark_dictionary.get('date'))
db.session.add(new_bookmark)
for t in bookmark_dictionary.get('tags') or []:
tag = fetch_or_add_tag(t)
new_bookmark.tags.append(tag)
db.session.commit()
def corpus_bookmark(corpus_id):
token = request.args.get("token_id", None)
page = request.args.get("page", None)
if token and page:
bm = Bookmark.mark(corpus_id, current_user.id, token, page)
link = "{uri}#token_{token}_row".format(
uri=url_for("main.tokens_correct", corpus_id=corpus_id, page=bm.page),
token=bm.token_id
)
else:
bm = Corpus.query.get_or_404(corpus_id).get_bookmark(current_user)
if bm:
link = "{uri}#token_{token}_row".format(
uri=url_for("main.tokens_correct", corpus_id=corpus_id, page=bm.page),
token=bm.token_id
)
else:
flash("No bookmark found for this corpus on your account", category="warning")
link = url_for("main.tokens_correct", corpus_id=corpus_id)
return redirect(link)
def index():
# render_template will look in templates folder by default
return render_template("index.html", new_bookmarks=Bookmark.newest(5))
def save_bookmark(q, title, url):
bookmark = Bookmark(title=title, url=url, user_id=current_user.id)
db.session.add(bookmark)
db.session.commit()
flash(f'Bookmark Saved with Title: "{title}"')
return redirect(url_for('main.search_pub', q=q))
def new_bookmark():
bookmark = Bookmark.from_json(request.json)
db.session.add(bookmark)
db.session.commit()
return jsonify(bookmark.to_json()), 201, \
{"Location": url_for("api.get_bookmark", id=bookmark.id, _external=True)}
