def get_publication_vals(pub, include_articles, add_type=False):
"""Extract public fields from a Publication record."""
vals = {
"pub_id":
pub.pub_id,
"pub_name":
pub.pub_name,
"pub_edition":
pub.pub_edition,
"pub_date":
pub.pub_date,
"pub_description":
pub.pub_description,
"pub_url":
pub.pub_url,
"pub_seqno":
pub.pub_seqno,
"pub_image_id":
pub.pub_id if pub.pub_image else None,
"pub_tags":
decode_tags(pub.pub_tags),
"publ_id":
pub.publ_id,
"time_created":
int(pub.time_created.timestamp()) if pub.time_created else None,
}
if include_articles:
articles = sorted(pub.articles, key=get_article_sort_key)
vals["articles"] = [get_article_vals(a) for a in articles]
if add_type:
vals["type"] = "publication"
return vals
def create_publication():
"""Create a publication."""
# parse the input
vals = get_request_args(request.json,
_FIELD_NAMES,
log=(_logger, "Create publication:"))
warnings = []
updated = clean_request_args(vals, _FIELD_NAMES, warnings, _logger)
# NOTE: Tags are stored in the database using \n as a separator, so we need to encode *after* cleaning them.
cleaned_tags = clean_tags(vals.get("pub_tags"), warnings)
vals["pub_tags"] = encode_tags(cleaned_tags)
if cleaned_tags != vals.get("pub_tags"):
updated["pub_tags"] = decode_tags(vals["pub_tags"])
# create the new publication
vals["time_created"] = datetime.datetime.now()
pub = Publication(**vals)
db.session.add(pub)
_set_seqno(pub, pub.publ_id)
_save_image(pub, updated)
db.session.commit()
_logger.debug("- New ID: %d", pub.pub_id)
search.add_or_update_publication(None, pub, None)
# generate the response
extras = {"pub_id": pub.pub_id}
if request.args.get("list"):
extras["publications"] = do_get_publications()
extras["tags"] = do_get_tags()
return make_ok_response(updated=updated, extras=extras, warnings=warnings)
def get_publication_vals(pub, include_articles, deep):
"""Extract public fields from a Publication record."""
vals = {
"_type":
"publication",
"pub_id":
pub.pub_id,
"pub_name":
pub.pub_name,
"pub_edition":
pub.pub_edition,
"pub_date":
pub.pub_date,
"pub_description":
pub.pub_description,
"pub_url":
pub.pub_url,
"pub_seqno":
pub.pub_seqno,
"pub_image_id":
pub.pub_id if pub.pub_image else None,
"pub_tags":
decode_tags(pub.pub_tags),
"publ_id":
pub.publ_id,
"time_created":
int(pub.time_created.timestamp()) if pub.time_created else None,
}
if include_articles:
articles = sorted(pub.articles, key=get_article_sort_key)
vals["articles"] = [get_article_vals(a, False) for a in articles]
if deep:
vals["_parent_publ"] = asl_articles.publishers.get_publisher_vals(
pub.parent_publ, False, False) if pub.parent_publ else None
return vals
def update_publication():
"""Update a publication."""
# parse the input
pub_id = request.json["pub_id"]
vals = get_request_args(request.json,
_FIELD_NAMES,
log=(_logger,
"Update publication: id={}".format(pub_id)))
warnings = []
updated = clean_request_args(vals, _FIELD_NAMES, warnings, _logger)
article_order = request.json.get("article_order")
# NOTE: Tags are stored in the database using \n as a separator, so we need to encode *after* cleaning them.
cleaned_tags = clean_tags(vals.get("pub_tags"), warnings)
vals["pub_tags"] = encode_tags(cleaned_tags)
if cleaned_tags != vals.get("pub_tags"):
updated["pub_tags"] = decode_tags(vals["pub_tags"])
# update the publication
pub = Publication.query.get(pub_id)
if not pub:
abort(404)
if vals["publ_id"] != pub.publ_id:
_set_seqno(pub, vals["publ_id"])
vals["time_updated"] = datetime.datetime.now()
apply_attrs(pub, vals)
_save_image(pub, updated)
if article_order:
query = Article.query.filter(Article.pub_id == pub_id)
articles = {int(a.article_id): a for a in query}
for n, article_id in enumerate(article_order):
if article_id not in articles:
_logger.warning(
"Can't set seq# for article %d, not in publication %d: %s",
article_id, pub_id, article_order)
continue
articles[article_id].article_seqno = n
del articles[article_id]
if articles:
_logger.warning(
"seq# was not set for some articles in publication %d: %s",
pub_id, ", ".join(str(k) for k in articles))
db.session.commit()
search.add_or_update_publication(None, pub, None)
# generate the response
extras = {}
if request.args.get("list"):
extras["publications"] = do_get_publications()
extras["tags"] = do_get_tags()
return make_ok_response(updated=updated, extras=extras, warnings=warnings)
def update_article():
"""Update an article."""
# parse the input
article_id = request.json["article_id"]
vals = get_request_args(request.json,
_FIELD_NAMES,
log=(_logger,
"Update article: id={}".format(article_id)))
warnings = []
updated = clean_request_args(vals, _FIELD_NAMES, warnings, _logger)
# NOTE: Tags are stored in the database using \n as a separator, so we need to encode *after* cleaning them.
cleaned_tags = clean_tags(vals.get("article_tags"), warnings)
vals["article_tags"] = encode_tags(cleaned_tags)
if cleaned_tags != vals.get("article_tags"):
updated["article_tags"] = decode_tags(vals["article_tags"])
# update the article
article = Article.query.get(article_id)
if not article:
abort(404)
orig_pub = Publication.query.get(
article.pub_id) if article.pub_id else None
if vals["pub_id"] != article.pub_id:
_set_seqno(article, vals["pub_id"])
vals["time_updated"] = datetime.datetime.now()
apply_attrs(article, vals)
_save_authors(article, updated)
_save_scenarios(article, updated)
_save_image(article, updated)
db.session.commit()
search.add_or_update_article(None, article, None)
# generate the response
extras = {}
if request.args.get("list"):
extras["authors"] = do_get_authors()
extras["scenarios"] = do_get_scenarios()
extras["tags"] = do_get_tags()
pubs = []
if orig_pub and orig_pub.pub_id != article.pub_id:
pubs.append(
asl_articles.publications.get_publication_vals(orig_pub, True))
if article.pub_id:
pub = Publication.query.get(article.pub_id)
pubs.append(
asl_articles.publications.get_publication_vals(pub, True))
if pubs:
extras["_publications"] = pubs
return make_ok_response(updated=updated, extras=extras, warnings=warnings)
def create_article():
"""Create an article."""
# parse the input
vals = get_request_args(request.json,
_FIELD_NAMES,
log=(_logger, "Create article:"))
warnings = []
updated = clean_request_args(vals, _FIELD_NAMES, warnings, _logger)
# NOTE: Tags are stored in the database using \n as a separator, so we need to encode *after* cleaning them.
cleaned_tags = clean_tags(vals.get("article_tags"), warnings)
vals["article_tags"] = encode_tags(cleaned_tags)
if cleaned_tags != vals.get("article_tags"):
updated["article_tags"] = decode_tags(vals["article_tags"])
# create the new article
vals["time_created"] = datetime.datetime.now()
article = Article(**vals)
db.session.add(article)
db.session.flush()
new_article_id = article.article_id
_set_seqno(article, article.pub_id)
_save_authors(article, updated)
_save_scenarios(article, updated)
_save_image(article, updated)
db.session.commit()
_logger.debug("- New ID: %d", new_article_id)
search.add_or_update_article(None, article, None)
# generate the response
extras = {"article_id": new_article_id}
if request.args.get("list"):
extras["authors"] = do_get_authors()
extras["scenarios"] = do_get_scenarios()
extras["tags"] = do_get_tags()
if article.pub_id:
pub = Publication.query.get(article.pub_id)
extras[
"_publication"] = asl_articles.publications.get_publication_vals(
pub, True)
return make_ok_response(updated=updated, extras=extras, warnings=warnings)
def get_article_vals(article, deep):
"""Extract public fields from an Article record."""
authors = sorted(article.article_authors, key=lambda a: a.seq_no)
scenarios = sorted(article.article_scenarios, key=lambda a: a.seq_no)
vals = {
"_type":
"article",
"article_id":
article.article_id,
"article_title":
article.article_title,
"article_subtitle":
article.article_subtitle,
"article_image_id":
article.article_id if article.article_image else None,
"article_authors": [get_author_vals(a.parent_author) for a in authors],
"article_date":
article.article_date,
"article_snippet":
article.article_snippet,
"article_pageno":
article.article_pageno,
"article_url":
article.article_url,
"article_scenarios":
[get_scenario_vals(s.parent_scenario) for s in scenarios],
"article_tags":
decode_tags(article.article_tags),
"article_rating":
article.article_rating,
"pub_id":
article.pub_id,
"publ_id":
article.publ_id,
}
if deep:
vals["_parent_pub"] = asl_articles.publications.get_publication_vals(
article.parent_pub, False, False) if article.parent_pub else None
vals["_parent_publ"] = asl_articles.publishers.get_publisher_vals(
article.parent_publ, False, False) if article.parent_publ else None
return vals
def get_article_vals(article, add_type=False):
"""Extract public fields from an Article record."""
authors = sorted(article.article_authors, key=lambda a: a.seq_no)
scenarios = sorted(article.article_scenarios, key=lambda a: a.seq_no)
vals = {
"article_id": article.article_id,
"article_title": article.article_title,
"article_subtitle": article.article_subtitle,
"article_image_id":
article.article_id if article.article_image else None,
"article_authors": [a.author_id for a in authors],
"article_snippet": article.article_snippet,
"article_pageno": article.article_pageno,
"article_url": article.article_url,
"article_scenarios": [s.scenario_id for s in scenarios],
"article_tags": decode_tags(article.article_tags),
"article_rating": article.article_rating,
"pub_id": article.pub_id,
}
if add_type:
vals["type"] = "article"
return vals
def _get_tags(tags):
"""Return the searchable tags for an article or publication."""
if not tags:
return None
tags = decode_tags(tags)
return "\n".join(tags)
def count_tags(query):
for row in query:
if not row[0]:
continue
for tag in decode_tags(row[0]):
tags[tag] = tags[tag] + 1
