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

1import json, re 

2from collections import namedtuple 

3from typing import Iterable, List 

4 

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 

9 

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 

35 

36# ~~Admin:Blueprint~~ 

37blueprint = Blueprint('admin', __name__) 

38 

39 

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') 

44 

45 

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) 

52 

53 

54@blueprint.route("/status") 

55@login_required 

56@ssl_required 

57def status_ui(): 

58 return render_template(templates.ADMIN_STATUS) 

59 

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) 

69 

70 

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) 

83 

84 # get the total number of journals to be affected 

85 jtotal = models.Journal.hit_count(query, consistent_order=False) 

86 

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) 

90 

91 resp = make_response(json.dumps({"journals": jtotal, "articles": atotal})) 

92 resp.mimetype = "application/json" 

93 return resp 

94 

95 elif request.method == "DELETE": 

96 if not current_user.has_role("delete_article"): 

97 abort(401) 

98 

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) 

104 

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 

111 

112 

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) 

132 

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) 

138 

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 

145 

146 

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 

166 

167 

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) 

178 

179 fc = ArticleFormFactory.get_from_context(role="admin", source=ap, user=current_user) 

180 if request.method == "GET": 

181 return fc.render_template() 

182 

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) 

186 

187 fc.modify_authors_if_required(request.values) 

188 

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) 

196 

197 return fc.render_template() 

198 

199 

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() 

208 

209 journal, _ = journal_svc.journal(journal_id) 

210 if journal is None: 

211 abort(404) 

212 

213 try: 

214 auth_svc.can_edit_journal(current_user._get_current_object(), journal) 

215 except exceptions.AuthoriseException: 

216 abort(401) 

217 

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) 

223 

224 fc = JournalFormFactory.context("admin", extra_param=exparam_editing_user()) 

225 autochecks = models.Autocheck.for_journal(journal_id) 

226 

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) 

238 

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) 

242 

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) 

246 

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) 

261 

262 

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) 

270 

271 fc = JournalFormFactory.context("admin_readonly") 

272 fc.processor(source=j) 

273 return fc.render_template(obj=j, lcc_tree=lcc_jstree, notabs=True) 

274 

275DisplayContData = namedtuple('DisplayContData', ['issn', 'title', 'id']) 

276 

277 

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) 

283 

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() 

291 

292 

293###################################################### 

294# Endpoints for reinstating/withdrawing journals from the DOAJ 

295# 

296 

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)) 

310 

311 return redirect(url_for('.journal_page', journal_id=journal_id, job=job.id)) 

312 

313 

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)) 

321 

322 

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) 

330 

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) 

334 

335 

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) 

343 

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) 

347 

348 

349# 

350##################################################################### 

351 

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) 

358 

359 return {'n_articles': models.Article.count_by_issns(j.bibjson().issns(), in_doaj=True)} 

360 

361 

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) 

368 

369 issns = j.bibjson().issns() 

370 if not issns: 

371 abort(404) 

372 

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'\\-')) 

375 

376 

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) 

385 

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) 

391 

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) 

396 

397 if form.type.data is None: 

398 abort(400) 

399 

400 if form.type.data not in ["replaces", "is_replaced_by"]: 

401 abort(400) 

402 

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) 

408 

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)) 

414 

415 

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)) 

424 

425 

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)) 

434 

435 

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() 

443 

444 ap, _ = application_svc.application(application_id) 

445 

446 if ap is None: 

447 abort(404) 

448 

449 try: 

450 auth_svc.can_edit_application(current_user._get_current_object(), ap) 

451 except exceptions.AuthoriseException: 

452 abort(401) 

453 

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) 

458 

459 fc = ApplicationFormFactory.context("admin", extra_param=exparam_editing_user()) 

460 form_diff, current_journal = ApplicationFormXWalk.update_request_diff(ap) 

461 

462 autochecks = models.Autocheck.for_application(application_id) 

463 

464 if request.method == "GET": 

465 fc.processor(source=ap) 

466 

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] 

471 

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) 

475 

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) 

496 

497 

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) 

515 

516 applicationService = DOAJ.applicationService() 

517 

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) 

525 

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) 

530 

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)) 

535 

536 # reject the application 

537 old_status = application.application_status 

538 applicationService.reject_application(application, current_user._get_current_object(), note=note) 

539 

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 })) 

550 

551 # sort out some flash messages for the user 

552 flash(note, "success") 

553 

554 msg = Messages.SENT_REJECTED_APPLICATION_EMAIL_TO_OWNER.format(user=application.owner) 

555 flash(msg, "success") 

556 

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)) 

559 

560 

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() 

569 

570 return render_template(templates.ADMIN_SITE_SEARCH, 

571 admin_page=True, 

572 edit_form=edit_form) 

573 

574 

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) 

580 

581 

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) 

587 

588 

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) 

595 

596 

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) 

605 

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) 

619 

620 elif request.method == "POST": 

621 

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) 

630 

631 eg.delete() 

632 

633 # return a json response 

634 resp = make_response(json.dumps({"success": True})) 

635 resp.mimetype = "application/json" 

636 return resp 

637 

638 # otherwise, we want to edit the content of the form or the object 

