Coverage for portality/models/v1/journal.py: 0%

1from portality.dao import DomainObject 

2from portality.core import app 

3from portality.models.v1.bibjson import GenericBibJSON 

4from portality.models.v1 import shared_structs 

5from portality.lib import dataobj, es_data_mapping, dates 

6from portality import datasets 

7 

8from copy import deepcopy 

9from datetime import datetime 

10 

11import string 

12from unidecode import unidecode 

13 

14class ContinuationException(Exception): 

15 pass 

16 

17class JournalLikeObject(dataobj.DataObj, DomainObject): 

18 

19 @classmethod 

20 def find_by_issn(cls, issns, in_doaj=None, max=10): 

21 if not isinstance(issns, list): 

22 issns = [issns] 

23 q = JournalQuery() 

24 q.find_by_issn(issns, in_doaj=in_doaj, max=max) 

25 result = cls.query(q=q.query) 

26 # create an arry of objects, using cls rather than Journal, which means subclasses can use it too (i.e. Suggestion) 

27 records = [cls(**r.get("_source")) for r in result.get("hits", {}).get("hits", [])] 

28 return records 

29 

30 @classmethod 

31 def issns_by_owner(cls, owner): 

32 q = IssnQuery(owner) 

33 res = cls.query(q=q.query()) 

34 issns = [term.get("keys") for term in res.get("aggregations", {}).get("issns", {}).get("buckets", [])] 

35 return issns 

36 

37 @classmethod 

38 def issns_by_query(cls, query): 

39 issns = [] 

40 for j in cls.iterate(query): 

41 issns += j.known_issns() 

42 return issns 

43 

44 ############################################ 

45 ## base property methods 

46 

47 @property 

48 def id(self): 

49 return self._get_single("id") 

50 

51 def set_id(self, id=None): 

52 if id is None: 

53 id = self.makeid() 

54 self._set_with_struct("id", id) 

55 

56 def set_created(self, date=None): 

57 if date is None: 

58 date = dates.now() 

59 self._set_with_struct("created_date", date) 

60 

61 @property 

62 def created_date(self): 

63 return self._get_single("created_date") 

64 

65 @property 

66 def created_timestamp(self): 

67 return self._get_single("created_date", coerce=dataobj.to_datestamp()) 

68 

69 def set_last_updated(self, date=None): 

70 if date is None: 

71 date = dates.now() 

72 self._set_with_struct("last_updated", date) 

73 

74 @property 

75 def last_updated(self): 

76 return self._get_single("last_updated") 

77 

78 @property 

79 def last_updated_timestamp(self): 

80 return self._get_single("last_updated", coerce=dataobj.to_datestamp()) 

81 

82 def bibjson(self): 

83 bj = self._get_single("bibjson") 

84 if bj is None: 

85 self._set_single("bibjson", {}) 

86 bj = self._get_single("bibjson") 

87 return JournalBibJSON(bj) 

88 

89 def set_bibjson(self, bibjson): 

90 bibjson = bibjson.data if isinstance(bibjson, JournalBibJSON) else bibjson 

91 self._set_with_struct("bibjson", bibjson) 

92 

93 def set_last_manual_update(self, date=None): 

94 if date is None: 

95 date = dates.now() 

96 self._set_with_struct("last_manual_update", date) 

97 

98 @property 

99 def last_manual_update(self): 

100 return self._get_single("last_manual_update") 

101 

102 @property 

103 def last_manual_update_timestamp(self): 

104 return self._get_single("last_manual_update", coerce=dataobj.to_datestamp()) 

105 

106 def has_been_manually_updated(self): 

107 return self.last_manual_update_timestamp > datetime.utcfromtimestamp(0) 

108 

109 def contacts(self): 

110 return self._get_single("admin.contact") 

111 

112 def get_latest_contact_name(self): 

113 try: 

114 contact = self.contacts()[-1] 

115 except IndexError as e: 

116 return "" 

117 return contact.get("name", "") 

