Coverage for portality/crosswalks/journal_form.py: 89%

414 statements  

« prev     ^ index     » next       coverage.py v7.17.3, created at 2026-11-20 13:43 +0000

1from werkzeug.datastructures import MultiDict 

2 

3from portality import models, lcc 

4from portality.datasets import licenses 

5from portality.forms.utils import expanded2compact 

6from portality.models import Account 

7from portality.lib import dates 

8from builtins import ValueError 

9 

10class JournalGenericXWalk(object): 

11 """ 

12 ~~Journal:Crosswalk->Journal:Form~~ 

13 ~~->Journal:Model~~ 

14 """ 

15 @classmethod 

16 def forminfo2multidict(cls, forminfo): 

17 formdata = expanded2compact(forminfo, 

18 join_lists={"keywords": ",", "subject": ","}, 

19 repeat_lists=["preservation_service_library", "language"] 

20 ) 

21 return MultiDict(formdata) 

22 

23 @classmethod 

24 def is_new_editor_group(cls, form, old): 

25 old_eg = old.editor_group 

26 new_eg = form.editor_group.data 

27 return old_eg != new_eg and new_eg is not None and new_eg != "" 

28 

29 @classmethod 

30 def is_new_editor(cls, form, old): 

31 old_ed = old.editor 

32 new_ed = form.editor.data 

33 return old_ed != new_ed and new_ed is not None and new_ed != "" 

34 

35 @classmethod 

36 def is_new_flag_assignee(cls, form, old): 

37 # This method assumes only one flag per journal 

38 old_flags = old.flags 

39 old_flag_assignee = old_flags[0]["flag"]["assigned_to"] if old_flags else None 

40 new_flags = form.flags.data 

41 new_flag_assignee = None 

42 is_resolved = form.flags.data["flag_resolved"] or form.flags.data["flag_resolved"] == "false" 

43 if not is_resolved and new_flags: 

44 new_flag_assignee = form.flags.data["flag_assignee"] 

45 return old_flag_assignee != new_flag_assignee if new_flag_assignee else False 

46 

47 @classmethod 

48 def form_diff(cls, a_formdata, b_formdata): 

49 

50 def _serialise(x): 

51 if isinstance(x, list): 

52 return "; ".join(sorted([_serialise(y) for y in x])) 

53 elif isinstance(x, dict): 

54 kvs = [] 

55 for k, v in x.items(): 

56 kvs.append(k + ":" + str(v)) 

57 kvs.sort() 

58 return ", ".join(kvs) 

59 else: 

60 return x 

61 

62 diff = {} 

63 for k, v in b_formdata.items(): 

64 if k in a_formdata: 

65 if isinstance(a_formdata[k], list): 

66 for entry in a_formdata[k]: 

67 if entry not in v: 

68 diff[k] = {"a" : _serialise(a_formdata[k]), "b" : _serialise(v)} 

69 break 

70 for entry in v: 

71 if entry not in a_formdata[k]: 

72 diff[k] = {"a": _serialise(a_formdata[k]), "b": _serialise(v)} 

73 break 

74 

75 elif isinstance(a_formdata[k], dict): 

76 pass # No instances of this in our current form, so leaving it out 

77 else: 

78 if a_formdata[k] != v: 

79 diff[k] = {"a" : a_formdata[k], "b" : v} 

80 

81 else: 

82 diff[k] = {"a" : "", "b": _serialise(v)} 

83 

84 return diff 

85 

86 @classmethod 

87 def form2bibjson(cls, form, bibjson): 

88 # pre-strip all the form content whitespace 

89 for field in form: 

90 if hasattr(field.data, "strip"): 

91 field.data = field.data.strip() 

92 

93 if form.alternative_title.data: 

94 bibjson.alternative_title = form.alternative_title.data 

95 

96 for apc_record in form.apc_charges.data: 

97 if not apc_record["apc_currency"] and not apc_record["apc_max"]: 

98 continue 

99 bibjson.add_apc(apc_record["apc_currency"], apc_record["apc_max"]) 

100 

101 if form.apc_url.data: 

102 bibjson.apc_url = form.apc_url.data 

103 