639 form = EditorGroupForm(request.form) 

640 

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 

646 

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() 

654 

655 associates = form.associates.data 

656 if associates is not None: 

657 associates = [a.strip() for a in associates.split(",") if a.strip() != ""] 

658 

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() 

669 

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() 

677 

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) 

684 

685 

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) 

697 

698 # return a json response 

699 resp = make_response(json.dumps({"suggestions": ac})) 

700 resp.mimetype = "application/json" 

701 return resp 

702 

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) 

710 

711 # return a json response 

712 resp = make_response(json.dumps({"suggestions": ac})) 

713 resp.mimetype = "application/json" 

714 return resp 

715 

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) 

723 

724 if eg is not None: 

725 editors = [eg.editor] 

726 editors += eg.associates 

727 editors = list(set(editors)) 

728 else: 

729 editors = None 

730 

731 # return a json response 

732 resp = make_response(json.dumps(editors)) 

733 resp.mimetype = "application/json" 

734 return resp 

735 

736 

737#################################################### 

738## endpoints for bulk edit 

739 

740class BulkAdminEndpointException(Exception): 

741 pass 

742 

743 

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) 

749 

750 

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.') 

759 

760 

761def get_query_from_request(payload, doaj_type=None): 

762 q = payload['selection_query'] 

763 q = remove_search_limits(q) 

764 

765 q = Query(q) 

766 

767 if doaj_type == "update_requests": 

768 update_request(q) 

769 elif doaj_type == "applications": 

770 not_update_request(q) 

771 

772 return q.as_dict() 

773 

774 

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) 

781 

782 payload = get_web_json_payload() 

783 validate_json(payload, fields_must_be_present=['selection_query', 'editor_group'], 

784 error_to_raise=BulkAdminEndpointException) 

785 

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 ) 

791 

792 return make_json_resp(summary.as_dict(), status_code=200) 

793 

794 

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) 

801 

802 payload = get_web_json_payload() 

803 validate_json(payload, fields_must_be_present=['selection_query', 'note'], 

804 error_to_raise=BulkAdminEndpointException) 

805 

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 ) 

811 

812 return make_json_resp(summary.as_dict(), status_code=200) 

813 

814 

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") 

821 

822 payload = get_web_json_payload() 

823 if not "metadata" in payload: 

824 raise BulkAdminEndpointException("key 'metadata' not present in request json") 

825 

826 formdata = MultiDict(payload["metadata"]) 

827 formulaic_context = JournalFormFactory.context("bulk_edit", extra_param=exparam_editing_user()) 

828 fc = formulaic_context.processor(formdata=formdata) 

829 

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 ) 

842 

843 return make_json_resp(summary.as_dict(), status_code=200) 

844 

845 

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) 

856 

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 ) 

863 

864 return make_json_resp(summary.as_dict(), status_code=200) 

865 

866 

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) 

874 

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) 

881 

882 

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) 

890 

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 ) 

896 

897 return make_json_resp(summary.as_dict(), status_code=200) 

898 

899################################################# 

900 

901################################################ 

902## Reporting endpoint 

903 

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)) 

913 

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) 

918 

919 query = json.loads(query_raw) 

920 sane_query = {"query": query.get("query")} 

921 if "sort" in query: 

922 sane_query["sort"] = query["sort"] 

923 

924 model_endpoint_map = { 

925 "journal": "journal", 

926 "application": "suggestion" 

927 } 

928 

929 query_svc = DOAJ.queryService() 

930 real_query = query_svc.make_actionable_query("admin_query", model_endpoint_map.get(model), current_user, sane_query) 

931 

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) 

934 

935 return make_json_resp({"job_id": job.id}, status_code=200) 

936 

937 

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) 

943 

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) 

948 

949@blueprint.route("/reports", methods=["GET"]) 

950@login_required 

951def reports_search(): 

952 return render_template(templates.ADMIN_REPORTS_SEARCH) 

953 

954@blueprint.route("/alerts", methods=["GET"]) 

955@login_required 

956def admin_alerts(): 

957 return render_template(templates.ADMIN_ALERTS_SEARCH) 

958 

959@blueprint.route("/autoassign", methods=["GET"]) 

960@login_required 

961def autoassign_search(): 

962 return render_template(templates.ADMIN_AUTOASSIGN_SEARCH) 

963 

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) 

971 

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) 

985 

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) 

993 

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) 

1007 

1008@blueprint.route("/ris", methods=["GET"]) 

1009@login_required 

1010def ris_search(): 

1011 return render_template(templates.ADMIN_RIS_SEARCH) 

1012 

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") 

1020 

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") 

1028 

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") 

1036 

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") 

1044 

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") 

1052 

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") 

1060 

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") 

1068 

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") 

1076 

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") 

1084 

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") 

1092 

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) 

1098 

1099 svc = DOAJ.exportService() 

1100 

1101 if action == "delete": 

1102 svc.remove_ris(id) 

1103 return make_json_resp({"delete": "success"}, status_code=200) 

1104 

1105 if action == "regenerate": 

1106 svc.ris(id) 

1107 return make_json_resp({"regenerate": "success"}, status_code=200)