118 

119 def get_latest_contact_email(self): 

120 try: 

121 contact = self.contacts()[-1] 

122 except IndexError as e: 

123 return "" 

124 return contact.get("email", "") 

125 

126 def add_contact(self, name, email): 

127 self._add_to_list_with_struct("admin.contact", {"name" : name, "email" : email}) 

128 

129 def remove_contacts(self): 

130 self._delete("admin.contact") 

131 

132 def add_note(self, note, date=None): 

133 if date is None: 

134 date = dates.now() 

135 obj = {"date" : date, "note" : note} 

136 self._delete_from_list("admin.notes", matchsub=obj) 

137 self._add_to_list_with_struct("admin.notes", obj) 

138 

139 def remove_note(self, note): 

140 self._delete_from_list("admin.notes", matchsub=note) 

141 

142 def set_notes(self, notes): 

143 self._set_with_struct("admin.notes", notes) 

144 

145 def remove_notes(self): 

146 self._delete("admin.notes") 

147 

148 @property 

149 def notes(self): 

150 return self._get_list("admin.notes") 

151 

152 @property 

153 def ordered_notes(self): 

154 notes = self.notes 

155 clusters = {} 

156 for note in notes: 

157 if note["date"] not in clusters: 

158 clusters[note["date"]] = [note] 

159 else: 

160 clusters[note["date"]].append(note) 

161 ordered_keys = sorted(list(clusters.keys()), reverse=True) 

162 ordered = [] 

163 for key in ordered_keys: 

164 clusters[key].reverse() 

165 ordered += clusters[key] 

166 return ordered 

167 # return sorted(notes, key=lambda x: x["date"], reverse=True) 

168 

169 @property 

170 def owner(self): 

171 return self._get_single("admin.owner") 

172 

173 def set_owner(self, owner): 

174 self._set_with_struct("admin.owner", owner) 

175 

176 def remove_owner(self): 

177 self._delete("admin.owner") 

178 

179 @property 

180 def editor_group(self): 

181 return self._get_single("admin.editor_group") 

182 

183 def set_editor_group(self, eg): 

184 self._set_with_struct("admin.editor_group", eg) 

185 

186 def remove_editor_group(self): 

187 self._delete("admin.editor_group") 

188 

189 @property 

190 def editor(self): 

191 return self._get_single("admin.editor") 

192 

193 def set_editor(self, ed): 

194 self._set_with_struct("admin.editor", ed) 

195 

196 def remove_editor(self): 

197 self._delete('admin.editor') 

198 

199 def known_issns(self): 

200 """ 

201 DEPRECATED 

202 

203 all issns this journal is known by 

204 

205 This used to mean "all issns the journal has ever been known by", but that definition has changed since 

206 continuations have been separated from the single journal object model. 

207 

208 Now this is just a proxy for self.bibjson().issns() 

209 """ 

210 return self.bibjson().issns() 

211 

212 def has_seal(self): 

213 return self._get_single("admin.seal", default=False) 

214 

215 def set_seal(self, value): 

216 self._set_with_struct("admin.seal", value) 

217 

218 @property 

219 def bulk_upload_id(self): 

220 return self._get_single("admin.bulk_upload") 

221 

222 def set_bulk_upload_id(self, bulk_upload_id): 

223 self._set_with_struct("admin.bulk_upload", bulk_upload_id) 

224 

225 ###################################################### 

226 ## internal utility methods 

227 

228 def _generate_index(self): 

229 # the index fields we are going to generate 

230 issns = [] 

231 titles = [] 

232 subjects = [] 

233 schema_subjects = [] 

234 schema_codes = [] 

235 classification = [] 

236 langs = [] 

237 country = None 

238 license = [] 

239 publisher = [] 

240 urls = {} 

241 has_seal = None 

242 classification_paths = [] 

243 unpunctitle = None 

244 asciiunpunctitle = None 

245 continued = "No" 

246 has_editor_group = "No" 