104 if form.preservation_service.data: 

105 pres_services = [e for e in form.preservation_service.data if e not in ["national_library", "none", "other"]] 

106 if "other" in form.preservation_service.data and form.preservation_service_other.data: 

107 pres_services.append(form.preservation_service_other.data) 

108 bibjson.set_preservation(pres_services, None) 

109 if "national_library" in form.preservation_service.data and form.preservation_service_library.data: 

110 libs = [x for x in form.preservation_service_library.data if x] 

111 for lib in libs: 

112 bibjson.add_preservation_library(lib) 

113 if "none" in form.preservation_service.data: 

114 bibjson.has_preservation = False 

115 

116 if form.preservation_service_url.data: 

117 bibjson.preservation_url = form.preservation_service_url.data 

118 

119 if form.copyright_author_retains.data: 

120 bibjson.author_retains_copyright = form.copyright_author_retains.data == 'y' 

121 

122 if form.copyright_url.data: 

123 bibjson.copyright_url = form.copyright_url.data 

124 

125 if form.publisher_name.data: 

126 bibjson.publisher_name = form.publisher_name.data 

127 if form.publisher_country.data: 

128 bibjson.publisher_country = form.publisher_country.data 

129 

130 if form.deposit_policy.data: 

131 dep_services = [e for e in form.deposit_policy.data if e not in ["none", "other"]] 

132 if "other" in form.deposit_policy.data and form.deposit_policy_other.data: 

133 dep_services.append(form.deposit_policy_other.data) 

134 if dep_services: 

135 bibjson.deposit_policy = dep_services 

136 else: 

137 bibjson.has_deposit_policy = False 

138 

139 if form.review_process.data or form.review_url.data: 

140 processes = None 

141 if form.review_process.data: 

142 processes = [e for e in form.review_process.data if e not in ["other"]] 

143 if "other" in form.review_process.data and form.review_process_other.data: 

144 processes.append(form.review_process_other.data) 

145 bibjson.set_editorial_review(processes, form.review_url.data, form.editorial_board_url.data) 

146 

147 if form.pissn.data: 

148 bibjson.pissn = form.pissn.data 

149 

150 if form.eissn.data: 

151 bibjson.eissn = form.eissn.data 

152 

153 if form.institution_name.data: 

154 bibjson.institution_name = form.institution_name.data 

155 if form.institution_country.data: 

156 bibjson.institution_country = form.institution_country.data 

157 

158 if form.keywords.data: 

159 bibjson.keywords = form.keywords.data 

160 

161 if form.language.data: 

162 norm_language = [x for x in form.language.data if x != ""] 

163 if norm_language: 

164 bibjson.language = norm_language # select multiple field - gives a list back 

165 

166 lurl = form.license_terms_url.data 

167 if lurl: 

168 bibjson.license_terms_url = lurl 

169 if form.license.data: 

170 for ltype in form.license.data: 

171 by, nc, nd, sa = None, None, None, None 

172 if ltype in licenses: 

173 by = licenses[ltype]['BY'] 

174 nc = licenses[ltype]['NC'] 

175 nd = licenses[ltype]['ND'] 

176 sa = licenses[ltype]['SA'] 

177 lurl = licenses[ltype]["url"] 

178 elif form.license_attributes.data: 

179 by = True if 'BY' in form.license_attributes.data else False 

180 nc = True if 'NC' in form.license_attributes.data else False 

181 nd = True if 'ND' in form.license_attributes.data else False 

182 sa = True if 'SA' in form.license_attributes.data else False 

183 bibjson.add_license(ltype, url=lurl, by=by, nc=nc, nd=nd, sa=sa) 

184 

185 # FIXME: this is not quite what we planned 

186 if form.license_display.data: 

187 bibjson.article_license_display = ["Embed"] if form.license_display.data == "y" else ["No"] 

188 

189 if form.license_display_example_url.data: 

190 bibjson.article_license_display_example_url = form.license_display_example_url.data 

191 

192 if form.boai.data: 

193 bibjson.boai = form.boai.data == "y" 

194 

195 if form.oa_start.data: 

196 bibjson.oa_start = form.oa_start.data 

