Coverage for portality/view/admin.py: 42%
746 statements
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 13:43 +0000
« prev ^ index » next coverage.py v7.17.3, created at 2026-11-20 13:43 +0000
1import json, re
2from collections import namedtuple
3from typing import Iterable, List
5from flask import Blueprint, request, flash, abort, make_response
6from flask import render_template, redirect, url_for, send_file
7from flask_login import current_user, login_required
8from werkzeug.datastructures import MultiDict
10from portality import models
11from portality import constants
12from portality import dao
13from portality import lock
14from portality.background import BackgroundSummary
15from portality.bll import DOAJ, exceptions
16from portality.bll.exceptions import ArticleMergeConflict, DuplicateArticleException
17from portality.bll.services.query import Query
18from portality.core import app
19from portality.crosswalks.application_form import ApplicationFormXWalk
20from portality.decorators import ssl_required, restrict_to_role, write_required
21from portality.forms.application_forms import ApplicationFormFactory, application_statuses
22from portality.forms.application_forms import JournalFormFactory
23from portality.forms.article_forms import ArticleFormFactory
24from portality.lcc import lcc_jstree
25from portality.lib.query_filters import remove_search_limits, update_request, not_update_request
26from portality.models import Journal
27from portality.tasks import journal_in_out_doaj, journal_bulk_edit, suggestion_bulk_edit, journal_bulk_delete, \
28 article_bulk_delete, admin_reports
29from portality.tasks.journal_in_out_doaj import find_matching_issns_in_doaj
30from portality.ui.messages import Messages
31from portality.ui import templates
32from portality.util import flash_with_url, jsonp, make_json_resp, get_web_json_payload, validate_json
33from portality.view.forms import EditorGroupForm, MakeContinuation
34from portality.view.view_helper import exparam_editing_user
36# ~~Admin:Blueprint~~
37blueprint = Blueprint('admin', __name__)
40# restrict everything in admin to logged in users with the "admin" role
41@blueprint.before_request
42def restrict():
43 return restrict_to_role('admin')
46# build an admin page where things can be done
47@blueprint.route('/')
48@login_required
49@ssl_required
50def index():
51 return render_template(templates.ADMIN_JOURNALS_SEARCH, admin_page=True)
54@blueprint.route("/status")
55@login_required
56@ssl_required
57def status_ui():
58 return render_template(templates.ADMIN_STATUS)
60@blueprint.route("/journals", methods=["GET"])
61@login_required
62@ssl_required
63def journals():
64 qs = request.query_string
65 target = url_for("admin.index")
66 if qs:
67 target += "?" + qs.decode()
68 return redirect(target)
71@blueprint.route("/journals", methods=["POST", "DELETE"])
72@login_required
73@ssl_required
74@write_required()
75@jsonp
76def journals_list():
77 if request.method == "POST":
78 try:
79 query = json.loads(request.values.get("q"))
80 except:
81 app.logger.warning("Bad Request at admin/journals: " + str(request.values.get("q")))
82 abort(400)
84 # get the total number of journals to be affected
85 jtotal = models.Journal.hit_count(query, consistent_order=False)
87 # get the total number of articles to be affected
88 issns = models.Journal.issns_by_query(query)
89 atotal = models.Article.count_by_issns(issns)
91 resp = make_response(json.dumps({"journals": jtotal, "articles": atotal}))
92 resp.mimetype = "application/json"
93 return resp
95 elif request.method == "DELETE":
96 if not current_user.has_role("delete_article"):
97 abort(401)
99 try:
100 query = json.loads(request.data)
101 except:
102 app.logger.warning("Bad Request at admin/journals: " + str(request.data))
103 abort(400)
105 # get only the query part
106 query = {"query": query.get("query")}
107 models.Journal.delete_selected(query=query, articles=True, snapshot_journals=True, snapshot_articles=True)
108 resp = make_response(json.dumps({"status": "success"}))
109 resp.mimetype = "application/json"
110 return resp
113@blueprint.route("/articles", methods=["POST", "DELETE"])
114@login_required
115@ssl_required
116@write_required()
117@jsonp
118def articles_list():
119 if request.method == "POST":
120 try:
121 query = json.loads(request.values.get("q"))
122 except:
123 print(request.values.get("q"))
124 abort(400)
125 total = models.Article.hit_count(query, consistent_order=False)
126 resp = make_response(json.dumps({"total": total}))
127 resp.mimetype = "application/json"
128 return resp
129 elif request.method == "DELETE":
130 if not current_user.has_role("delete_article"):
131 abort(401)
133 try:
134 query = json.loads(request.data)
135 except:
136 app.logger.warning("Bad Request at admin/journals: " + str(request.data))
137 abort(400)
139 # get only the query part
140 query = {"query": query.get("query")}
141 models.Article.delete_selected(query=query, snapshot=True)
142 resp = make_response(json.dumps({"status": "success"}))
143 resp.mimetype = "application/json"
144 return resp
147@blueprint.route("/delete/article/<article_id>", methods=["POST"])
148@login_required
149@ssl_required
150@write_required()
151def article_endpoint(article_id):
152 if not current_user.has_role("delete_article"):
153 abort(401)
154 a = models.Article.pull(article_id)
155 if a is None:
156 abort(404)
157 delete = request.values.get("delete", "false")
158 if delete != "true":
159 abort(400)
160 a.snapshot()
161 a.delete()
162 # return a json response
163 resp = make_response(json.dumps({"success": True}))
164 resp.mimetype = "application/json"
165 return resp
168@blueprint.route("/article/<article_id>", methods=["GET", "POST"])
169@login_required
170@ssl_required
171@write_required()
172def article_page(article_id):
173 if not current_user.has_role("edit_article"):
174 abort(401)
175 ap = models.Article.pull(article_id)
176 if ap is None:
177 abort(404)
179 fc = ArticleFormFactory.get_from_context(role="admin", source=ap, user=current_user)
180 if request.method == "GET":
181 return fc.render_template()
183 elif request.method == "POST":
184 user = current_user._get_current_object()
185 fc = ArticleFormFactory.get_from_context(role="admin", source=ap, user=user, form_data=request.form)
187 fc.modify_authors_if_required(request.values)
189 if fc.validate():
190 try:
191 fc.finalise()
192 except ArticleMergeConflict:
193 Messages.flash(Messages.ARTICLE_METADATA_MERGE_CONFLICT)
194 except DuplicateArticleException:
195 Messages.flash(Messages.ARTICLE_METADATA_UPDATE_CONFLICT)
197 return fc.render_template()
200@blueprint.route("/journal/<journal_id>", methods=["GET", "POST"])
201@login_required
202@ssl_required
203@write_required()
204def journal_page(journal_id):
205 # ~~JournalForm:Page~~
206 auth_svc = DOAJ.authorisationService()
207 journal_svc = DOAJ.journalService()
209 journal, _ = journal_svc.journal(journal_id)
210 if journal is None:
211 abort(404)
213 try:
214 auth_svc.can_edit_journal(current_user._get_current_object(), journal)
215 except exceptions.AuthoriseException:
216 abort(401)
218 # attempt to get a lock on the object
219 try:
220 lockinfo = lock.lock(constants.LOCK_JOURNAL, journal_id, current_user.id)
221 except lock.Locked as l:
222 return render_template(templates.JOURNAL_LOCKED, journal=journal, lock=l.lock)
224 fc = JournalFormFactory.context("admin", extra_param=exparam_editing_user())
225 autochecks = models.Autocheck.for_journal(journal_id)
227 if request.method == "GET":
228 job = None
229 job_id = request.values.get("job")
230 if job_id is not None and job_id != "":
231 # ~~-> BackgroundJobs:Model~~
232 job = models.BackgroundJob.pull(job_id)
233 # ~~-> BackgroundJobs:Page~~
234 url = url_for("admin.background_jobs_search") + "?source=" + dao.Facetview2.url_encode_query(
235 dao.Facetview2.make_query(job_id))
236 Messages.flash_with_url(Messages.ADMIN__WITHDRAW_REINSTATE.format(url=url), "success")
237 fc.processor(source=journal)
239 bibjson = journal.bibjson()
240 past_cont_list = create_cont_list(journal.get_past_continuations(), bibjson.replaces)
241 future_cont_list = create_cont_list(journal.get_future_continuations(), bibjson.is_replaced_by)
243 return fc.render_template(lock=lockinfo, job=job, obj=journal, lcc_tree=lcc_jstree,
244 past_cont_list=past_cont_list, future_cont_list=future_cont_list,
245 autochecks=autochecks)
247 elif request.method == "POST":
248 processor = fc.processor(formdata=request.form, source=journal)
249 if processor.validate():
250 try:
251 processor.finalise(current_user._get_current_object())
252 flash('Journal updated.', 'success')
253 for a in processor.alert:
254 flash_with_url(a, "success")
255 return redirect(url_for("admin.journal_page", journal_id=journal.id, _anchor='done'))
256 except Exception as e:
257 flash(str(e))
258 return redirect(url_for("admin.journal_page", journal_id=journal.id, _anchor='cannot_edit'))
259 else:
260 return fc.render_template(lock=lockinfo, obj=journal, lcc_tree=lcc_jstree, autochecks=autochecks)
263@blueprint.route("/journal/readonly/<journal_id>", methods=["GET"])
264@login_required
265@ssl_required
266def journal_readonly(journal_id):
267 j = models.Journal.pull(journal_id)
268 if j is None:
269 abort(404)
271 fc = JournalFormFactory.context("admin_readonly")
272 fc.processor(source=j)
273 return fc.render_template(obj=j, lcc_tree=lcc_jstree, notabs=True)
275DisplayContData = namedtuple('DisplayContData', ['issn', 'title', 'id'])
278def create_cont_list(continuations: Iterable[Journal],
279 continuation_issns: List[str]) -> List[DisplayContData]:
280 def _issn_id_tuple(j: Journal):
281 bibjson = j.bibjson()
282 return DisplayContData(bibjson.pissn or bibjson.eissn, j.id, bibjson.title)
284 cont_list = map(_issn_id_tuple, continuations)
285 cont_list = {data.issn: data for data in cont_list}
286 cont_list.update({
287 issn: DisplayContData(issn, None, None) for issn in continuation_issns
288 if issn not in cont_list
289 })
290 return cont_list.values()
293######################################################
294# Endpoints for reinstating/withdrawing journals from the DOAJ
295#
297@blueprint.route("/journal/<journal_id>/activate", methods=["GET", "POST"])
298@login_required
299@ssl_required
300@write_required()
301def journal_activate(journal_id):
302 matching_issns = find_matching_issns_in_doaj(journal_id)
303 if not matching_issns:
304 job = journal_in_out_doaj.change_in_doaj([journal_id], True)
305 else:
306 flash_with_url(
307 Messages.CANNOT_CHANGE_THE_STATUS__OTHER_JOURNAL_IN_DOAJ_EXISTS.format(ids=", ".join(matching_issns)),
308 "error")
309 return redirect(url_for('.journal_page', journal_id=journal_id))
311 return redirect(url_for('.journal_page', journal_id=journal_id, job=job.id))
314@blueprint.route("/journal/<journal_id>/deactivate", methods=["GET", "POST"])
315@login_required
316@ssl_required
317@write_required()
318def journal_deactivate(journal_id):
319 job = journal_in_out_doaj.change_in_doaj([journal_id], False)
320 return redirect(url_for('.journal_page', journal_id=journal_id, job=job.id))
323@blueprint.route("/journals/bulk/withdraw", methods=["POST"])
324@login_required
325@ssl_required
326@write_required()
327def journals_bulk_withdraw():
328 payload = get_web_json_payload()
329 validate_json(payload, fields_must_be_present=['selection_query'], error_to_raise=BulkAdminEndpointException)
331 q = get_query_from_request(payload)
332 summary = journal_in_out_doaj.change_by_query(q, False, dry_run=payload.get("dry_run", True))
333 return make_json_resp(summary.as_dict(), status_code=200)
336@blueprint.route("/journals/bulk/reinstate", methods=["POST"])
337@login_required
338@ssl_required
339@write_required()
340def journals_bulk_reinstate():
341 payload = get_web_json_payload()
342 validate_json(payload, fields_must_be_present=['selection_query'], error_to_raise=BulkAdminEndpointException)
344 q = get_query_from_request(payload)
345 summary = journal_in_out_doaj.change_by_query(q, True, dry_run=payload.get("dry_run", True))
346 return make_json_resp(summary.as_dict(), status_code=200)
349#
350#####################################################################
352@blueprint.route("/journal/<journal_id>/article-info/", methods=["GET"])
353@login_required
354def journal_article_info(journal_id):
355 j = models.Journal.pull(journal_id)
356 if j is None:
357 abort(404)
359 return {'n_articles': models.Article.count_by_issns(j.bibjson().issns(), in_doaj=True)}
362@blueprint.route("/journal/<journal_id>/article-info/admin-site-search", methods=["GET"])
363@login_required
364def journal_article_info_admin_site_search(journal_id):
365 j = models.Journal.pull(journal_id)
366 if j is None:
367 abort(404)
369 issns = j.bibjson().issns()
370 if not issns:
371 abort(404)
373 target_url = '/admin/admin_site_search?source={"query":{"bool":{"must":[{"term":{"admin.in_doaj":true}},{"term":{"es_type.exact":"article"}},{"query_string":{"query":"%s","default_operator":"AND","default_field":"index.issn.exact"}}]}},"track_total_hits":true}'
374 return redirect(target_url % issns[0].replace('-', r'\\-'))
377@blueprint.route("/journal/<journal_id>/continue", methods=["GET", "POST"])
378@login_required
379@ssl_required
380@write_required()
381def journal_continue(journal_id):
382 j = models.Journal.pull(journal_id)
383 if j is None:
384 abort(404)
386 if request.method == "GET":
387 type = request.values.get("type")
388 form = MakeContinuation()
389 form.type.data = type
390 return render_template(templates.CONTINUATION, form=form, current=j)
392 elif request.method == "POST":
393 form = MakeContinuation(request.form)
394 if not form.validate():
395 return render_template(templates.CONTINUATION, form=form, current=j)
397 if form.type.data is None:
398 abort(400)
400 if form.type.data not in ["replaces", "is_replaced_by"]:
401 abort(400)
403 try:
404 cont = j.make_continuation(form.type.data, eissn=form.eissn.data, pissn=form.pissn.data,
405 title=form.title.data)
406 except:
407 abort(400)
409 flash("The continuation has been created (see below). You may now edit the other metadata associated with it."
410 " The original journal has also been updated with this continuation's ISSN(s). "
411 "Once you are happy with this record, you can publish it to the DOAJ",
412 "success")
413 return redirect(url_for('.journal_page', journal_id=cont.id))
416@blueprint.route("/applications", methods=["GET"])
417@login_required
418@ssl_required
419def suggestions():
420 fc = ApplicationFormFactory.context("admin", extra_param=exparam_editing_user())
421 return render_template(templates.APPLICATIONS_SEARCH,
422 admin_page=True,
423 application_status_choices=application_statuses(None, fc))
426@blueprint.route("/update_requests", methods=["GET"])
427@login_required
428@ssl_required
429def update_requests():
430 fc = ApplicationFormFactory.context("admin", extra_param=exparam_editing_user())
431 return render_template(templates.UPDATE_REQUESTS_SEARCH,
432 admin_page=True,
433 application_status_choices=application_statuses(None, fc))
436@blueprint.route("/application/<application_id>", methods=["GET", "POST"])
437@write_required()
438@login_required
439@ssl_required
440def application(application_id, **kwargs):
441 auth_svc = DOAJ.authorisationService()
442 application_svc = DOAJ.applicationService()
444 ap, _ = application_svc.application(application_id)
446 if ap is None:
447 abort(404)
449 try:
450 auth_svc.can_edit_application(current_user._get_current_object(), ap)
451 except exceptions.AuthoriseException:
452 abort(401)
454 try:
455 lockinfo = lock.lock(constants.LOCK_APPLICATION, application_id, current_user.id)
456 except lock.Locked as l:
457 return render_template(templates.APPLICATION_LOCKED, application=ap, lock=l.lock)
459 fc = ApplicationFormFactory.context("admin", extra_param=exparam_editing_user())
460 form_diff, current_journal = ApplicationFormXWalk.update_request_diff(ap)
462 autochecks = models.Autocheck.for_application(application_id)
464 if request.method == "GET":
465 fc.processor(source=ap)
467 continuation_info = {"initial_warning": request.args.get("info") == constants.APP_PROCESSOR_INFO_IS_BEING_REJECTED}
468 replaces = Journal.find_by_issn(ap.bibjson().replaces)
469 if replaces:
470 continuation_info["journal"] = replaces[0]
472 return fc.render_template(obj=ap, lock=lockinfo, form_diff=form_diff,
473 current_journal=current_journal, lcc_tree=lcc_jstree, autochecks=autochecks,
474 continuation_info=continuation_info)
476 elif request.method == "POST":
477 processor = fc.processor(formdata=request.form, source=ap)
478 if processor.validate():
479 try:
480 processor.finalise(current_user._get_current_object())
481 # if (processor.form.resettedFields):
482 # text = "Some fields has been resetted due to invalid value:"
483 # for f in processor.form.resettedFields:
484 # text += "<br>field: {}, invalid value: {}, new value: {}".format(f["name"], f["data"], f["default"])
485 # flash(text, 'info')
486 flash('Application updated.', 'success')
487 for a in processor.alert:
488 flash_with_url(a, "success")
489 return redirect(url_for("admin.application", application_id=ap.id, _anchor='done', info=processor.info))
490 except Exception as e:
491 flash("unexpected field " + str(e))
492 return redirect(url_for("admin.application", application_id=ap.id, _anchor='cannot_edit'))
493 else:
494 return fc.render_template(obj=ap, lock=lockinfo, form_diff=form_diff, current_journal=current_journal,
495 lcc_tree=lcc_jstree, autochecks=autochecks)
498@blueprint.route("/application_quick_reject/<application_id>", methods=["POST"])
499@login_required
500@ssl_required
501@write_required()
502def application_quick_reject(application_id):
503 # extract the note information from the request
504 canned_reason = request.values.get("quick_reject", "")
505 additional_info = request.values.get("quick_reject_details", "")
506 reasons = []
507 if canned_reason != "":
508 reasons.append(canned_reason)
509 if additional_info != "":
510 reasons.append(additional_info)
511 if len(reasons) == 0:
512 abort(400)
513 reason = " - ".join(reasons)
514 note = Messages.REJECT_NOTE_WRAPPER.format(editor=current_user.id, note=reason)
516 applicationService = DOAJ.applicationService()
518 # retrieve the application and an edit lock on that application
519 application = None
520 try:
521 application, alock = applicationService.application(application_id, lock_application=True,
522 lock_account=current_user._get_current_object())
523 except lock.Locked as e:
524 abort(409)
526 # determine if this was a new application or an update request
527 update_request = application.current_journal is not None
528 if update_request:
529 abort(400)
531 if application.owner is None:
532 Messages.flash_with_url(Messages.ADMIN__QUICK_REJECT__NO_OWNER, "error")
533 # redirect the user back to the edit page
534 return redirect(url_for('.application', application_id=application_id))
536 # reject the application
537 old_status = application.application_status
538 applicationService.reject_application(application, current_user._get_current_object(), note=note)
540 # send the notification email to the user
541 if old_status != constants.APPLICATION_STATUS_REJECTED:
542 eventsSvc = DOAJ.eventsService()
543 eventsSvc.trigger(models.Event(constants.EVENT_APPLICATION_STATUS, current_user.id, {
544 "application": application.data,
545 "old_status": old_status,
546 "new_status": constants.APPLICATION_STATUS_REJECTED,
547 "process": constants.PROCESS__QUICK_REJECT,
548 "note": reason
549 }))
551 # sort out some flash messages for the user
552 flash(note, "success")
554 msg = Messages.SENT_REJECTED_APPLICATION_EMAIL_TO_OWNER.format(user=application.owner)
555 flash(msg, "success")
557 # redirect the user back to the edit page
558 return redirect(url_for('admin.application', application_id=application_id, info=constants.APP_PROCESSOR_INFO_IS_BEING_REJECTED))
561@blueprint.route("/admin_site_search", methods=["GET"])
562@login_required
563@ssl_required
564def admin_site_search():
565 # edit_formcontext = formcontext.ManEdBulkEdit()
566 # edit_form = edit_formcontext.render_template()
567 edit_formulaic_context = JournalFormFactory.context("bulk_edit", extra_param=exparam_editing_user())
568 edit_form = edit_formulaic_context.render_template()
570 return render_template(templates.ADMIN_SITE_SEARCH,
571 admin_page=True,
572 edit_form=edit_form)
575@blueprint.route("/editor_groups")
576@login_required
577@ssl_required
578def editor_group_search():
579 return render_template(templates.EDITOR_GROUP_SEARCH, admin_page=True)
582@blueprint.route("/background_jobs")
583@login_required
584@ssl_required
585def background_jobs_search():
586 return render_template(templates.BACKGROUND_JOBS_SEARCH, admin_page=True)
589@blueprint.route("/notifications")
590@login_required
591@ssl_required
592def global_notifications_search():
593 """ ~~->AdminNotificationsSearch:Page~~ """
594 return render_template(templates.GLOBAL_NOTIFICATIONS_SEARCH, admin_page=True)
597@blueprint.route("/editor_group", methods=["GET", "POST"])
598@blueprint.route("/editor_group/<group_id>", methods=["GET", "POST"])
599@login_required
600@ssl_required
601@write_required()
602def editor_group(group_id=None):
603 if not current_user.has_role("modify_editor_groups"):
604 abort(401)
606 # ~~->EditorGroup:Form~~
607 if request.method == "GET":
608 form = EditorGroupForm()
609 if group_id is not None:
610 eg = models.EditorGroup.pull(group_id)
611 form.group_id.data = eg.id
612 form.name.data = eg.name
613 # Do not allow the user to edit the name. issue #3859
614 form.name.render_kw = {'disabled': True}
615 form.maned.data = eg.maned
616 form.editor.data = eg.editor
617 form.associates.data = ",".join(eg.associates)
618 return render_template(templates.EDITOR_GROUP, admin_page=True, form=form)
620 elif request.method == "POST":
622 if request.values.get("delete", "false") == "true":
623 # we have been asked to delete the id
624 if group_id is None:
625 # we can only delete things that exist
626 abort(400)
627 eg = models.EditorGroup.pull(group_id)
628 if eg is None:
629 abort(404)
631 eg.delete()
633 # return a json response
634 resp = make_response(json.dumps({"success": True}))
635 resp.mimetype = "application/json"
636 return resp
638 # otherwise, we want to edit the content of the form or the object
639 form = EditorGroupForm(request.form)
641 if form.validate():
642 # get the group id from the url or from the request parameters
643 if group_id is None:
644 group_id = request.values.get("group_id")
645 group_id = group_id if group_id != "" else None
647 # if we have a group id, this is an edit, so get the existing group
648 if group_id is not None:
649 eg = models.EditorGroup.pull(group_id)
650 if eg is None:
651 abort(404)
652 else:
653 eg = models.EditorGroup()
655 associates = form.associates.data
656 if associates is not None:
657 associates = [a.strip() for a in associates.split(",") if a.strip() != ""]
659 # prep the user accounts with the correct role(s)
660 ed = models.Account.pull(form.editor.data)
661 ed.add_role("editor")
662 ed.save()
663 if associates is not None:
664 for a in associates:
665 ae = models.Account.pull(a)
666 if ae is not None: # If the account has been deleted, pull fails
667 ae.add_role("associate_editor")
668 ae.save()
670 if eg.name is None:
671 eg.set_name(form.name.data)
672 eg.set_maned(form.maned.data)
673 eg.set_editor(form.editor.data)
674 if associates is not None:
675 eg.set_associates(associates)
676 eg.save()
678 flash(
679 "Group was updated - changes may not be reflected below immediately. Reload the page to see the update.",
680 "success")
681 return redirect(url_for('admin.editor_group_search'))
682 else:
683 return render_template(templates.EDITOR_GROUP, admin_page=True, form=form)
686@blueprint.route("/autocomplete/user")
687@login_required
688@ssl_required
689def user_autocomplete():
690 q = request.values.get("q")
691 s = request.values.get("s", 10)
692 admin_only = "admin_only" in request.args
693 if admin_only:
694 ac = models.Account.admin_autocomplete("id", q, size=s)
695 else:
696 ac = models.Account.autocomplete("id", q, size=s)
698 # return a json response
699 resp = make_response(json.dumps({"suggestions": ac}))
700 resp.mimetype = "application/json"
701 return resp
703@blueprint.route("/autocomplete/user_tags")
704@login_required
705@ssl_required
706def user_tags_autocomplete():
707 q = request.values.get("q")
708 s = request.values.get("s", 10)
709 ac = models.Account.autocomplete("attributes." + constants.USER_ATTR__TAG + ".exact", q, size=s)
711 # return a json response
712 resp = make_response(json.dumps({"suggestions": ac}))
713 resp.mimetype = "application/json"
714 return resp
716# Route which returns the associate editor account names within a given editor group
717@blueprint.route("/dropdown/eg_associates")
718@login_required
719@ssl_required
720def eg_associates_dropdown():
721 egn = request.values.get("egn")
722 eg = models.EditorGroup.pull_by_key("name", egn)
724 if eg is not None:
725 editors = [eg.editor]
726 editors += eg.associates
727 editors = list(set(editors))
728 else:
729 editors = None
731 # return a json response
732 resp = make_response(json.dumps(editors))
733 resp.mimetype = "application/json"
734 return resp
737####################################################
738## endpoints for bulk edit
740class BulkAdminEndpointException(Exception):
741 pass
744@app.errorhandler(BulkAdminEndpointException)
745def bulk_admin_endpoints_bad_request(exception):
746 r = {}
747 r['error'] = exception.message
748 return make_json_resp(r, status_code=400)
751def get_bulk_edit_background_task_manager(doaj_type):
752 if doaj_type == 'journals':
753 return journal_bulk_edit.journal_manage
754 elif doaj_type in ['applications', 'update_requests']:
755 return suggestion_bulk_edit.suggestion_manage
756 else:
757 raise BulkAdminEndpointException(
758 'Unsupported DOAJ type - you can currently only bulk edit journals and applications/update_requests.')
761def get_query_from_request(payload, doaj_type=None):
762 q = payload['selection_query']
763 q = remove_search_limits(q)
765 q = Query(q)
767 if doaj_type == "update_requests":
768 update_request(q)
769 elif doaj_type == "applications":
770 not_update_request(q)
772 return q.as_dict()
775@blueprint.route("/<doaj_type>/bulk/assign_editor_group", methods=["POST"])
776@login_required
777@ssl_required
778@write_required()
779def bulk_assign_editor_group(doaj_type):
780 task = get_bulk_edit_background_task_manager(doaj_type)
782 payload = get_web_json_payload()
783 validate_json(payload, fields_must_be_present=['selection_query', 'editor_group'],
784 error_to_raise=BulkAdminEndpointException)
786 summary = task(
787 selection_query=get_query_from_request(payload, doaj_type),
788 editor_group=payload['editor_group'],
789 dry_run=payload.get('dry_run', True)
790 )
792 return make_json_resp(summary.as_dict(), status_code=200)
795@blueprint.route("/<doaj_type>/bulk/add_note", methods=["POST"])
796@login_required
797@ssl_required
798@write_required()
799def bulk_add_note(doaj_type):
800 task = get_bulk_edit_background_task_manager(doaj_type)
802 payload = get_web_json_payload()
803 validate_json(payload, fields_must_be_present=['selection_query', 'note'],
804 error_to_raise=BulkAdminEndpointException)
806 summary = task(
807 selection_query=get_query_from_request(payload, doaj_type),
808 note=payload['note'],
809 dry_run=payload.get('dry_run', True)
810 )
812 return make_json_resp(summary.as_dict(), status_code=200)
815@blueprint.route("/journals/bulk/edit_metadata", methods=["POST"])
816@login_required
817@ssl_required
818@write_required()
819def bulk_edit_journal_metadata():
820 task = get_bulk_edit_background_task_manager("journals")
822 payload = get_web_json_payload()
823 if not "metadata" in payload:
824 raise BulkAdminEndpointException("key 'metadata' not present in request json")
826 formdata = MultiDict(payload["metadata"])
827 formulaic_context = JournalFormFactory.context("bulk_edit", extra_param=exparam_editing_user())
828 fc = formulaic_context.processor(formdata=formdata)
830 if not fc.validate():
831 msg = "Unable to submit your request due to form validation issues: "
832 for field in fc.form:
833 if field.errors:
834 msg += field.label.text + " - " + ",".join(field.errors)
835 summary = BackgroundSummary(None, error=msg)
836 else:
837 summary = task(
838 selection_query=get_query_from_request(payload),
839 dry_run=payload.get('dry_run', True),
840 **payload["metadata"]
841 )
843 return make_json_resp(summary.as_dict(), status_code=200)
846@blueprint.route("/<doaj_type>/bulk/change_status", methods=["POST"])
847@login_required
848@ssl_required
849@write_required()
850def applications_bulk_change_status(doaj_type):
851 if doaj_type not in ["applications", "update_requests"]:
852 abort(403)
853 payload = get_web_json_payload()
854 validate_json(payload, fields_must_be_present=['selection_query', 'application_status'],
855 error_to_raise=BulkAdminEndpointException)
857 q = get_query_from_request(payload, doaj_type)
858 summary = get_bulk_edit_background_task_manager('applications')(
859 selection_query=q,
860 application_status=payload['application_status'],
861 dry_run=payload.get('dry_run', True)
862 )
864 return make_json_resp(summary.as_dict(), status_code=200)
867@blueprint.route("/journals/bulk/delete", methods=['POST'])
868@write_required()
869def bulk_journals_delete():
870 if not current_user.has_role("ultra_bulk_delete"):
871 abort(403)
872 payload = get_web_json_payload()
873 validate_json(payload, fields_must_be_present=['selection_query'], error_to_raise=BulkAdminEndpointException)
875 q = get_query_from_request(payload)
876 summary = journal_bulk_delete.journal_bulk_delete_manage(
877 selection_query=q,
878 dry_run=payload.get('dry_run', True)
879 )
880 return make_json_resp(summary.as_dict(), status_code=200)
883@blueprint.route("/articles/bulk/delete", methods=['POST'])
884@write_required()
885def bulk_articles_delete():
886 if not current_user.has_role("ultra_bulk_delete"):
887 abort(403)
888 payload = get_web_json_payload()
889 validate_json(payload, fields_must_be_present=['selection_query'], error_to_raise=BulkAdminEndpointException)
891 q = get_query_from_request(payload)
892 summary = article_bulk_delete.article_bulk_delete_manage(
893 selection_query=q,
894 dry_run=payload.get('dry_run', True)
895 )
897 return make_json_resp(summary.as_dict(), status_code=200)
899#################################################
901################################################
902## Reporting endpoint
904@blueprint.route("/report", methods=["POST"])
905@write_required()
906@login_required
907def request_report():
908 model = request.values.get("model")
909 query_raw = request.values.get("query")
910 name = request.values.get("name")
911 # TODO: it's probably a bit cheeky to use the type param (used for casting) to run our lambda function, but it works
912 notes = request.values.get("notes", False, lambda x: json.loads(x))
914 if notes is True and not current_user.has_role(constants.ROLE_ADMIN_REPORT_WITH_NOTES): # "ultra_admin_reports_with_notes"
915 # Fixme: this abort is only visible within the network console, because it's a jSON endpoint to serve the page.
916 # It will just appear that the generate button isn't working (but they'll have edited the HTML to re-enable the checkbox)
917 abort(403)
919 query = json.loads(query_raw)
920 sane_query = {"query": query.get("query")}
921 if "sort" in query:
922 sane_query["sort"] = query["sort"]
924 model_endpoint_map = {
925 "journal": "journal",
926 "application": "suggestion"
927 }
929 query_svc = DOAJ.queryService()
930 real_query = query_svc.make_actionable_query("admin_query", model_endpoint_map.get(model), current_user, sane_query)
932 job = admin_reports.AdminReportsBackgroundTask.prepare(current_user.id, model=model, true_query=real_query.as_dict(), ui_query=sane_query, name=name, notes=notes)
933 admin_reports.AdminReportsBackgroundTask.submit(job)
935 return make_json_resp({"job_id": job.id}, status_code=200)
938@blueprint.route("/report/<report_id>", methods=["GET"])
939@login_required
940def get_report(report_id):
941 def safe(filename):
942 return re.sub(r'[^a-zA-Z0-9-_]', '_', filename)
944 exporter = DOAJ.exportService()
945 record, fh = exporter.retrieve(report_id)
946 safe_filename = safe(record.name) + "_" + safe(record.generated_date) + ".csv"
947 return send_file(fh, as_attachment=True, download_name=safe_filename)
949@blueprint.route("/reports", methods=["GET"])
950@login_required
951def reports_search():
952 return render_template(templates.ADMIN_REPORTS_SEARCH)
954@blueprint.route("/alerts", methods=["GET"])
955@login_required
956def admin_alerts():
957 return render_template(templates.ADMIN_ALERTS_SEARCH)
959@blueprint.route("/autoassign", methods=["GET"])
960@login_required
961def autoassign_search():
962 return render_template(templates.ADMIN_AUTOASSIGN_SEARCH)
964@blueprint.route("/journal-csv", methods=["GET"])
965@login_required
966def journal_csv_search():
967 svc = DOAJ.journalService()
968 free = svc.get_free_csv()
969 premium = svc.get_premium_csv()
970 return render_template(templates.ADMIN_JOURNAL_CSV_SEARCH, free=free, premium=premium)
972@blueprint.route("/journal-csv/delete", methods=["POST"])
973@write_required()
974@login_required
975def journal_csv_delete():
976 svc = DOAJ.journalService()
977 id = request.values.get("id")
978 if id is None:
979 abort(400)
980 try:
981 svc.delete_csv(id)
982 return make_json_resp({"status": "success"}, status_code=200)
983 except:
984 abort(400)
986@blueprint.route("/pdd", methods=["GET"])
987@login_required
988def pdd_search():
989 svc = DOAJ.publicDataDumpService()
990 free = svc.get_free_dump()
991 premium = svc.get_premium_dump()
992 return render_template(templates.ADMIN_PDD_SEARCH, free=free, premium=premium)
994@blueprint.route("/pdd/delete", methods=["POST"])
995@write_required()
996@login_required
997def pdd_delete():
998 svc = DOAJ.publicDataDumpService()
999 id = request.values.get("id")
1000 if id is None:
1001 abort(400)
1002 try:
1003 svc.delete_pdd(id)
1004 return make_json_resp({"status": "success"}, status_code=200)
1005 except:
1006 abort(400)
1008@blueprint.route("/ris", methods=["GET"])
1009@login_required
1010def ris_search():
1011 return render_template(templates.ADMIN_RIS_SEARCH)
1013@blueprint.route("/system/provenance", methods=["GET"])
1014@login_required
1015def system_object_provenance():
1016 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1017 container_id="provenance_search",
1018 init_function="initProvenance",
1019 page_title="Provenance")
1021@blueprint.route("/system/file-uploads", methods=["GET"])
1022@login_required
1023def system_object_file_uploads():
1024 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1025 container_id="file_uploads_search",
1026 init_function="initFileUploads",
1027 page_title="File Uploads")
1029@blueprint.route("/system/bulk-uploads", methods=["GET"])
1030@login_required
1031def system_object_bulk_uploads():
1032 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1033 container_id="bulk_uploads_search",
1034 init_function="initBulkUploads",
1035 page_title="Bulk Uploads")
1037@blueprint.route("/system/cache", methods=["GET"])
1038@login_required
1039def system_object_cache():
1040 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1041 container_id="cache_search",
1042 init_function="initCache",
1043 page_title="Cache")
1045@blueprint.route("/system/locks", methods=["GET"])
1046@login_required
1047def system_object_locks():
1048 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1049 container_id="locks_search",
1050 init_function="initLocks",
1051 page_title="Locks")
1053@blueprint.route("/system/preservation", methods=["GET"])
1054@login_required
1055def system_object_preservation():
1056 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1057 container_id="preservation_search",
1058 init_function="initPreservation",
1059 page_title="Preservation")
1061@blueprint.route("/system/article-tombstones", methods=["GET"])
1062@login_required
1063def system_object_article_tombstones():
1064 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1065 container_id="article_tombstones_search",
1066 init_function="initArticleTombstones",
1067 page_title="Article Tombstones")
1069@blueprint.route("/system/draft-applications", methods=["GET"])
1070@login_required
1071def system_object_draft_applications():
1072 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1073 container_id="draft_applications_search",
1074 init_function="initDraftApplications",
1075 page_title="Draft Applications")
1077@blueprint.route("/system/harvester-state", methods=["GET"])
1078@login_required
1079def system_object_harvester_state():
1080 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1081 container_id="harvester_state_search",
1082 init_function="initHarvesterState",
1083 page_title="Harvester State")
1085@blueprint.route("/system/autochecks", methods=["GET"])
1086@login_required
1087def system_object_autochecks():
1088 return render_template(templates.ADMIN_SYSTEM_OBJECTS_SEARCH,
1089 container_id="autochecks_search",
1090 init_function="initAutochecks",
1091 page_title="Autochecks")
1093@blueprint.route("/ris/<id>/<action>", methods=["POST"])
1094@login_required
1095def ris_manage(id, action):
1096 if action not in ["delete", "regenerate"]:
1097 abort(404)
1099 svc = DOAJ.exportService()
1101 if action == "delete":
1102 svc.remove_ris(id)
1103 return make_json_resp({"delete": "success"}, status_code=200)
1105 if action == "regenerate":
1106 svc.ris(id)
1107 return make_json_resp({"regenerate": "success"}, status_code=200)