247 has_editor = "No" 

248 

249 # the places we're going to get those fields from 

250 cbib = self.bibjson() 

251 

252 # get the issns out of the current bibjson 

253 issns += cbib.get_identifiers(cbib.P_ISSN) 

254 issns += cbib.get_identifiers(cbib.E_ISSN) 

255 

256 # get the title out of the current bibjson 

257 if cbib.title is not None: 

258 titles.append(cbib.title) 

259 

260 # get the subjects and concatenate them with their schemes from the current bibjson 

261 for subs in cbib.subjects(): 

262 scheme = subs.get("scheme") 

263 term = subs.get("term") 

264 subjects.append(term) 

265 schema_subjects.append(scheme + ":" + term) 

266 classification.append(term) 

267 if "code" in subs: 

268 schema_codes.append(scheme + ":" + subs.get("code")) 

269 

270 # add the keywords to the non-schema subjects (but not the classification) 

271 subjects += cbib.keywords 

272 

273 # get the bibjson object to convert the languages to the english form 

274 langs = cbib.language_name() 

275 

276 # get the english name of the country 

277 country = cbib.country_name() 

278 

279 # get the title of the license 

280 lic = cbib.get_license() 

281 if lic is not None: 

282 license.append(lic.get("title")) 

283 

284 # copy the publisher/institution 

285 if cbib.publisher: 

286 publisher.append(cbib.publisher) 

287 if cbib.institution: 

288 publisher.append(cbib.institution) 

289 

290 # extract and convert all of the urls by their type 

291 links = cbib.get_urls() 

292 for link in links: 

293 lt = link.get("type") 

294 if lt is not None: 

295 urls[lt + "_url"] = link.get("url") 

296 

297 # deduplicate the lists 

298 issns = list(set(issns)) 

299 titles = list(set(titles)) 

300 subjects = list(set(subjects)) 

301 schema_subjects = list(set(schema_subjects)) 

302 classification = list(set(classification)) 

303 license = list(set(license)) 

304 publisher = list(set(publisher)) 

305 schema_codes = list(set(schema_codes)) 

306 

307 # determine if the seal is applied 

308 has_seal = "Yes" if self.has_seal() else "No" 

309 

310 # get the full classification paths for the subjects 

311 classification_paths = cbib.lcc_paths() 

312 

313 # create an unpunctitle 

314 if cbib.title is not None: 

315 throwlist = string.punctuation + '\n\t' 

316 unpunctitle = "".join(c for c in cbib.title if c not in throwlist).strip() 

317 try: 

318 asciiunpunctitle = unidecode(unpunctitle) 

319 except: 

320 asciiunpunctitle = unpunctitle 

321 

322 # record if this journal object is a continuation 

323 if len(cbib.replaces) > 0 or len(cbib.is_replaced_by) > 0: 

324 continued = "Yes" 

325 

326 if self.editor_group is not None: 

327 has_editor_group = "Yes" 

328 

329 if self.editor is not None: 

330 has_editor = "Yes" 

331 

332 # build the index part of the object 

333 index = {} 

334 if len(issns) > 0: 

335 index["issn"] = issns 

336 if len(titles) > 0: 

337 index["title"] = titles 

338 if len(subjects) > 0: 

339 index["subject"] = subjects 

340 if len(schema_subjects) > 0: 

341 index["schema_subject"] = schema_subjects 

342 if len(classification) > 0: 

343 index["classification"] = classification 

344 if len(publisher) > 0: 

345 index["publisher"] = publisher 

346 if len(license) > 0: 

347 index["license"] = license 

348 if len(langs) > 0: 

349 index["language"] = langs 

350 if country is not None: 

351 index["country"] = country 

352 if len(schema_codes) > 0: 

353 index["schema_code"] = schema_codes 

354 if len(list(urls.keys())) > 0: 

355 index.update(urls) 

356 if has_seal: 

357 index["has_seal"] = has_seal 

358 if len(classification_paths) > 0: 