197 

198 if form.oa_statement_url.data: 

199 bibjson.oa_statement_url = form.oa_statement_url.data 

200 

201 if form.journal_url.data: 

202 bibjson.journal_url = form.journal_url.data 

203 

204 if form.aims_scope_url.data: 

205 bibjson.aims_scope_url = form.aims_scope_url.data 

206 

207 if form.author_instructions_url.data: 

208 bibjson.author_instructions_url = form.author_instructions_url.data 

209 

210 if form.waiver_url.data: 

211 bibjson.waiver_url = form.waiver_url.data 

212 

213 if form.persistent_identifiers.data: 

214 schemes = [e for e in form.persistent_identifiers.data if e not in ["none", "other"]] 

215 if "other" in form.persistent_identifiers.data and form.persistent_identifiers_other.data: 

216 schemes.append(form.persistent_identifiers_other.data) 

217 if len(schemes) > 0: 

218 bibjson.pid_scheme = schemes 

219 elif "none" in form.persistent_identifiers.data: 

220 bibjson.has_pid_scheme = False 

221 

222 if form.plagiarism_detection.data: 

223 has_detection = form.plagiarism_detection.data == "y" 

224 bibjson.set_plagiarism_detection(form.plagiarism_url.data, has_detection) 

225 

226 if form.publication_time_weeks.data: 

227 bibjson.publication_time_weeks = form.publication_time_weeks.data 

228 

229 if form.other_charges_url.data: 

230 bibjson.other_charges_url = form.other_charges_url.data 

231 

232 if form.title.data: 

233 bibjson.title = form.title.data 

234 

235 if form.apc.data: 

236 bibjson.has_apc = form.apc.data == "y" 

237 

238 if form.has_other_charges.data: 

239 has_other = form.has_other_charges.data == "y" 

240 bibjson.has_other_charges = has_other 

241 

242 if form.has_waiver.data: 

243 has_waiver = form.has_waiver.data == "y" 

244 bibjson.has_waiver = has_waiver 

245 

246 if form.deposit_policy_url.data: 

247 bibjson.deposit_policy_url = form.deposit_policy_url.data 

248 

249 # continuations information 

250 if getattr(form, "continues", None): 

251 bibjson.replaces = form.continues.data 

252 if getattr(form, "continued_by", None): 

253 bibjson.is_replaced_by = form.continued_by.data 

254 if getattr(form, "discontinued_date", None): 

255 bibjson.discontinued_date = form.discontinued_date.data 

256 

257 # subject information 

258 if getattr(form, "subject", None): 

259 new_subjects = [] 

260 incoming = form.subject.data 

261 if not isinstance(incoming, list): 

262 incoming = [x.strip() for x in form.subject.data.split(",")] 

263 for code in incoming: 

264 sobj = {"scheme": 'LCC', "term": lcc.lookup_code(code), "code": code} 

265 new_subjects.append(sobj) 

266 bibjson.subject = new_subjects 

267 

268 s2o = getattr(form, "s2o", None) 

269 if s2o is not None and (s2o.data == "y" or s2o.data is True): 

270 bibjson.add_label("s2o") 

271 

272 mirror = getattr(form, "mirror", None) 

273 if mirror is not None and (mirror.data == "y" or mirror.data is True): 

274 bibjson.add_label("mirror") 

275 

276 ojc = getattr(form, "ojc", None) 

277 if ojc is not None and (ojc.data == "y" or ojc.data is True): 

278 bibjson.add_label("ojc") 

279 

280 @classmethod 

281 def form2admin(cls, form, obj): 

282 import re 

283 if getattr(form, "notes", None): 

284 for formnote in form.notes.data: 

285 if formnote["note"]: 

286 note_date = formnote["note_date"] 

287 note_id = formnote["note_id"] 

288 obj.add_note(formnote["note"], date=note_date, id=note_id, 

289 author_id=formnote["note_author_id"]) 

290 

291 flag = getattr(form, "flags", None) 

292 if flag and flag["flag_note"].data: 

293 flag_date = flag["flag_created_date"].data 

294 try: 

295 if flag["flag_deadline"].data: 

