def edit_bookmark(username: str, url_uuid: UUID) -> flask.Response:
owner = get_user_or_fail(db.session, username)
require_access_or_fail(
BookmarkAccessObject(user_uuid=owner.user_uuid, url_uuid=url_uuid),
Access.WRITE,
)
form = flask.request.form
existing_bookmark = get_bookmark_by_url_uuid(db.session, owner.user_uuid,
url_uuid)
if existing_bookmark is None:
raise exc.NotFound()
updated_bookmark = Bookmark(
url=existing_bookmark.url,
created=existing_bookmark.created,
title=form["title"],
description=form["description"],
unread="unread" in form,
deleted="deleted" in form,
updated=datetime.utcnow().replace(tzinfo=timezone.utc),
tag_triples=tag_triples_from_form(
form, current=existing_bookmark.tag_triples),
)
merged_bookmark = updated_bookmark.merge(existing_bookmark)
set_bookmark(db.session, get_cache(), owner.user_uuid, merged_bookmark)
db.session.commit()
flask.flash("Edited: %s" % merged_bookmark.title)
return flask.make_response("ok")
def sync() -> flask.Response:
extension_version = flask.request.headers.get(
"Quarchive-Extension-Version", "unknown"
)
log.debug("extension version: %s", extension_version)
user = get_current_user()
use_jsonlines = flask.request.headers["Content-Type"] != "application/json"
if not use_jsonlines:
log.warning("sync request using deprecated single json object")
body = flask.request.json
recieved_bookmarks = (Bookmark.from_json(item) for item in body["bookmarks"])
else:
log.info("sync request using jsonlines")
recieved_bookmarks = (
Bookmark.from_json(json.loads(l)) for l in flask.request.stream.readlines()
)
try:
changed_bookmarks = merge_bookmarks(
db.session, user.user_uuid, recieved_bookmarks
)
except BadCanonicalisationException as e:
log.error(
"bad canonicalised url ('%s') from version %s, user %s",
e.url_string,
extension_version,
user,
)
db.session.rollback()
flask.abort(400, "bad canonicalisation on url: %s" % e.url_string)
db.session.commit()
if "full" in flask.request.args:
response_bookmarks = all_bookmarks(db.session, get_current_user().user_uuid)
else:
response_bookmarks = changed_bookmarks
# If we got JSON, send json back
if not use_jsonlines:
return flask.json.jsonify(
{"bookmarks": [b.to_json() for b in response_bookmarks]}
)
else:
def generator():
for b in response_bookmarks:
yield json.dumps(b.to_json())
yield "\n"
return flask.Response(
flask.stream_with_context(generator()), mimetype="application/x-ndjson",
)
def bookmark_from_sqla(url: URL, sqla_obj: SQLABookmark) -> Bookmark:
return Bookmark(
url=url,
created=sqla_obj.created,
description=sqla_obj.description,
updated=sqla_obj.updated,
unread=sqla_obj.unread,
deleted=sqla_obj.deleted,
title=sqla_obj.title,
tag_triples=frozenset(
(btag.tag_obj.tag_name, btag.updated, btag.deleted)
for btag in sqla_obj.bookmark_tag_objs),
)
def create_bookmark(username: str) -> flask.Response:
owner = get_user_or_fail(db.session, username)
# FIXME: sort out optional url_uuid
require_access_or_fail(
UserBookmarksAccessObject(user_uuid=owner.user_uuid),
Access.WRITE,
)
form = flask.request.form
creation_time = datetime.utcnow().replace(tzinfo=timezone.utc)
tag_triples = tag_triples_from_form(form)
url_str = form["url"]
try:
# As it's a user entering this url, help them along with getting a
# sufficiently canonicalised url
url = URL.from_string(url_str, coerce_canonicalisation=True)
except DisallowedSchemeException:
log.warning("user tried to create url: %s (disallowed scheme)",
url_str)
flask.abort(400, "invalid url (disallowed scheme)")
bookmark = Bookmark(
url=url,
title=form["title"],
description=form["description"],
unread="unread" in form,
deleted=False,
updated=creation_time,
created=creation_time,
tag_triples=tag_triples,
)
url_uuid = set_bookmark(db.session, get_cache(), owner.user_uuid, bookmark)
db.session.commit()
publish_message(
message_lib.BookmarkCreated(user_uuid=owner.user_uuid,
url_uuid=url.url_uuid),
environ["QM_RABBITMQ_BG_WORKER_TOPIC"],
)
flask.flash("Bookmarked: %s" % bookmark.title)
response = flask.make_response("Redirecting...", 303)
response.headers["Location"] = flask.url_for(
"quarchive.edit_bookmark_form",
url_uuid=url_uuid,
username=owner.username,
)
return response
def create_bookmark() -> flask.Response:
form = flask.request.form
creation_time = datetime.utcnow().replace(tzinfo=timezone.utc)
tag_triples = tag_triples_from_form(form)
bookmark = Bookmark(
url=URL.from_string(form["url"]),
title=form["title"],
description=form["description"],
unread="unread" in form,
deleted=False,
updated=creation_time,
created=creation_time,
tag_triples=tag_triples,
)
url_uuid = set_bookmark(db.session, get_current_user().user_uuid, bookmark)
db.session.commit()
flask.flash("Bookmarked: %s" % bookmark.title)
response = flask.make_response("Redirecting...", 303)
response.headers["Location"] = flask.url_for(
"quarchive.edit_bookmark_form", url_uuid=url_uuid
)
return response
def sync(current_user: User) -> Tuple[flask.Response, int]:
start_time = datetime.utcnow()
extension_version = flask.request.headers.get(
"Quarchive-Extension-Version", "unknown"
)
log.debug("extension version: %s", extension_version)
user_uuid = current_user.user_uuid
use_jsonlines = flask.request.headers["Content-Type"] != "application/json"
if not use_jsonlines:
log.warning("sync request using deprecated single json object")
body = flask.request.json
recieved_bookmarks = (Bookmark.from_json(item) for item in body["bookmarks"])
else:
log.info("sync request using jsonlines")
recieved_bookmarks = (
Bookmark.from_json(json.loads(l)) for l in flask.request.stream.readlines()
)
try:
merge_result = merge_bookmarks(db.session, user_uuid, recieved_bookmarks)
except BadCanonicalisationException as e:
log.error(
"bad canonicalised url ('%s') from version %s, user %s",
e.url_string,
extension_version,
current_user,
)
db.session.rollback()
flask.abort(400, "bad canonicalisation on url: %s" % e.url_string)
db.session.commit()
for added in merge_result.added:
publish_message(
message_lib.BookmarkCreated(
user_uuid=user_uuid, url_uuid=added.url.url_uuid
),
environ["QM_RABBITMQ_BG_WORKER_TOPIC"],
)
is_full_sync = "full" in flask.request.args
if is_full_sync:
response_bookmarks = all_bookmarks(db.session, current_user.user_uuid)
else:
response_bookmarks = merge_result.changed
# If we got JSON, send json back
if not use_jsonlines:
return flask.json.jsonify(
{"bookmarks": [b.to_json() for b in response_bookmarks]}
)
else:
def generator():
for b in response_bookmarks:
yield json.dumps(b.to_json())
yield "\n"
if is_full_sync:
duration = datetime.utcnow() - start_time
log.info(
"completed full sync for %s in %ds",
current_user.username,
duration.total_seconds(),
)
return (
flask.Response(
flask.stream_with_context(generator()), mimetype="application/x-ndjson",
),
200,
)