359 index["classification_paths"] = classification_paths 

360 if unpunctitle is not None: 

361 index["unpunctitle"] = unpunctitle 

362 if asciiunpunctitle is not None: 

363 index["asciiunpunctitle"] = asciiunpunctitle 

364 index["continued"] = continued 

365 index["has_editor_group"] = has_editor_group 

366 index["has_editor"] = has_editor 

367 self._set_with_struct("index", index) 

368 

369class Journal(JournalLikeObject): 

370 __type__ = "journal" 

371 

372 def __init__(self, **kwargs): 

373 # FIXME: hack, to deal with ES integration layer being improperly abstracted 

374 if "_source" in kwargs: 

375 kwargs = kwargs["_source"] 

376 self._add_struct(shared_structs.SHARED_BIBJSON) 

377 self._add_struct(shared_structs.JOURNAL_BIBJSON_EXTENSION) 

378 self._add_struct(JOURNAL_STRUCT) 

379 super(Journal, self).__init__(raw=kwargs) 

380 

381 ##################################################### 

382 ## Journal-specific data access methods 

383 

384 @classmethod 

385 def all_in_doaj(cls, page_size=5000): 

386 q = JournalQuery() 

387 return cls.iterate(q.all_in_doaj(), page_size=page_size, wrap=True) 

388 

389 @classmethod 

390 def find_by_publisher(cls, publisher, exact=True): 

391 q = PublisherQuery(publisher, exact) 

392 result = cls.query(q=q.query()) 

393 records = [Journal(**r.get("_source")) for r in result.get("hits", {}).get("hits", [])] 

394 return records 

395 

396 @classmethod 

397 def find_by_title(cls, title): 

398 q = TitleQuery(title) 

399 result = cls.query(q=q.query()) 

400 records = [Journal(**r.get("_source")) for r in result.get("hits", {}).get("hits", [])] 

401 return records 

402 

403 @classmethod 

404 def delete_selected(cls, query, articles=False, snapshot_journals=True, snapshot_articles=True): 

405 if articles: 

406 # list the issns of all the journals 

407 issns = cls.issns_by_query(query) 

408 

409 # issue a delete request over all the articles by those issns 

410 from portality.models import Article 

411 Article.delete_by_issns(issns, snapshot=snapshot_articles) 

412 

413 # snapshot the journal record 

414 if snapshot_journals: 

415 js = cls.iterate(query, page_size=1000) 

416 for j in js: 

417 j.snapshot() 

418 

419 # finally issue a delete request against the journals 

420 cls.delete_by_query(query) 

421 

422 def all_articles(self): 

423 from portality.models import Article 

424 return Article.find_by_issns(self.known_issns()) 

425 

426 def article_stats(self): 

427 from portality.models import Article 

428 q = ArticleStatsQuery(self.known_issns()) 

429 data = Article.query(q=q.query()) 

430 hits = data.get("hits", {}) 

431 total = hits.get("total", {}).get('value', 0) 

432 latest = None 

433 if total > 0: 

434 latest = hits.get("hits", [])[0].get("_source").get("created_date") 

435 return { 

436 "total" : total, 

437 "latest" : latest 

438 } 

439 

440 def mappings(self): 

441 return es_data_mapping.create_mapping(self.get_struct(), MAPPING_OPTS) 

442 

443 ############################################ 

444 ## base property methods 

445 

446 @property 

447 def toc_id(self): 

448 bibjson = self.bibjson() 

449 id_ = bibjson.get_one_identifier(bibjson.E_ISSN) 

450 if not id_: 

451 id_ = bibjson.get_one_identifier(bibjson.P_ISSN) 

452 if not id_: 

453 id_ = self.id 

454 return id_ 

455 

456 @property 

457 def last_update_request(self): 

458 related = self.related_applications 

459 if len(related) == 0: 

460 return None 

461 sorted(related, key=lambda x : x.get("date_accepted", "1970-01-01T00:00:00Z")) 