296 flag_deadline = dates.parse(flag["flag_deadline"].data, format=dates.FMT_DATE_STD) 

297 else: 

298 flag_deadline = dates.far_in_the_future() 

299 except: 

300 # FIXME: why is there validation in the crosswalk? 

301 raise ValueError("Flag deadline must be a valid date in BigEnd format (ie. YYYY-MM-DD)") 

302 flag_assigned_to = flag["flag_assignee"].data 

303 author = flag["flag_setter"].data 

304 flag_author = author 

305 if author: 

306 flag_author = re.findall(r'\((.*?)\)', author)[0] 

307 print("id: ", flag_author) 

308 flag_id = flag["flag_note_id"].data 

309 flag_note = flag["flag_note"].data 

310 obj.add_note(flag_note, date=flag_date, id=flag_id, 

311 author_id=flag_author, assigned_to=flag_assigned_to, deadline=flag_deadline) 

312 

313 if getattr(form, 'owner', None): 

314 owner = form.owner.data 

315 if owner: 

316 owner = owner.strip() 

317 obj.set_owner(owner) 

318 

319 if getattr(form, 'editor_group', None): 

320 editor_group = form.editor_group.data 

321 if editor_group: 

322 editor_group = editor_group.strip() 

323 obj.set_editor_group(editor_group) 

324 

325 if getattr(form, "editor", None): 

326 editor = form.editor.data 

327 if editor: 

328 editor = editor.strip() 

329 obj.set_editor(editor) 

330 

331 if getattr(form, "last_full_review", None): 

332 lfr = form.last_full_review.data 

333 if lfr: 

334 lfr = lfr.strip() 

335 obj.last_full_review = lfr 

336 

337 @classmethod 

338 def bibjson2form(cls, bibjson, forminfo): 

339 from portality.models import JournalLikeBibJSON 

340 from portality.forms.application_forms import ApplicationFormFactory 

341 from portality.datasets import get_currency_code 

342 

343 assert isinstance(bibjson, JournalLikeBibJSON) 

344 

345 forminfo['alternative_title'] = bibjson.alternative_title 

346 

347 # when we crosswalk the apc currency we also have to check that it is current 

348 # so that we only present information to the form is the form is capable of 

349 # presenting it on to the user 

350 forminfo["apc_charges"] = [] 

351 for apc_record in bibjson.apc: 

352 currency = apc_record.get("currency") 

353 check = get_currency_code(currency, fail_if_not_found=True) 

354 if check is None: 

355 continue 

356 

357 forminfo["apc_charges"].append({ 

358 "apc_currency" : apc_record.get("currency"), 

359 "apc_max" : apc_record.get("price") 

360 }) 

361 

362 forminfo["apc_url"] = bibjson.apc_url 

363 

364 pres_choices = [x for x, y in ApplicationFormFactory.choices_for("preservation_service")] 

365 if bibjson.preservation_services is not None: 

366 forminfo["preservation_service"] = [x for x in bibjson.preservation_services if x in pres_choices] 

367 forminfo["preservation_service_other"] = " ".join([x for x in bibjson.preservation_services if x not in pres_choices]) 

368 if len(forminfo["preservation_service_other"]) > 0: 

369 forminfo["preservation_service"].append("other") 

370 if "preservation_service" not in forminfo: 

371 forminfo["preservation_service"] = [] 

372 if bibjson.preservation_library: 

373 forminfo["preservation_service_library"] = bibjson.preservation_library 

374 forminfo["preservation_service"].append("national_library") 

375 if bibjson.has_preservation is False and len(forminfo["preservation_service"]) == 0: 

376 forminfo["preservation_service"].append("none") 

377 

378 forminfo["preservation_service_url"] = bibjson.preservation_url 

379 if bibjson.author_retains_copyright is not None: 

380 forminfo["copyright_author_retains"] = "y" if bibjson.author_retains_copyright else "n" 

381 forminfo["copyright_url"] = bibjson.copyright_url 

382 

383 forminfo["publisher_name"] = bibjson.publisher_name 

384 forminfo["publisher_country"] = bibjson.publisher_country 

385 

