def validate_pagination_params(page, per_page, order):
order = str(order).strip().upper()
ensure(str(order).upper() in ["ASC", "DESC"], "unknown ordering %r" % order)
ensure(all(map(utils.isint, [page, per_page])), "'page' and 'per-page' must be integers")
return page, per_page, order
def add(art, event, value=None, datetime_event=None):
utils.ensure(art, "need art")
datetime_event = datetime_event or utils.utcnow()
struct = {
'event': event,
'value': str(value),
'datetime_event': datetime_event
}
create = update = True
ae, created, updated = \
create_or_update(models.ArticleEvent, struct, ['article', 'event', 'datetime_event'], create, update, article=art)
return ae
def slurp(msid):
"download the article page for a given elife doi, write content to disk"
if os.path.exists(fname(msid)):
return
doi = "10.7554/eLife.%s" % str(msid).zfill(5)
# ll: https://elifesciences.org/lookup/doi/10.7554/eLife.17267
url = "https://elifesciences.org/lookup/doi/" + doi
LOG.debug(url)
resp = requests.get(url, allow_redirects=False)
ensure(resp.status_code != 404, "404 fetching article: %s" % resp.status_code)
art_info_url = resp.headers['Location'] + "/article-info"
resp2 = requests.get(art_info_url)
with open(fname(msid), 'wb') as handle:
handle.write(resp2.content)
def associate(av, citation):
ensure(
isinstance(citation, dict) and 'uri' in citation,
"expecting a valid external-link type citation, got: %r" % citation)
data = {
'articleversion': av,
'uri': citation['uri'],
'citation': citation,
}
key = ['articleversion', 'uri']
avr, _, _ = create_or_update(models.ArticleVersionExtRelation,
data,
key,
create=True,
update=True)
return avr
def latest_article_versions(page=1, per_page=-1, order='DESC', only_published=True):
"returns a list of the most recent article versions for all articles."
order = str(order).strip().upper()
ensure(str(order).upper() in ['ASC', 'DESC'], "unknown ordering %r" % order)
order_by = 'datetime_published'
ensure(all(map(utils.isint, [page, per_page])), "'page' and 'per-page' must be integers")
# sql limit+offset rules
limit = per_page
offset = per_page * (page - 1)
# python slicing rules
start = (page - 1) * per_page
end = start + per_page
if only_published:
sql = """
SELECT
pav.id, pav.article_id, pav.title, pav.version, pav.status, pav.datetime_published,
pav.datetime_record_created, pav.datetime_record_updated
FROM publisher_articleversion pav,
(SELECT pav2.article_id,
max(version) AS max_ver
FROM publisher_articleversion pav2
WHERE datetime_published IS NOT NULL
GROUP BY pav2.article_id) as pav2
WHERE
pav.article_id = pav2.article_id AND pav.version = pav2.max_ver
ORDER BY %s %s""" % (order_by, order)
if per_page > 0:
sql += """
LIMIT %s
OFFSET %s""" % (limit, offset)
# quotes parameters :(
#rq = models.ArticleVersion.objects.raw(sql, [order_by])
q = models.ArticleVersion.objects.raw(sql)
# print q.query
# print [(v.article.manuscript_id, v.datetime_published) for v in q]
return list(q)
# this query only works if we're not excluding unpublished articles.
# the max() function doesn't obey the filtering rules
if order is 'DESC':
order_by = '-' + order_by
q = models.ArticleVersion.objects \
.select_related('article') \
.annotate(max_version=Max('article__articleversion__version')) \
.filter(version=F('max_version')) \
.order_by(order_by)
if per_page > 0:
q = q[start:end]
return list(q)
def validate_pagination_params(page, per_page, order):
order = str(order).strip().upper()
# TODO: necessary? this duplicates api_v2_views.request_args a bit ...
ensure(str(order).upper() in ['ASC', 'DESC'], "unknown ordering, expecting either 'asc' or 'desc'")
ensure(all(map(utils.isint, [page, per_page])), "'page' and 'per-page' must be integers")
return page, per_page, order