462 return related[0].get("date_accepted", "1970-01-01T00:00:00Z") 

463 

464 ############################################################ 

465 ## revision history methods 

466 

467 def snapshot(self): 

468 from portality.models import JournalHistory 

469 

470 snap = deepcopy(self.data) 

471 if "id" in snap: 

472 snap["about"] = snap["id"] 

473 del snap["id"] 

474 if "index" in snap: 

475 del snap["index"] 

476 if "last_updated" in snap: 

477 del snap["last_updated"] 

478 if "created_date" in snap: 

479 del snap["created_date"] 

480 

481 hist = JournalHistory(**snap) 

482 hist.save() 

483 

484 ####################################################################### 

485 ## Conversion methods 

486 

487 def make_continuation(self, type, eissn=None, pissn=None, title=None): 

488 # check that the type is one we know. Must be either 'replaces' or 'is_replaced_by' 

489 if type not in ["replaces", "is_replaced_by"]: 

490 raise ContinuationException("type must be one of 'replaces' or 'is_replaced_by'") 

491 

492 if eissn is None and pissn is None: 

493 raise ContinuationException("You must create a continuation with at least one issn") 

494 

495 # take a copy of the raw data for this journal, and the issns for this journal 

496 raw_cont = deepcopy(self.data) 

497 bibjson = self.bibjson() 

498 issns = bibjson.issns() 

499 cissns = [] 

500 

501 # make a new instance of the journal - this will be our continuation 

502 del raw_cont["id"] 

503 del raw_cont["created_date"] 

504 del raw_cont["last_updated"] 

505 j = Journal(**raw_cont) 

506 

507 # ensure that the journal is NOT in doaj. That will be for the admin to decide 

508 j.set_in_doaj(False) 

509 

510 # get a copy of the continuation's bibjson, then remove the existing issns 

511 cbj = j.bibjson() 

512 cbj.remove_identifiers(cbj.E_ISSN) 

513 cbj.remove_identifiers(cbj.P_ISSN) 

514 

515 # also remove any existing continuation information 

516 del cbj.replaces 

517 del cbj.is_replaced_by 

518 del cbj.discontinued_date 

519 

520 # now write the new identifiers 

521 if eissn is not None and eissn != "": 

522 cissns.append(eissn) 

523 cbj.add_identifier(cbj.E_ISSN, eissn) 

524 if pissn is not None and pissn != "": 

525 cissns.append(pissn) 

526 cbj.add_identifier(cbj.P_ISSN, pissn) 

527 

528 # update the title 

529 if title is not None: 

530 cbj.title = title 

531 

532 # now add the issns of the original journal in the appropriate field 

533 # 

534 # This is a bit confusing - because we're asking this of a Journal object, the relationship type we're asking 

535 # for relates to this journal, not to the continuation we are creating. This means that when setting the 

536 # new continuations properties, we have to do the opposite to what we do to the journal's properties 

537 # 

538 # "replaces" means that the current journal replaces the new continuation 

539 if type == "replaces": 

540 bibjson.replaces = cissns 

541 cbj.is_replaced_by = issns 

542 

543 # "is_replaced_by" means that the current journal is replaced by the new continuation 

544 elif type == "is_replaced_by": 

545 bibjson.is_replaced_by = cissns 

546 cbj.replaces = issns 

547 

548 # save this journal 

549 self.save() 

550 

551 # save the continuation, and return a copy to the caller 

552 j.save() 

553 return j 

554 

555 #################################################### 

556 ## admin data methods 

557 

558 def is_in_doaj(self): 

559 return self._get_single("admin.in_doaj", default=False) 

560 

561 def set_in_doaj(self, value): 

562 self._set_with_struct("admin.in_doaj", value) 

563 

564 @property 

565 def current_application(self): 

566 return self._get_single("admin.current_application") 

567 

568 def set_current_application(self, application_id): 

569 self._set_with_struct("admin.current_application", application_id) 

570 