386 dep_choices = [x for x, y in ApplicationFormFactory.choices_for("deposit_policy")] 

387 if bibjson.deposit_policy: 

388 forminfo["deposit_policy"] = [x for x in bibjson.deposit_policy if x in dep_choices] 

389 forminfo["deposit_policy_other"] = " ".join([x for x in bibjson.deposit_policy if x not in dep_choices]) 

390 if len(forminfo["deposit_policy_other"]) > 0: 

391 forminfo["deposit_policy"].append("other") 

392 if "deposit_policy" not in forminfo: 

393 forminfo["deposit_policy"] = [] 

394 if bibjson.has_deposit_policy is False and len(forminfo["deposit_policy"]) == 0: 

395 forminfo["deposit_policy"].append("none") 

396 

397 review_choices = [x for x, y in ApplicationFormFactory.choices_for("review_process")] 

398 if bibjson.editorial_review_process: 

399 forminfo["review_process"] = [x for x in bibjson.editorial_review_process if x in review_choices] 

400 forminfo["review_process_other"] = " ".join([x for x in bibjson.editorial_review_process if x not in review_choices]) 

401 if len(forminfo["review_process_other"]) > 0: 

402 forminfo["review_process"].append("other") 

403 

404 forminfo["review_url"] = bibjson.editorial_review_url 

405 forminfo["pissn"] = bibjson.pissn 

406 forminfo["eissn"] = bibjson.eissn 

407 

408 if bibjson.institution_name: 

409 forminfo["institution_name"] = bibjson.institution_name 

410 if bibjson.institution_country: 

411 forminfo["institution_country"] = bibjson.institution_country 

412 

413 forminfo['keywords'] = bibjson.keywords # fixme: all keywords are being rendered as one single item 

414 forminfo['language'] = bibjson.language 

415 

416 license_attributes = [] 

417 ltypes = [] 

418 for l in bibjson.licenses: 

419 ltypes.append(l.get("type")) 

420 if l.get("type") == "Publisher's own license": 

421 if l.get("BY"): license_attributes.append("BY") 

422 if l.get("SA"): license_attributes.append("SA") 

423 if l.get("NC"): license_attributes.append("NC") 

424 if l.get("ND"): license_attributes.append("ND") 

425 forminfo["license_attributes"] = license_attributes 

426 forminfo["license"] = ltypes 

427 

428 if bibjson.article_license_display is not None and len(bibjson.article_license_display) > 0: 

429 forminfo["license_display"] = "y" if "Embed" in bibjson.article_license_display else "n" 

430 forminfo["license_display_example_url"] = bibjson.article_license_display_example_url 

431 if bibjson.boai is not None: 

432 forminfo["boai"] = 'y' if bibjson.boai else 'n' 

433 forminfo["license_terms_url"] = bibjson.license_terms_url 

434 if bibjson.oa_start: 

435 forminfo["oa_start"] = bibjson.oa_start 

436 forminfo["oa_statement_url"] = bibjson.oa_statement_url 

437 forminfo["journal_url"] = bibjson.journal_url 

438 forminfo["aims_scope_url"] = bibjson.aims_scope_url 

439 forminfo["editorial_board_url"] = bibjson.editorial_board_url 

440 forminfo["author_instructions_url"] = bibjson.author_instructions_url 

441 forminfo["waiver_url"] = bibjson.waiver_url 

442 

443 pid_choices = [x for x, y in ApplicationFormFactory.choices_for("persistent_identifiers")] 

444 if bibjson.pid_scheme: 

445 forminfo["persistent_identifiers"] = [x for x in bibjson.pid_scheme if x in pid_choices] 

446 forminfo["persistent_identifiers_other"] = " ".join([x for x in bibjson.pid_scheme if x not in pid_choices]) 

447 if len(forminfo["persistent_identifiers_other"]) > 0: 

448 forminfo["persistent_identifiers"].append("other") 

449 if bibjson.has_pid_scheme is False: # distinct from None 

450 forminfo["persistent_identifiers"] = ["none"] 

451 

452 if bibjson.plagiarism_detection is not None: 

453 forminfo["plagiarism_detection"] = "y" if bibjson.plagiarism_detection else "n" 