571 def remove_current_application(self): 

572 self._delete("admin.current_application") 

573 

574 @property 

575 def related_applications(self): 

576 return self._get_list("admin.related_applications") 

577 

578 def add_related_application(self, application_id, date_accepted=None, status=None): 

579 obj = {"application_id" : application_id} 

580 self._delete_from_list("admin.related_applications", matchsub=obj) 

581 if date_accepted is not None: 

582 obj["date_accepted"] = date_accepted 

583 if status is not None: 

584 obj["status"] = status 

585 self._add_to_list_with_struct("admin.related_applications", obj) 

586 

587 def set_related_applications(self, related_applications_records): 

588 self._set_with_struct("admin.related_applications", related_applications_records) 

589 

590 def remove_related_applications(self): 

591 self._delete("admin.related_applications") 

592 

593 def related_application_record(self, application_id): 

594 for record in self.related_applications: 

595 if record.get("application_id") == application_id: 

596 return record 

597 return None 

598 

599 def latest_related_application_id(self): 

600 related = self.related_applications 

601 if len(related) == 0: 

602 return None 

603 if len(related) == 1: 

604 return related[0].get("application_id") 

605 sorted(related, key=lambda x: x.get("date_accepted", "1970-01-01T00:00:00Z")) 

606 return related[0].get("application_id") 

607 

608 def is_ticked(self): 

609 return self._get_single("admin.ticked", default=False) 

610 

611 def set_ticked(self, ticked): 

612 self._set_with_struct("admin.ticked", ticked) 

613 

614 @property 

615 def toc_id(self): 

616 bibjson = self.bibjson() 

617 id_ = bibjson.get_one_identifier(bibjson.E_ISSN) 

618 if not id_: 

619 id_ = bibjson.get_one_identifier(bibjson.P_ISSN) 

620 if not id_: 

621 id_ = self.id 

622 return id_ 

623 

624 ######################################################################## 

625 ## Functions for handling continuations 

626 

627 def get_future_continuations(self): 

628 irb = self.bibjson().is_replaced_by 

629 q = ContinuationQuery(irb) 

630 

631 future = [] 

632 journals = self.q2obj(q=q.query()) 

633 subjournals = [] 

634 for j in journals: 

635 subjournals += j.get_future_continuations() 

636 

637 future = journals + subjournals 

638 return future 

639 

640 def get_past_continuations(self): 

641 replaces = self.bibjson().replaces 

642 q = ContinuationQuery(replaces) 

643 

644 past = [] 

645 journals = self.q2obj(q=q.query()) 

646 subjournals = [] 

647 for j in journals: 

648 subjournals += j.get_past_continuations() 

649 

650 past = journals + subjournals 

651 return past 

652 

653 ####################################################################### 

654 

655 ##################################################### 

656 ## operations we can do to the journal 

657 

658 def calculate_tick(self): 

659 created_date = self.created_date 

660 last_update_request = self.last_update_request 

661 

662 tick_threshold = app.config.get("TICK_THRESHOLD", '2014-03-19T00:00:00Z') 

663 threshold = datetime.strptime(tick_threshold, "%Y-%m-%dT%H:%M:%SZ") 

664 

665 if created_date is None: # don't worry about the last_update_request date - you can't update unless you've been created! 

666 # we haven't even saved the record yet. All we need to do is check that the tick 

667 # threshold is in the past (which I suppose theoretically it could not be), then 

668 # set it 

669 if datetime.utcnow() >= threshold: 

670 self.set_ticked(True) 

671 else: 

672 self.set_ticked(False) 

673 return 

674 

675 # otherwise, this is an existing record, and we just need to update it 

676 

677 # convert the strings to datetime objects 

678 created = datetime.strptime(created_date, "%Y-%m-%dT%H:%M:%SZ") 

679 lud = None 

680 if last_update_request is not None: 

681 lud = datetime.strptime(last_update_request, "%Y-%m-%dT%H:%M:%SZ") 

682 

683 if created >= threshold and self.is_in_doaj(): 

684 self.set_ticked(True) 

685 return 

686 

687 if lud is not None and lud >= threshold and self.is_in_doaj(): 

688 self.set_ticked(True) 

689 return 

690 

691 self.set_ticked(False) 

692 

693 def propagate_in_doaj_status_to_articles(self): 

694 for article in self.all_articles(): 

695 article.set_in_doaj(self.is_in_doaj()) 

696 article.save() 

697 

698 def prep(self): 

699 self._ensure_in_doaj() 

700 self.calculate_tick() 

701 self._generate_index() 

702 self._calculate_has_apc() 

703 self._generate_autocompletes() 

704 self.set_last_updated() 

705 

706 def save(self, snapshot=True, sync_owner=True, **kwargs): 

707 self.prep() 

708 self.check_construct() 

709 if sync_owner: 

710 self._sync_owner_to_application() 

711 res = super(Journal, self).save(**kwargs) 

712 if snapshot: 

713 self.snapshot() 

714 return res 

715 

716 ###################################################### 

717 ## internal utility methods 

718 

719 def _generate_autocompletes(self): 

720 bj = self.bibjson() 

721 publisher = bj.publisher 

722 institution = bj.institution 

723 provider = bj.provider 

724 

725 if publisher is not None: 

726 self._set_with_struct("index.publisher_ac", publisher.lower()) 

727 

728 if institution is not None: 

729 self._set_with_struct("index.institution_ac", institution.lower()) 

730 

731 if provider is not None: 

732 self._set_with_struct("index.provider_ac", provider.lower()) 

733 

734 def _calculate_has_apc(self): 

735 # work out of the journal has an apc 

736 has_apc = "No Information" 

737 apc_field_present = len(list(self.bibjson().apc.keys())) > 0 

738 if apc_field_present: 

739 has_apc = "Yes" 

740 elif self.is_ticked(): 

741 has_apc = "No" 

742 

743 self._set_with_struct("index.has_apc", has_apc) 

744 

745 def _ensure_in_doaj(self): 

746 # switching active to false takes the item out of the DOAJ 

747 # though note that switching active to True does not put something IN the DOAJ 

748 if not self.bibjson().active: 

749 self.set_in_doaj(False) 

750 

751 def _sync_owner_to_application(self): 

752 if self.current_application is None: 

753 return 

754 from portality.models import Suggestion 

755 ca = Suggestion.pull(self.current_application) 

756 if ca is not None and ca.owner != self.owner: 

757 ca.set_owner(self.owner) 

758 ca.save(sync_owner=False) 

759 

760 

761class JournalBibJSON(GenericBibJSON): 

762 def __init__(self, bibjson=None): 

763 self._add_struct(shared_structs.SHARED_BIBJSON.get("structs", {}).get("bibjson")) 

764 self._add_struct(shared_structs.JOURNAL_BIBJSON_EXTENSION.get("structs", {}).get("bibjson")) 

765 super(JournalBibJSON, self).__init__(bibjson) 

766 

767 ############################################################ 

768 # journal-specific simple property getter and setters 

769 

770 @property 

771 def alternative_title(self): 

772 return self._get_single("alternative_title") 

773 

774 @alternative_title.setter 

775 def alternative_title(self, val): 

776 self._set_with_struct("alternative_title", val) 

777 

778 @property 

779 def author_pays_url(self): 

780 return self._get_single("author_pays_url") 

781 

782 @author_pays_url.setter 

783 def author_pays_url(self, val): 

784 self._set_with_struct("author_pays_url", val) 

785 

786 @property 

787 def author_pays(self): 

788 return self._get_single("author_pays") 

789 

790 @author_pays.setter 

791 def author_pays(self, val): 

792 self._set_with_struct("author_pays", val) 

793 

794 @author_pays.deleter 

795 def author_pays(self): 

796 self._delete("author_pays") 

797 

798 @property 

799 def country(self):