454 forminfo["plagiarism_url"] = bibjson.plagiarism_url 

455 forminfo["publication_time_weeks"] = bibjson.publication_time_weeks 

456 forminfo["other_charges_url"] = bibjson.other_charges_url 

457 forminfo['title'] = bibjson.title 

458 

459 # FIXME: these translations don't handle partial records (i.e. drafts) 

460 # we may want to add some methods to allow the settedness of these fields to be checked 

461 if bibjson.has_apc is not None: 

462 forminfo["apc"] = "y" if bibjson.has_apc else "n" 

463 if bibjson.has_other_charges is not None: 

464 forminfo["has_other_charges"] = "y" if bibjson.has_other_charges else "n" 

465 if bibjson.has_waiver is not None: 

466 forminfo["has_waiver"] = "y" if bibjson.has_waiver else "n" 

467 

468 forminfo["deposit_policy_url"] = bibjson.deposit_policy_url 

469 

470 # continuation information 

471 forminfo["continues"] = bibjson.replaces 

472 forminfo["continued_by"] = bibjson.is_replaced_by 

473 forminfo["discontinued_date"] = bibjson.discontinued_date 

474 

475 # subject classifications 

476 forminfo['subject'] = [] 

477 for s in bibjson.subject: 

478 if "code" in s: 

479 forminfo['subject'].append(s['code']) 

480 

481 # labels 

482 forminfo['s2o'] = "s2o" in bibjson.labels 

483 forminfo['mirror'] = "mirror" in bibjson.labels 

484 forminfo['ojc'] = "ojc" in bibjson.labels 

485 

486 @classmethod 

487 def admin2form(cls, obj, forminfo): 

488 forminfo['notes'] = [] 

489 for n in obj.ordered_notes_except_flags: 

490 author_id = n.get('author_id', '') 

491 note_author_name = f'{Account.get_name_safe(author_id)} ({author_id})' if author_id else '' 

492 note_obj = {'note': n['note'], 'note_date': n['date'], 'note_id': n['id'], 

493 'note_author': note_author_name, 

494 'note_author_id': author_id, 

495 } 

496 forminfo['notes'].append(note_obj) 

497 

498 forminfo["flags"] = [] 

499 if obj.flags: 

500 # display only the newest flag 

501 flag = obj.flags[0] 

502 author_id = flag["author_id"] 

503 flag_setter = f'{Account.get_name_safe(author_id)} ({author_id})' if author_id else '' 

504 deadline = flag["flag"].get("deadline") 

505 flag_deadline = ( 

506 deadline if (deadline and deadline != dates.far_in_the_future()) else "" 

507 ) 

508 flag_assignee = flag["flag"]["assigned_to"] 

509 flag_obj = {"flag_created_date": flag["date"], "flag_note": flag["note"], 

510 "flag_note_id": flag["id"], "flag_setter": flag_setter, "flag_assignee": flag_assignee, 

511 "flag_deadline": flag_deadline } 

512 forminfo['flags'].append(flag_obj) 

513 forminfo["flags"] = flag_obj 

514 

515 forminfo['owner'] = obj.owner 

516 if obj.editor_group is not None: 

517 forminfo['editor_group'] = obj.editor_group 

518 if obj.editor is not None: 

519 forminfo['editor'] = obj.editor 

520 

521 if getattr(obj, "last_full_review", None): 

522 forminfo["last_full_review"] = obj.last_full_review 

523 

524 

525class JournalFormXWalk(JournalGenericXWalk): 

526 

527 @classmethod 

528 def form2obj(cls, form): 

529 journal = models.Journal() 

530 bibjson = journal.bibjson() 

531 

532 # first do the generic crosswalk to bibjson 

533 cls.form2bibjson(form, bibjson) 

534 

535 # then do the admin fields 

536 cls.form2admin(form, journal) 

537 

538 return journal 

539 

540 @classmethod 

541 def obj2form(cls, obj): 

542 forminfo = {} 

543 bibjson = obj.bibjson() 

544 

545 cls.bibjson2form(bibjson, forminfo) 

546 cls.admin2form(obj, forminfo) 

547 

548 return forminfo