Coverage for apps/ptf/cmds/database_cmds.py: 61%

1157 statements  

« prev     ^ index     » next       coverage.py v7.3.2, created at 2024-02-28 09:09 +0000

1from unidecode import unidecode 

2 

3from django.conf import settings 

4from django.db.models import Q 

5from django.utils import timezone 

6 

7from ptf import exceptions 

8from ptf import model_helpers 

9 

10from ..models import Abstract 

11from ..models import Article 

12from ..models import Author 

13from ..models import Award 

14from ..models import BibItem 

15from ..models import BibItemId 

16from ..models import Collection 

17from ..models import CollectionMembership 

18from ..models import Container 

19from ..models import Contrib 

20from ..models import ContribAddress 

21from ..models import Contribution 

22from ..models import DataStream 

23from ..models import ExtId 

24from ..models import ExtLink 

25from ..models import FrontMatter 

26from ..models import Kwd 

27from ..models import MetaDataPart 

28from ..models import Provider 

29from ..models import PtfSite 

30from ..models import Publisher 

31from ..models import RelatedObject 

32from ..models import RelationName 

33from ..models import Relationship 

34from ..models import ResourceCount 

35from ..models import ResourceId 

36from ..models import SiteMembership 

37from ..models import Stats 

38from ..models import Subj 

39from ..models import SupplementaryMaterial 

40from ..models import TranslatedArticle 

41from ..models import XmlBase 

42from ..models import parse_page_count 

43from .base_cmds import baseCmd 

44from .base_cmds import make_int 

45 

46# TODO: call full_clean before each .save() call to validate a Model object 

47# It requires to update models.py and add some blank=True to fields that can be null/empty 

48# Example: number and vseries for a Container 

49 

50 

51def get_first_letter(name): 

52 letter = "" 

53 if name: 

54 letter = name[0] 

55 letter = unidecode(letter) 

56 if len(letter) > 1: 

57 letter = letter[0] 

58 letter = letter.upper() 

59 if letter == "?": 

60 letter = "Z" 

61 

62 # with 't Hooft, G => first_letter is H 

63 if name.startswith("'t") and len(name) > 3: 

64 letter = name[3].upper() 

65 

66 return letter 

67 

68 

69def add_contributors(contributors, resource=None, bibitem=None): 

70 if resource is None and bibitem is None: 70 ↛ 71line 70 didn't jump to line 71, because the condition on line 70 was never true

71 raise RuntimeError("add_contributors: resource and bibitem are None") 

72 

73 seq = 0 

74 for contrib in contributors: 

75 seq += 1 

76 

77 contrib["seq"] = seq 

78 contribution_fields_list = Contribution.get_fields_list() 

79 contributions_fields = { 

80 key: contrib[key] for key in contribution_fields_list if key in contrib 

81 } 

82 

83 contribution = Contribution(resource=resource, bibitem=bibitem, **contributions_fields) 

84 contribution.save() 

85 

86 for addr in contrib["addresses"]: 

87 contrib_address = ContribAddress(contribution=contribution, address=addr) 

88 contrib_address.save() 

89 

90 if bibitem is None and contribution.role == "author" and not contribution.is_etal(): 

91 ref_name = contribution.mid if contribution.mid else str(contribution) 

92 try: 

93 author = Author.objects.get(name=ref_name) 

94 author.count += 1 

95 except Author.DoesNotExist: 

96 letter = ref_name[0] 

97 letter = unidecode(letter) 

98 if len(letter) > 1: 98 ↛ 99line 98 didn't jump to line 99, because the condition on line 98 was never true

99 letter = letter[0] 

100 letter = letter.upper() 

101 if letter == "?": 101 ↛ 102line 101 didn't jump to line 102, because the condition on line 101 was never true

102 letter = "Z" 

103 

104 # with 't Hooft, G => first_letter is H 

105 if ref_name.startswith("'t") and len(ref_name) > 3: 105 ↛ 106line 105 didn't jump to line 106, because the condition on line 105 was never true

106 letter = ref_name[3].upper() 

107 

108 author = Author(name=ref_name, first_letter=letter, count=1) 

109 author.save() 

110 

111 

112def add_counts(xobj, resource, add_total=False): 

113 seq = 1 

114 for name, value in xobj.counts: 

115 try: 

116 ResourceCount.objects.get(resource=resource, name=name) 

117 raise exceptions.ResourceExists(f"The ResourceCount {name} already exists") 

118 except ResourceCount.DoesNotExist: 

119 resource_count = ResourceCount(resource=resource, name=name, seq=seq, value=value) 

120 

121 resource_count.save() 

122 

123 if name == "page-count" and add_total: 123 ↛ 134line 123 didn't jump to line 134, because the condition on line 123 was never false

124 value = parse_page_count(value) 

125 

126 try: 

127 total = Stats.objects.get(name=name) 

128 total.value += value 

129 except Stats.DoesNotExist: 

130 total = Stats(name=name, value=value) 

131 

132 total.save() 

133 

134 seq += 1 

135 

136 

137def add_biblio(xobj, resource): 

138 for seq, xbibitem in enumerate(xobj.bibitems, start=1): 

139 bibitem = BibItem( 

140 resource=resource, 

141 sequence=seq, 

142 label=xbibitem.label, 

143 citation_xml=xbibitem.citation_xml, 

144 citation_tex=xbibitem.citation_tex, 

145 citation_html=xbibitem.citation_html, 

146 type=xbibitem.type, 

147 user_id=xbibitem.user_id, 

148 article_title_tex=xbibitem.article_title_tex, 

149 chapter_title_tex=xbibitem.chapter_title_tex, 

150 source_tex=xbibitem.source_tex, 

151 publisher_name=xbibitem.publisher_name, 

152 publisher_loc=xbibitem.publisher_loc, 

153 institution=xbibitem.institution, 

154 series=xbibitem.series, 

155 volume=xbibitem.volume, 

156 issue=xbibitem.issue, 

157 month=xbibitem.month, 

158 year=xbibitem.year, 

159 comment=xbibitem.comment, 

160 annotation=xbibitem.annotation, 

161 fpage=xbibitem.fpage, 

162 lpage=xbibitem.lpage, 

163 page_range=xbibitem.page_range, 

164 size=xbibitem.size, 

165 ) 

166 

167 bibitem.save() 

168 

169 add_contributors(contributors=xbibitem.contributors, bibitem=bibitem) 

170 

171 if xbibitem.extids: 

172 the_types = [] 

173 for id_type, id_value in xbibitem.extids: 

174 if id_type and id_type not in the_types: 

175 the_types.append(id_type) 

176 

177 bibitemid = BibItemId( 

178 bibitem=bibitem, 

179 id_type=id_type, 

180 id_value=id_value, 

181 checked=True, 

182 false_positive=False, 

183 ) 

184 

185 bibitemid.save() 

186 

187 

188def add_relations(xobj, resource): 

189 for relation in xobj.relations: 

190 with_doi = "10." in relation.id_value 

191 if with_doi and resource.doi is None: 191 ↛ 192line 191 didn't jump to line 192, because the condition on line 191 was never true

192 raise ValueError( 

193 f"The article {resource.pid} has no DOI but uses the relation {relation.rel_type} with the DOI {relation.id_value}" 

194 ) 

195 

196 # First, we need to find if the relation is stored in the RelationName as a left or right attribute 

197 name = relation.rel_type 

198 relationname = model_helpers.get_relationname_left(left_name=name) 

199 

200 if relationname: 

201 # RelationName with a left attribute (ex "follows"): 

202 # the subject of the relationship is the xml parent (typically the article defined by the xml) 

203 # the object is the id declared by the <related-article> 

204 # Example <article> 

205 # <article_id ...>A</article-id> 

206 # <related-article ... related-article-type="follows">B</related-article> 

207 # => RelationShip with subject = A and object = B 

208 

209 subject_pid = resource.doi if with_doi else resource.pid 

210 subject_resource = resource 

211 object_pid = relation.id_value 

212 # Find the resource to update the related article 

213 # But to work during a regular import, the related article must already be in the database 

214 # Depending on the import order, it might not work 

215 if with_doi: 215 ↛ 216line 215 didn't jump to line 216, because the condition on line 215 was never true

216 object_resource = model_helpers.get_article_by_doi(relation.id_value) 

217 else: 

218 object_resource = model_helpers.get_article(relation.id_value) 

219 else: 

220 relationname = model_helpers.get_relationname_right(right_name=name) 

221 

222 if relationname: 222 ↛ 244line 222 didn't jump to line 244, because the condition on line 222 was never false

223 # RelationName with a right attribute (ex "followed-by"): 

224 # the subject of the relationship is the id declared by the <related-article> 

225 # the object is the xml parent (typically the article defined by the xml) 

226 # Example <article> 

227 # <article_id ...>A</article-id> 

228 # <related-article ... related-article-type="followed-by">B</related-article> 

229 # => RelationShip with subject = B and object = A 

230 

231 subject_pid = relation.id_value 

232 # Find the resource to update the related article 

233 # But to work during a regular import, the related article must already be in the database 

234 # Depending on the import order, it might not work 

235 if with_doi: 235 ↛ 236line 235 didn't jump to line 236, because the condition on line 235 was never true

236 subject_resource = model_helpers.get_article_by_doi(relation.id_value) 

237 else: 

238 subject_resource = model_helpers.get_article(relation.id_value) 

239 

240 object_pid = resource.doi if with_doi else resource.pid 

241 object_resource = resource 

242 

243 # Elsevier creates basic relation. Create the relationname on the fly if necessary 

244 if not relationname and name == "refers to": 244 ↛ 245line 244 didn't jump to line 245, because the condition on line 244 was never true

245 relationname = RelationName( 

246 left="refers to", 

247 right="is referenced by", 

248 gauche="fait référence à", 

249 droite="est référencé par", 

250 ) 

251 relationname.save() 

252 

253 subject_pid = resource.doi if with_doi else resource.pid 

254 subject_resource = resource 

255 object_pid = relation.id_value 

256 # Find the resource to update the related article 

257 # But to work during a regular import, the related article must already be in the database 

258 # Depending on the import order, it might not work 

259 if with_doi: 

260 object_resource = model_helpers.get_article_by_doi(relation.id_value) 

261 else: 

262 object_resource = model_helpers.get_article(relation.id_value) 

263 

264 if relationname: 264 ↛ 189line 264 didn't jump to line 189, because the condition on line 264 was never false

265 params = {"subject_pid": subject_pid, "object_pid": object_pid, "solr_commit": False} 

266 cmd = addRelationshipDatabaseCmd(params) 

267 if subject_resource is not None: 

268 cmd.set_subject_resource(subject_resource) 

269 if object_resource is not None: 

270 cmd.set_object_resource(object_resource) 

271 cmd.set_relationname(relationname) 

272 

273 try: 

274 relationship = Relationship.objects.get( 

275 subject_pid=subject_pid, object_pid=object_pid, rel_info=relationname 

276 ) 

277 # la première fois que l'on crée la relation une des 2 ressources ID est a priori None 

278 # la deuxième fois (la relation symétrique) il faut compléter la 

279 # RelationShip 

280 if relationship.resource is not None and relationship.related is not None: 280 ↛ 281line 280 didn't jump to line 281, because the condition on line 280 was never true

281 raise exceptions.ResourceExists( 

282 f"The Relationship {subject_pid} {relationname.left} {object_pid} already exists" 

283 ) 

284 if subject_resource is not None: 284 ↛ 286line 284 didn't jump to line 286, because the condition on line 284 was never false

285 relationship.resource = subject_resource 

286 if object_resource is not None: 286 ↛ 288line 286 didn't jump to line 288, because the condition on line 286 was never false

287 relationship.related = object_resource 

288 relationship.save() 

289 

290 except Relationship.DoesNotExist: 

291 relationship = Relationship( 

292 subject_pid=subject_pid, 

293 object_pid=object_pid, 

294 resource=subject_resource, 

295 related=object_resource, 

296 rel_info=relationname, 

297 ) 

298 relationship.save() 

299 

300 

301def add_frontmatter(xobj, resource): 

302 if hasattr(xobj, "frontmatter_xml") and xobj.frontmatter_xml is not None: 

303 frontmatter = FrontMatter( 

304 resource=resource, 

305 value_xml=xobj.frontmatter_xml, 

306 value_html=xobj.frontmatter_toc_html, 

307 foreword_html=xobj.frontmatter_foreword_html, 

308 ) 

309 frontmatter.save() 

310 

311 

312def add_publisher(xobj): 

313 if hasattr(xobj, "publisher") and xobj.publisher: 

314 publisher = model_helpers.get_publisher(xobj.publisher.name) 

315 

316 if publisher is None: 

317 cmd = addPublisherDatabaseCmd({"xobj": xobj.publisher}) 

318 publisher = cmd.do() 

319 

320 return publisher 

321 

322 

323class addSiteDatabaseCmd(baseCmd): 

324 """ 

325 addSiteDatabaseCmd: adds/remove a PtfSite 

326 

327 Exception raised: 

328 - ValueError if the init params are empty 

329 - exceptions.ResourceExists during do if the site already exists 

330 - exceptions.ResourceDoesNotExist during undo if the site does not exist 

331 - RuntimeError during undo if resources are still deployed 

332 """ 

333 

334 def __init__(self, params=None): 

335 self.site_name = None 

336 self.site_domain = None 

337 self.site_id = None 

338 

339 super().__init__(params) 

340 

341 if not self.site_name: 341 ↛ 342line 341 didn't jump to line 342, because the condition on line 341 was never true

342 self.site_name = settings.SITE_NAME 

343 

344 if not self.site_domain: 344 ↛ 345line 344 didn't jump to line 345, because the condition on line 344 was never true

345 self.site_domain = settings.SITE_DOMAIN 

346 

347 self.required_params.extend(["site_name", "site_domain", "site_id"]) 

348 

349 # Returns a PtfSite 

350 def internal_do(self): 

351 super().internal_do() 

352 

353 try: 

354 PtfSite.objects.get(name=self.site_name) 

355 raise exceptions.ResourceExists( 

356 "The site " + self.site_name + " " + self.site_domain + " already exists" 

357 ) 

358 except PtfSite.DoesNotExist: 

359 site = PtfSite( 

360 domain=self.site_domain, name=self.site_name, acro=self.site_name, id=self.site_id 

361 ) 

362 site.save() 

363 

364 return site 

365 

366 def pre_undo(self): 

367 super().pre_undo() 

368 

369 if SiteMembership.objects.filter(site__name=self.site_name).exists(): 

370 raise RuntimeError( 

371 "Impossible de supprimer le site car il y a encore des ressources publiees" 

372 ) 

373 

374 def internal_undo(self): 

375 super().internal_undo() 

376 

377 try: 

378 # may throw PtfSite.DoesNotExist 

379 site = PtfSite.objects.get(name=self.site_name) 

380 id = site.id 

381 site.delete() 

382 except PtfSite.DoesNotExist: 

383 raise exceptions.ResourceDoesNotExist("The site " + self.site_name + " does not exist") 

384 

385 return id 

386 

387 

388class addProviderDatabaseCmd(baseCmd): 

389 """ 

390 addProviderDatabaseCmd: adds/remove a Provider 

391 

392 Exception raised: 

393 - ValueError if the init params are empty 

394 - exceptions.ResourceExists during do if the provider already exists 

395 - exceptions.ResourceDoesNotExist during undo if the provider does not exist 

396 """ 

397 

398 def __init__(self, params=None): 

399 self.name = None 

400 self.pid_type = None 

401 self.sid_type = None 

402 

403 super().__init__(params) 

404 

405 self.required_params.extend(["name", "pid_type"]) 

406 

407 def internal_do(self): 

408 super().internal_do() 

409 

410 try: 

411 Provider.objects.get(name=self.name, pid_type=self.pid_type, sid_type=self.sid_type) 

412 raise exceptions.ResourceExists("The provider " + self.name + " already exists") 

413 except Provider.DoesNotExist: 

414 p = Provider(name=self.name, pid_type=self.pid_type, sid_type=self.sid_type) 

415 p.save() 

416 

417 return p 

418 

419 def internal_undo(self): 

420 super().internal_undo() 

421 

422 try: 

423 p = Provider.objects.get( 

424 name=self.name, pid_type=self.pid_type, sid_type=self.sid_type 

425 ) 

426 id = p.id 

427 p.delete() 

428 except Provider.DoesNotExist: 

429 raise exceptions.ResourceDoesNotExist("The provider " + self.name + " does not exist") 

430 

431 return id 

432 

433 

434class addXmlBaseDatabaseCmd(baseCmd): 

435 """ 

436 addXmlBaseDatabaseCmd: adds/remove an XmlBase 

437 

438 XmlBase is the root URL of an ExtLink (ex: http://archive.numdam.org/article) 

439 

440 Exception raised: 

441 - ValueError if the init params are empty 

442 - exceptions.ResourceExists during do if the XmlBase already exists 

443 - exceptions.ResourceDoesNotExist during undo if the XmlBase does not exist 

444 - RuntimeError during undo if related extlinks or objects still exist 

445 """ 

446 

447 def __init__(self, params=None): 

448 self.base = None # Ex: http://archive.numdam.org/article 

449 

450 super().__init__(params) 

451 

452 self.required_params.extend(["base"]) 

453 

454 def internal_do(self): 

455 super().internal_do() 

456 

457 try: 

458 XmlBase.objects.get(base=self.base) 

459 raise exceptions.ResourceExists("The xmlbase " + self.base + " already exists") 

460 except XmlBase.DoesNotExist: 

461 xmlbase = XmlBase(base=self.base) 

462 xmlbase.save() 

463 

464 return xmlbase 

465 

466 def internal_undo(self): 

467 super().internal_undo() 

468 

469 try: 

470 xmlbase = XmlBase.objects.get(base=self.base) 

471 id = xmlbase.id 

472 except XmlBase.DoesNotExist: 

473 raise exceptions.ResourceDoesNotExist("The xmlbase " + self.base + " does not exist") 

474 

475 try: 

476 extlink = ExtLink.objects.get(base=xmlbase) 

477 

478 if extlink: 

479 raise RuntimeError( 

480 "Impossible de supprimer cette ressource car elle est encore utilisee par des ExtLinks" 

481 ) 

482 

483 except ExtLink.DoesNotExist: 

484 pass 

485 

486 try: 

487 related_object = RelatedObject.objects.get(base=xmlbase) 

488 

489 if related_object: 

490 raise RuntimeError( 

491 "Impossible de supprimer cette ressource car elle est encore utilisee par des RelatedObjects" 

492 ) 

493 

494 except RelatedObject.DoesNotExist: 

495 pass 

496 

497 xmlbase.delete() 

498 return id 

499 

500 

501class addExtLinkDatabaseCmd(baseCmd): 

502 """ 

503 addExtLinkDatabaseCmd: adds/remove an ExtLink 

504 An extlink is a link to an external object (image...) 

505 

506 Exception raised: 

507 - ValueError if the init params are empty 

508 - exceptions.ResourceExists during do if the ExtLink already exists 

509 - exceptions.ResourceDoesNotExist during undo if the ExtLink does not exist 

510 - RuntimeError during undo if resources are still deployed 

511 """ 

512 

513 def __init__(self, params=None): 

514 self.rel = None # 'website' or 'small_icon' 

515 self.mimetype = None 

516 self.location = None 

517 self.metadata = None 

518 self.seq = None 

519 self.resource = None 

520 self.base = None 

521 

522 super().__init__(params) 

523 

524 self.required_params.extend(["rel", "location", "seq", "resource"]) 

525 

526 def set_resource(self, resource): 

527 self.resource = resource 

528 

529 def set_base(self, base): 

530 self.base = base 

531 

532 def internal_do(self): 

533 super().internal_do() 

534 

535 try: 

536 ExtLink.objects.get( 

537 resource=self.resource, 

538 base=self.base, 

539 rel=self.rel, 

540 mimetype=self.mimetype, 

541 location=self.location, 

542 metadata=self.metadata, 

543 seq=self.seq, 

544 ) 

545 raise exceptions.ResourceExists( 

546 "The ExtLink " + self.base + " " + self.rel + " already exists" 

547 ) 

548 except ExtLink.DoesNotExist: 

549 extlink = ExtLink( 

550 resource=self.resource, 

551 base=self.base, 

552 rel=self.rel, 

553 mimetype=self.mimetype, 

554 location=self.location, 

555 metadata=self.metadata, 

556 seq=self.seq, 

557 ) 

558 extlink.save() 

559 

560 return extlink 

561 

562 def internal_undo(self): 

563 super().internal_undo() 

564 

565 try: 

566 extlink = ExtLink.objects.get(resource=self.resource, base=self.base, rel=self.rel) 

567 id = extlink.id 

568 extlink.delete() 

569 except ExtLink.DoesNotExist: 

570 raise exceptions.ResourceDoesNotExist("The extlink " + self.rel + " does not exist") 

571 

572 return id 

573 

574 

575class addExtIdDatabaseCmd(baseCmd): 

576 """ 

577 addExtIdDatabaseCmd: adds/remove an ExtId 

578 

579 Exception raised: 

580 - ValueError if the init params are empty 

581 - exceptions.ResourceExists during do if the ExtId already exists 

582 - exceptions.ResourceDoesNotExist during undo if the ExtId does not exist 

583 - RuntimeError during undo if resources are still deployed 

584 """ 

585 

586 def __init__(self, params=None): 

587 self.resource = None 

588 self.id_type = None 

589 self.id_value = None 

590 self.checked = True 

591 self.false_positive = False 

592 

593 super().__init__(params) 

594 

595 self.required_params.extend(["id_type", "id_value", "resource"]) 

596 

597 def set_resource(self, resource): 

598 self.resource = resource 

599 

600 def internal_do(self): 

601 super().internal_do() 

602 

603 try: 

604 # May raise Resource.DoesNotExist 

605 extid = ExtId.objects.get( 

606 resource=self.resource, id_type=self.id_type, id_value=self.id_value 

607 ) 

608 except ExtId.DoesNotExist: 

609 extid = ExtId( 

610 resource=self.resource, 

611 id_type=self.id_type, 

612 id_value=self.id_value, 

613 checked=self.checked, 

614 false_positive=self.false_positive, 

615 ) 

616 extid.save() 

617 

618 return extid 

619 

620 def internal_undo(self): 

621 super().internal_undo() 

622 

623 try: 

624 extid = ExtId.objects.get( 

625 resource=self.resource, id_type=self.id_type, id_value=self.id_value 

626 ) 

627 id = extid.id 

628 extid.delete() 

629 except ExtId.DoesNotExist: 

630 raise exceptions.ResourceDoesNotExist("The extid " + self.id_value + " does not exist") 

631 

632 return id 

633 

634 

635class addRelatedObjectDatabaseCmd(baseCmd): 

636 """ 

637 addRelatedObjectDatabaseCmd: adds/remove a RelatedObject 

638 

639 a related object is a pdf/djvu... attached to the object (article...) 

640 It can be for example a listing of a program attached to an article. 

641 

642 Exception raised: 

643 - ValueError if the init params are empty 

644 - exceptions.ResourceExists during do if the RelatedObject already exists 

645 - exceptions.ResourceDoesNotExist during undo if the RelatedObject does not exist 

646 - RuntimeError during undo if resources are still deployed 

647 """ 

648 

649 def __init__(self, params=None): 

650 self.rel = None 

651 self.mimetype = None 

652 self.location = None 

653 self.metadata = None 

654 self.seq = None 

655 self.resource = None 

656 self.base = None 

657 

658 super().__init__(params) 

659 

660 self.required_params.extend(["rel", "location", "seq", "resource"]) 

661 

662 def set_resource(self, resource): 

663 self.resource = resource 

664 

665 def set_base(self, base): 

666 self.base = base 

667 

668 def internal_do(self): 

669 super().internal_do() 

670 

671 try: 

672 RelatedObject.objects.get( 

673 resource=self.resource, 

674 base=self.base, 

675 rel=self.rel, 

676 mimetype=self.mimetype, 

677 location=self.location, 

678 metadata=self.metadata, 

679 seq=self.seq, 

680 ) 

681 raise exceptions.ResourceExists( 

682 "The RelatedObject " 

683 + self.base 

684 + " " 

685 + self.rel 

686 + " " 

687 + self.location 

688 + " already exists" 

689 ) 

690 except RelatedObject.DoesNotExist: 

691 related_object = RelatedObject( 

692 resource=self.resource, 

693 base=self.base, 

694 rel=self.rel, 

695 mimetype=self.mimetype, 

696 location=self.location, 

697 metadata=self.metadata, 

698 seq=self.seq, 

699 ) 

700 

701 related_object.save() 

702 

703 return related_object 

704 

705 def internal_undo(self): 

706 super().internal_undo() 

707 

708 try: 

709 related_object = RelatedObject.objects.get( 

710 resource=self.resource, base=self.base, rel=self.rel, location=self.location 

711 ) 

712 id = related_object.id 

713 related_object.delete() 

714 except RelatedObject.DoesNotExist: 

715 raise exceptions.ResourceDoesNotExist( 

716 "The relatedobject " + self.location + " does not exist" 

717 ) 

718 

719 return id 

720 

721 

722class addSupplementaryMaterialDatabaseCmd(addRelatedObjectDatabaseCmd): 

723 """ 

724 addSupplementaryMaterialDatabaseCmd: adds/remove a Supplementary Materiel 

725 

726 a supplementary material is a pdf/djvu... attached to the object (article...) 

727 It can be for example a listing of a program attached to an article. 

728 

729 Exception raised: 

730 - ValueError if the init params are empty 

731 - exceptions.ResourceExists during do if the RelatedObject already exists 

732 - exceptions.ResourceDoesNotExist during undo if the RelatedObject does not exist 

733 - RuntimeError during undo if resources are still deployed 

734 """ 

735 

736 def __init__(self, params=None): 

737 super().__init__(params) 

738 

739 def internal_do(self): 

740 supplementary_material, _created = SupplementaryMaterial.objects.update_or_create( 

741 caption=self.caption, 

742 resource=self.resource, 

743 base=self.base, 

744 rel=self.rel, 

745 mimetype=self.mimetype, 

746 location=self.location, 

747 metadata=self.metadata, 

748 seq=self.seq, 

749 ) 

750 return supplementary_material 

751 

752 def internal_undo(self): 

753 try: 

754 supplementary_material = SupplementaryMaterial.objects.get( 

755 resource=self.resource, base=self.base, rel=self.rel, location=self.location 

756 ) 

757 pk = supplementary_material.pk 

758 supplementary_material.delete() 

759 except SupplementaryMaterial.DoesNotExist: 

760 raise exceptions.ResourceDoesNotExist( 

761 "The SupplementaryMaterial " + self.location + " does not exist" 

762 ) 

763 return pk 

764 

765 

766class addDataStreamDatabaseCmd(baseCmd): 

767 """ 

768 addDataStreamDatabaseCmd: adds/remove a DataStream 

769 

770 a datastream is the pdf/djvu... of the object (container, article) 

771 

772 Exception raised: 

773 - ValueError if the init params are empty 

774 - exceptions.ResourceExists during do if the DataStream already exists 

775 - exceptions.ResourceDoesNotExist during undo if the DataStream does not exist 

776 - RuntimeError during undo if resources are still deployed 

777 """ 

778 

779 def __init__(self, params=None): 

780 self.rel = None 

781 self.mimetype = None 

782 self.location = None 

783 self.text = None 

784 self.seq = None 

785 self.resource = None 

786 self.base = None 

787 

788 super().__init__(params) 

789 

790 self.required_params.extend(["rel", "location", "seq", "resource"]) 

791 

792 def set_resource(self, resource): 

793 self.resource = resource 

794 

795 def set_base(self, base): 

796 self.base = base 

797 

798 def internal_do(self): 

799 super().internal_do() 

800 

801 try: 

802 DataStream.objects.get( 

803 resource=self.resource, 

804 base=self.base, 

805 rel=self.rel, 

806 mimetype=self.mimetype, 

807 location=self.location, 

808 text=self.text, 

809 seq=self.seq, 

810 ) 

811 raise exceptions.ResourceExists( 

812 "The DataStream " 

813 + self.base 

814 + " " 

815 + self.rel 

816 + " " 

817 + self.location 

818 + " already exists" 

819 ) 

820 except DataStream.DoesNotExist: 

821 datastream = DataStream( 

822 resource=self.resource, 

823 base=self.base, 

824 rel=self.rel, 

825 mimetype=self.mimetype, 

826 location=self.location, 

827 text=self.text, 

828 seq=self.seq, 

829 ) 

830 

831 datastream.save() 

832 

833 return datastream 

834 

835 def internal_undo(self): 

836 super().internal_undo() 

837 

838 try: 

839 datastream = DataStream.objects.get( 

840 resource=self.resource, base=self.base, rel=self.rel, location=self.location 

841 ) 

842 id = datastream.id 

843 datastream.delete() 

844 except DataStream.DoesNotExist: 

845 raise exceptions.ResourceDoesNotExist( 

846 "The datastream " + self.location + " does not exist" 

847 ) 

848 

849 return id 

850 

851 

852class addResourceCountDatabaseCmd(baseCmd): 

853 """ 

854 addResourceCountDatabaseCmd: adds/remove a ResourceCount 

855 

856 A ResourceCount is a generic count element. 

857 Exemple: page count, table count, image count... 

858 

859 Exception raised: 

860 - ValueError if the init params are empty 

861 - exceptions.ResourceExists during do if the ResourceCount already exists 

862 - exceptions.ResourceDoesNotExist during undo if the ResourceCount does not exist 

863 - RuntimeError during undo if resources are still deployed 

864 """ 

865 

866 def __init__(self, params=None): 

867 self.seq = None 

868 self.name = None 

869 self.value = None 

870 self.resource = None 

871 self.add_total = False 

872 

873 super().__init__(params) 

874 

875 self.required_params.extend(["seq", "name", "value", "resource"]) 

876 

877 def set_resource(self, resource): 

878 self.resource = resource 

879 

880 def internal_do(self): 

881 super().internal_do() 

882 

883 try: 

884 ResourceCount.objects.get(resource=self.resource, name=self.name) 

885 raise exceptions.ResourceExists("The ResourceCount " + self.name + " already exists") 

886 except ResourceCount.DoesNotExist: 

887 resource_count = ResourceCount( 

888 resource=self.resource, name=self.name, seq=self.seq, value=self.value 

889 ) 

890 

891 resource_count.save() 

892 

893 if self.name == "page-count" and self.add_total: 

894 value = parse_page_count(self.value) 

895 

896 try: 

897 total = Stats.objects.get(name=self.name) 

898 total.value += value 

899 except Stats.DoesNotExist: 

900 total = Stats(name=self.name, value=value) 

901 

902 total.save() 

903 

904 return resource_count 

905 

906 def internal_undo(self): 

907 super().internal_undo() 

908 

909 try: 

910 resource_count = ResourceCount.objects.get(resource=self.resource, name=self.name) 

911 id = resource_count.id 

912 resource_count.delete() 

913 except ResourceCount.DoesNotExist: 

914 raise exceptions.ResourceDoesNotExist("The count " + self.name + " does not exist") 

915 

916 return id 

917 

918 

919class addMetaDataPartDatabaseCmd(baseCmd): 

920 """ 

921 addMetaDataPartDatabaseCmd: adds/remove a MetaDataPart 

922 

923 A MetaDataPart is a generic count element. 

924 Exemple: page count, table count, image count... 

925 

926 Exception raised: 

927 - ValueError if the init params are empty 

928 - exceptions.ResourceExists during do if the MetaDataPart already exists 

929 - exceptions.ResourceDoesNotExist during undo if the MetaDataPart does not exist 

930 - RuntimeError during undo if resources are still deployed 

931 """ 

932 

933 def __init__(self, params=None): 

934 self.seq = None 

935 self.name = None 

936 self.data = None 

937 self.resource = None 

938 

939 super().__init__(params) 

940 

941 self.required_params.extend(["seq", "name", "data", "resource"]) 

942 

943 def set_resource(self, resource): 

944 self.resource = resource 

945 

946 def internal_do(self): 

947 super().internal_do() 

948 

949 try: 

950 MetaDataPart.objects.get(resource=self.resource, name=self.name) 

951 raise exceptions.ResourceExists("The MetaDataPart " + self.name + " already exists") 

952 except MetaDataPart.DoesNotExist: 

953 metadatapart = MetaDataPart( 

954 resource=self.resource, name=self.name, seq=self.seq, data=self.data 

955 ) 

956 

957 metadatapart.save() 

958 

959 return metadatapart 

960 

961 def internal_undo(self): 

962 super().internal_undo() 

963 

964 try: 

965 metadatapart = MetaDataPart.objects.get(resource=self.resource, name=self.name) 

966 id = metadatapart.id 

967 metadatapart.delete() 

968 except MetaDataPart.DoesNotExist: 

969 raise exceptions.ResourceDoesNotExist( 

970 "The metadatapart " + self.name + " does not exist" 

971 ) 

972 

973 return id 

974 

975 

976class addBibItemDatabaseCmd(baseCmd): 

977 """ 

978 addBibItemDatabaseCmd: adds/remove a BibItem 

979 

980 No verification is done to check if a BibItem already exists 

981 Rationale: BibItems are only added in a loop within an article. 

982 The check is actually the existence of the article. 

983 

984 Exception raised: 

985 - ValueError if the init params are empty 

986 - exceptions.ResourceDoesNotExist during undo if the BibItem does not exist 

987 - RuntimeError during undo if resources are still deployed 

988 """ 

989 

990 def __init__(self, params=None): 

991 self.sequence = None 

992 self.label = "" 

993 self.citation_xml = None 

994 self.citation_tex = None 

995 self.citation_html = None 

996 self.resource = None 

997 

998 self.type = "" 

999 self.user_id = "" 

1000 self.title_tex = "" 

1001 self.publisher_name = "" 

1002 self.publisher_loc = "" 

1003 self.institution = "" 

1004 self.series = "" 

1005 self.volume = "" 

1006 self.issue = "" 

1007 self.month = "" 

1008 self.year = "" 

1009 self.comment = "" 

1010 self.annotation = "" 

1011 self.fpage = "" 

1012 self.lpage = "" 

1013 self.page_range = "" 

1014 self.size = "" 

1015 self.source = "" 

1016 self.article_title_tex = "" 

1017 self.chapter_title_tex = "" 

1018 

1019 self.contributors = None 

1020 

1021 super().__init__(params) 

1022 

1023 self.required_params.extend(["sequence", "citation_xml", "resource"]) 

1024 

1025 def set_resource(self, resource): 

1026 self.resource = resource 

1027 

1028 def internal_do(self): 

1029 super().internal_do() 

1030 

1031 bibitem = BibItem( 

1032 resource=self.resource, 

1033 sequence=self.sequence, 

1034 label=self.label, 

1035 citation_xml=self.citation_xml, 

1036 citation_tex=self.citation_tex, 

1037 citation_html=self.citation_html, 

1038 type=self.type, 

1039 user_id=self.user_id, 

1040 article_title_tex=self.article_title_tex, 

1041 chapter_title_tex=self.chapter_title_tex, 

1042 source_tex=self.source_tex, 

1043 publisher_name=self.publisher_name, 

1044 publisher_loc=self.publisher_loc, 

1045 institution=self.institution, 

1046 series=self.series, 

1047 volume=self.volume, 

1048 issue=self.issue, 

1049 month=self.month, 

1050 year=self.year, 

1051 comment=self.comment, 

1052 annotation=self.annotation, 

1053 fpage=self.fpage, 

1054 lpage=self.lpage, 

1055 page_range=self.page_range, 

1056 size=self.size, 

1057 ) 

1058 

1059 bibitem.save() 

1060 

1061 return bibitem 

1062 

1063 def post_do(self, bibitem): 

1064 super().post_do(bibitem) 

1065 

1066 add_contributors(contributors=self.contributors, bibitem=bibitem) 

1067 

1068 def internal_undo(self): 

1069 super().internal_undo() 

1070 

1071 try: 

1072 bibitem = BibItem.objects.get(resource=self.resource, sequence=self.sequence) 

1073 id = bibitem.id 

1074 bibitem.delete() 

1075 except BibItem.DoesNotExist: 

1076 raise exceptions.ResourceDoesNotExist( 

1077 "The bibitem " + self.sequence + " does not exist" 

1078 ) 

1079 

1080 return id 

1081 

1082 

1083class addBibItemIdDatabaseCmd(baseCmd): 

1084 """ 

1085 addBibItemIdDatabaseCmd: adds/remove a BibItemId 

1086 

1087 No verification is done to check if a BibItemId already exists 

1088 Rationale: BibItems are only added in a loop within an article. 

1089 The check is actually the existence of the article. 

1090 

1091 Exception raised: 

1092 - ValueError if the init params are empty 

1093 - exceptions.ResourceDoesNotExist during undo if the BibItemId does not exist 

1094 - RuntimeError during undo if resources are still deployed 

1095 """ 

1096 

1097 def __init__(self, params=None): 

1098 self.bibitem = None 

1099 self.id_type = None 

1100 self.id_value = None 

1101 self.checked = True 

1102 self.false_positive = False 

1103 

1104 super().__init__(params) 

1105 

1106 self.required_params.extend(["bibitem", "id_type", "id_value"]) 

1107 

1108 def set_bibitem(self, bibitem): 

1109 self.bibitem = bibitem 

1110 

1111 def internal_do(self): 

1112 super().internal_do() 

1113 

1114 bibitemid = BibItemId( 

1115 bibitem=self.bibitem, 

1116 id_type=self.id_type, 

1117 id_value=self.id_value, 

1118 checked=self.checked, 

1119 false_positive=self.false_positive, 

1120 ) 

1121 

1122 bibitemid.save() 

1123 

1124 return bibitemid 

1125 

1126 def internal_undo(self): 

1127 super().internal_undo() 

1128 

1129 try: 

1130 bibitemid = BibItemId.objects.get( 

1131 bibitem=self.bibitem, id_type=self.id_type, id_value=self.id_value 

1132 ) 

1133 id = bibitemid.id 

1134 bibitemid.delete() 

1135 except BibItemId.DoesNotExist: 

1136 raise exceptions.ResourceDoesNotExist( 

1137 "The bibitemid " + self.value + " does not exist" 

1138 ) 

1139 

1140 return id 

1141 

1142 

1143class addFrontMatterDatabaseCmd(baseCmd): 

1144 """ 

1145 addFrontMatterDatabaseCmd: adds/remove a FrontMatter 

1146 

1147 No verification is done to check if a FrontMatter already exists 

1148 Rationale: FrontMatters are only added in a loop within an article. 

1149 The check is actually the existence of the article. 

1150 

1151 Exception raised: 

1152 - ValueError if the init params are empty 

1153 - exceptions.ResourceDoesNotExist during undo if the FrontMatter does not exist 

1154 - RuntimeError during undo if resources are still deployed 

1155 """ 

1156 

1157 def __init__(self, params=None): 

1158 self.value_xml = "" 

1159 self.value_html = "" 

1160 self.foreword_html = "" 

1161 self.resource = None 

1162 

1163 super().__init__(params) 

1164 

1165 self.required_params.extend(["value_xml", "resource"]) 

1166 

1167 def set_resource(self, resource): 

1168 self.resource = resource 

1169 

1170 def internal_do(self): 

1171 super().internal_do() 

1172 

1173 frontmatter = FrontMatter( 

1174 resource=self.resource, 

1175 value_xml=self.value_xml, 

1176 value_html=self.value_html, 

1177 foreword_html=self.foreword_html, 

1178 ) 

1179 

1180 frontmatter.save() 

1181 

1182 return frontmatter 

1183 

1184 def internal_undo(self): 

1185 super().internal_undo() 

1186 

1187 try: 

1188 frontmatter = FrontMatter.objects.get(resource=self.resource) 

1189 id = frontmatter.id 

1190 frontmatter.delete() 

1191 except FrontMatter.DoesNotExist: 

1192 raise exceptions.ResourceDoesNotExist( 

1193 "The front-matter " + self.text + " does not exist" 

1194 ) 

1195 

1196 return id 

1197 

1198 

1199class addRelationshipDatabaseCmd(baseCmd): 

1200 """ 

1201 addRelationshipDatabaseCmd: adds/remove a Relationship 

1202 

1203 Relationship relates 2 resources (ex: articles) with a relation. ex "follows", "followed-by" 

1204 

1205 RelationName are created with a fixture (see app/ptf/apps/ptf/fixtures/initial_data.json 

1206 Example { "left" : "follows", "right" : "followed-by" } 

1207 A related-article of an article has 1 relation name (ex "follows" or "followed-by") 

1208 You need to know if the relation was stored in the left or right attribute of a RelationName, 

1209 so that you can create/search the Relationship with the correct object/subject. 

1210 Ex: with A "follows" B, A is the subject and B the object because "follows" is a RelationName.left attribute 

1211 with A "followed-by" B, A is the object the B the subject because 

1212 "followed-by" is a RelationName.right attribute 

1213 A Relationship relates 2 resources with a RelationName 

1214 

1215 

1216 Exception raised: 

1217 - ValueError if the init params are empty 

1218 - exceptions.ResourceExists during do if the Relationship already exists 

1219 - exceptions.ResourceDoesNotExist during undo if the Relationship does not exist 

1220 - RuntimeError during undo if resources are still deployed 

1221 """ 

1222 

1223 def __init__(self, params=None): 

1224 self.subject_resource = None 

1225 self.subject_pid = None 

1226 self.object_resource = None 

1227 self.object_pid = None 

1228 self.relationname = None 

1229 

1230 super().__init__(params) 

1231 

1232 self.required_params.extend(["subject_pid", "object_pid", "relationname"]) 

1233 

1234 def set_subject_resource(self, resource): 

1235 self.subject_resource = resource 

1236 # self.subject_pid = resource.pid 

1237 

1238 def set_object_resource(self, resource): 

1239 self.object_resource = resource 

1240 # self.object_pid = resource.pid 

1241 

1242 def set_relationname(self, relationname): 

1243 self.relationname = relationname 

1244 

1245 def internal_do(self): 

1246 super().internal_do() 

1247 

1248 try: 

1249 relationship = Relationship.objects.get( 

1250 subject_pid=self.subject_pid, 

1251 object_pid=self.object_pid, 

1252 rel_info=self.relationname, 

1253 ) 

1254 # la première fois que l'on crée la relation une des 2 ressourcesID est a priori None 

1255 # la deuxième fois (la relation symétrique) il faut compléter la 

1256 # RelationShip 

1257 if relationship.resource is not None and relationship.related is not None: 

1258 raise exceptions.ResourceExists( 

1259 "The Relationship {} {} {} already exists".format( 

1260 self.subject_pid, self.relationname.left, self.object_pid 

1261 ) 

1262 ) 

1263 if self.subject_resource is not None: 

1264 relationship.resource = self.subject_resource 

1265 if self.object_resource is not None: 

1266 relationship.related = self.object_resource 

1267 relationship.save() 

1268 

1269 except Relationship.DoesNotExist: 

1270 relationship = Relationship( 

1271 subject_pid=self.subject_pid, 

1272 object_pid=self.object_pid, 

1273 resource=self.subject_resource, 

1274 related=self.object_resource, 

1275 rel_info=self.relationname, 

1276 ) 

1277 

1278 relationship.save() 

1279 

1280 return relationship 

1281 

1282 def internal_undo(self): 

1283 super().internal_undo() 

1284 

1285 try: 

1286 relationship = Relationship.objects.get( 

1287 subject_pid=self.subject_pid, 

1288 object_pid=self.object_pid, 

1289 rel_info=self.relationname, 

1290 ) 

1291 id = relationship.id 

1292 

1293 # Create relationship is typically a 2 steps process 

1294 # (1: create the relationship with only 1 resource. 2: update the relationship with the 2nd resource) 

1295 # Undo is also a 2 steps process 

1296 # (1: unset a resource. 2: delete the relationship) 

1297 if relationship.resource is not None and relationship.related is not None: 

1298 # Both left and right resources are set: unset the resource 

1299 # that was given as param 

1300 if self.subject_resource is None: 

1301 relationship.related = None 

1302 else: 

1303 relationship.resource = None 

1304 relationship.save() 

1305 else: 

1306 relationship.delete() 

1307 except Relationship.DoesNotExist: 

1308 raise exceptions.ResourceDoesNotExist( 

1309 "The relationship " + self.relationname + " does not exist" 

1310 ) 

1311 

1312 return id 

1313 

1314 

1315class addResourceDatabaseCmd(baseCmd): 

1316 """ 

1317 addResourceDatabaseCmd: base class for all resources 

1318 

1319 Exception raised: 

1320 - exceptions.ResourceDoesNotExist during undo if the Resource does not exist 

1321 """ 

1322 

1323 def __init__(self, params=None): 

1324 self.xobj = None # model_data object 

1325 

1326 self.provider = None 

1327 self._prod_deployed_date = None 

1328 

1329 super().__init__(params) 

1330 

1331 self.required_params.extend(["xobj", "provider"]) 

1332 

1333 # May raise ValueError 

1334 def check_params(self): 

1335 super().check_params() 

1336 

1337 if hasattr(self.xobj, "pid") and not self.xobj.pid and not self.xobj.sid: 1337 ↛ 1338line 1337 didn't jump to line 1338, because the condition on line 1337 was never true

1338 raise ValueError("pid et sid sont vides") 

1339 

1340 def set_provider(self, provider): 

1341 self.provider = provider 

1342 

1343 # May raise Provider.DoesNotExist 

1344 def set_provider_by_name_or_id(self, provider_name="", pid_type="", sid_type=None): 

1345 self.provider = Provider.objects.get( 

1346 name=provider_name, pid_type=pid_type, sid_type=sid_type 

1347 ) 

1348 

1349 def post_do(self, resource): 

1350 super().post_do(resource) 

1351 self.object_to_be_deleted = resource 

1352 

1353 site = model_helpers.get_or_create_site(settings.SITE_ID) 

1354 if site: 1354 ↛ 1360line 1354 didn't jump to line 1360, because the condition on line 1354 was never false

1355 resource.deploy(site, self._prod_deployed_date) 

1356 

1357 # Creation of SiteMembership for production website on ptf_tools is handled in DeployJatsIssue 

1358 # Restoration of SiteMembership is handled in importExtraDataPtfCmd 

1359 

1360 for id_type, id_value in self.xobj.ids: 

1361 if ( 1361 ↛ 1360line 1361 didn't jump to line 1360

1362 id_type != self.provider.pid_type 

1363 and id_type != self.provider.sid_type 

1364 and (id_type != "numdam-id" or self.provider.pid_type != "mathdoc-id") 

1365 ): 

1366 try: 

1367 # May raise Resource.DoesNotExist 

1368 resource_id = ResourceId.objects.get( 

1369 resource=resource, id_type=id_type, id_value=id_value 

1370 ) 

1371 except ResourceId.DoesNotExist: 

1372 resource_id = ResourceId(resource=resource, id_type=id_type, id_value=id_value) 

1373 resource_id.save() 

1374 

1375 for id_type, id_value in self.xobj.extids: 

1376 if ( 1376 ↛ 1375line 1376 didn't jump to line 1375

1377 id_type != self.provider.pid_type 

1378 and id_type != self.provider.sid_type 

1379 and (id_type != "numdam-id" or self.provider.pid_type != "mathdoc-id") 

1380 ): 

1381 try: 

1382 # May raise Resource.DoesNotExist 

1383 ExtId.objects.get(resource=resource, id_type=id_type, id_value=id_value) 

1384 except ExtId.DoesNotExist: 

1385 ext_id = ExtId(resource=resource, id_type=id_type, id_value=id_value) 

1386 ext_id.save() 

1387 

1388 seq = 1 

1389 for a in self.xobj.abstracts: 

1390 value_xml = a["value_xml"] if "value_xml" in a else "" 

1391 value_html = a["value_html"] if "value_html" in a else "" 

1392 value_tex = a["value_tex"] if "value_tex" in a else "" 

1393 

1394 la = Abstract( 

1395 resource=resource, 

1396 tag=a["tag"], 

1397 lang=a["lang"], 

1398 seq=seq, 

1399 value_xml=value_xml, 

1400 value_html=value_html, 

1401 value_tex=value_tex, 

1402 ) 

1403 la.save() 

1404 seq += 1 

1405 

1406 add_contributors(contributors=self.xobj.contributors, resource=resource) 

1407 

1408 for i, kwd in enumerate(self.xobj.kwds): 

1409 k = Kwd( 

1410 resource=resource, lang=kwd["lang"], type=kwd["type"], value=kwd["value"], seq=i 

1411 ) 

1412 k.save() 

1413 

1414 for i, subj in enumerate(self.xobj.subjs): 

1415 s = Subj( 

1416 resource=resource, lang=subj["lang"], type=subj["type"], value=subj["value"], seq=i 

1417 ) 

1418 s.save() 

1419 

1420 seq = 1 

1421 for a in self.xobj.awards: 

1422 abbrev = a["abbrev"] 

1423 award_id = a["award_id"] 

1424 

1425 award = Award(resource=resource, abbrev=abbrev, award_id=award_id, seq=seq) 

1426 award.save() 

1427 seq += 1 

1428 

1429 # TODO custom meta 

1430 

1431 def pre_undo(self): 

1432 super().pre_undo() 

1433 

1434 # None value not detected in check_params (required_delete_params) 

1435 # => undo was already called 

1436 if self.object_to_be_deleted is None: 

1437 raise exceptions.ResourceDoesNotExist("The object to be deleted no longer exists") 

1438 

1439 # Django automatically deletes related objects such as ResourceIds, 

1440 # Abstracts... 

1441 

1442 # Author are deleted by signals (see models.py) 

1443 # Another solution would be to do it here 

1444 

1445 # Undeploy the resource in all sites 

1446 for site in self.object_to_be_deleted.sites.all(): 

1447 self.object_to_be_deleted.undeploy(site) 

1448 

1449 def internal_undo(self): 

1450 super().internal_undo() 

1451 

1452 id = self.object_to_be_deleted.id 

1453 self.object_to_be_deleted.delete() 

1454 

1455 return id 

1456 

1457 def post_undo(self): 

1458 super().internal_undo() 

1459 

1460 self.object_to_be_deleted = None # prevents a 2nd attempt to delete 

1461 

1462 

1463class addPublisherDatabaseCmd(baseCmd): 

1464 """ 

1465 addPublisherDatabaseCmd: adds/remove a publisher 

1466 

1467 Exception raised: 

1468 - ValueError if the init params are empty 

1469 - exceptions.ResourceExists during do if the Publisher already exists 

1470 - exceptions.ResourceDoesNotExist during undo if the Publisher does not exist 

1471 """ 

1472 

1473 def __init__(self, params=None): 

1474 self.xobj = None # model_data object 

1475 self.object_to_be_deleted = None 

1476 

1477 super().__init__(params) 

1478 

1479 self.required_params.extend(["xobj"]) 

1480 self.required_delete_params.append("object_to_be_deleted") 

1481 

1482 def set_object_to_be_deleted(self, obj): 

1483 self.object_to_be_deleted = obj 

1484 

1485 def internal_do(self): 

1486 super().internal_do() 

1487 

1488 # A Publisher is a resource. Therefore it needs a provider (that provides the publisher id/key) 

1489 # As we are creating the key, Mathdoc is the provider 

1490 provider = Provider.objects.get(name="mathdoc", pid_type="mathdoc-id") 

1491 key = model_helpers.make_key(self.xobj.name) 

1492 

1493 try: 

1494 Publisher.objects.get(pub_key=key) 

1495 raise exceptions.ResourceExists("The publisher " + self.xobj.name + " already exists") 

1496 except Publisher.DoesNotExist: 

1497 publisher = Publisher( 

1498 pub_key=key, 

1499 pub_name=self.xobj.name, 

1500 pub_loc=self.xobj.loc, 

1501 pid=key, 

1502 provider=provider, 

1503 ) 

1504 publisher.save() 

1505 

1506 self.object_to_be_deleted = publisher 

1507 return publisher 

1508 

1509 def internal_undo(self): 

1510 super().internal_undo() 

1511 

1512 # None value not detected in check_params (required_delete_params) 

1513 # => undo was already called 

1514 if self.object_to_be_deleted is None: 

1515 raise exceptions.ResourceDoesNotExist("The object to be deleted no longer exists") 

1516 

1517 self.object_to_be_deleted.refresh_from_db() 

1518 

1519 if self.object_to_be_deleted.publishes.count(): 

1520 raise RuntimeError( 

1521 "Impossible de supprimer ce publisher car il a encore des resources qui sont publiées par ce publisher" 

1522 ) 

1523 

1524 id = self.object_to_be_deleted.id 

1525 self.object_to_be_deleted.delete() 

1526 self.object_to_be_deleted = None 

1527 

1528 return id 

1529 

1530 

1531class addContainerDatabaseCmd(addResourceDatabaseCmd): 

1532 """ 

1533 addContainerDatabaseCmd: adds/remove a container 

1534 

1535 an Container needs a Collection 

1536 

1537 Exception raised: 

1538 - ValueError if the init params are empty 

1539 - exceptions.ResourceExists during do if the container already exists 

1540 - exceptions.ResourceDoesNotExist during undo if the Container does not exist 

1541 """ 

1542 

1543 def __init__(self, params=None): 

1544 self.last_modified = None 

1545 self.collection = None 

1546 self._publisher = None 

1547 

1548 super().__init__(params) 

1549 

1550 self.required_params.extend(["collection"]) 

1551 

1552 def add_collection(self, collection): 

1553 if not self.collection: 1553 ↛ exitline 1553 didn't return from function 'add_collection', because the condition on line 1553 was never false

1554 self.collection = collection 

1555 

1556 def pre_do(self): 

1557 super().pre_do() 

1558 

1559 self._publisher = add_publisher(self.xobj) 

1560 

1561 def internal_do(self): 

1562 super().internal_do() 

1563 

1564 vseries = volume = number = seq = "" 

1565 if hasattr(self.xobj, "volume"): 

1566 vseries = self.xobj.vseries 

1567 volume = self.xobj.volume 

1568 number = self.xobj.number 

1569 seq = self.xobj.seq 

1570 elif len(self.xobj.incollection) > 0: 1570 ↛ 1579line 1570 didn't jump to line 1579, because the condition on line 1570 was never false

1571 # Books do not have vseries/volume/number, but a list of incollection 

1572 # Set vseries/volume/number from the 1st incollection (the main collection) 

1573 incol = self.xobj.incollection[0] 

1574 vseries = incol.vseries 

1575 volume = "" 

1576 number = incol.volume 

1577 seq = incol.seq 

1578 

1579 if settings.CONTAINER_SEQUENCED: 1579 ↛ 1580line 1579 didn't jump to line 1580, because the condition on line 1579 was never true

1580 seq = make_int(volume) if volume else make_int(self.xobj.year) 

1581 

1582 last_modified = model_helpers.parse_date_str(self.xobj.last_modified_iso_8601_date_str) 

1583 if self.xobj.prod_deployed_date_iso_8601_date_str: 

1584 self._prod_deployed_date = model_helpers.parse_date_str( 

1585 self.xobj.prod_deployed_date_iso_8601_date_str 

1586 ) 

1587 

1588 with_online_first = ( 

1589 self.xobj.with_online_first if hasattr(self.xobj, "with_online_first") else False 

1590 ) 

1591 

1592 try: 

1593 Container.objects.get( 

1594 pid=self.xobj.pid, 

1595 provider__pid_type=self.provider.pid_type, 

1596 my_collection__pid=self.collection.pid, 

1597 ) 

1598 raise exceptions.ResourceExists("The container " + self.xobj.pid + " already exists") 

1599 

1600 except Container.DoesNotExist: 

1601 container = Container( 

1602 ctype=self.xobj.ctype, 

1603 doi=self.xobj.doi, 

1604 pid=self.xobj.pid, 

1605 lang=self.xobj.lang, 

1606 title_xml=self.xobj.title_xml, 

1607 title_tex=self.xobj.title_tex, 

1608 title_html=self.xobj.title_html, 

1609 trans_lang=self.xobj.trans_lang, 

1610 trans_title_tex=self.xobj.trans_title_tex, 

1611 trans_title_html=self.xobj.trans_title_html, 

1612 provider=self.provider, 

1613 my_publisher=self._publisher, 

1614 my_collection=self.collection, 

1615 year=self.xobj.year, 

1616 vseries=vseries, 

1617 vseries_int=make_int(vseries), 

1618 volume=volume, 

1619 volume_int=make_int(volume), 

1620 number=number, 

1621 number_int=make_int(number), 

1622 seq=seq, 

1623 last_modified=last_modified, 

1624 with_online_first=with_online_first, 

1625 body_html=self.xobj.body_html, 

1626 body_tex=self.xobj.body_tex, 

1627 body_xml=self.xobj.body_xml, 

1628 ) 

1629 

1630 container.save() 

1631 

1632 return container 

1633 

1634 def post_do(self, container): 

1635 super().post_do(container) 

1636 

1637 if hasattr(self.xobj, "incollection"): 

1638 for incol in self.xobj.incollection: 

1639 # Ignore the first incollection which was treated as the main collection 

1640 if incol.pid != self.collection.pid: 

1641 collection = model_helpers.get_collection(incol.pid) 

1642 if collection: 1642 ↛ 1638line 1642 didn't jump to line 1638, because the condition on line 1642 was never false

1643 collection_membership = CollectionMembership( 

1644 collection=collection, 

1645 container=container, 

1646 seq=incol.seq, 

1647 vseries=incol.vseries, 

1648 volume="", 

1649 number=incol.volume, 

1650 vseries_int=make_int(incol.vseries), 

1651 volume_int=0, 

1652 number_int=make_int(incol.volume), 

1653 ) 

1654 collection_membership.save() 

1655 

1656 add_biblio(self.xobj, container) 

1657 add_counts(self.xobj, container, add_total=True) 

1658 add_relations(self.xobj, container) 

1659 add_frontmatter(self.xobj, container) 

1660 

1661 def post_undo(self): 

1662 collection = self.object_to_be_deleted.get_collection() 

1663 super().post_undo() 

1664 

1665 if self._publisher is not None: 

1666 if self._publisher.publishes.count() == 0: 

1667 self._publisher.delete() 

1668 self._publisher = None 

1669 

1670 if collection.parent and collection.content.count() == 0: 

1671 # Child collection that was created on the fly is removed automatically 

1672 # if it no longer has any content 

1673 collection.delete() 

1674 

1675 

1676class addArticleDatabaseCmd(addResourceDatabaseCmd): 

1677 """ 

1678 addArticleDatabaseCmd: adds/remove an article 

1679 

1680 an article needs a container (book or issue) 

1681 

1682 Exception raised: 

1683 - ValueError if the init params are empty 

1684 - exceptions.ResourceExists during do if the article already exists 

1685 - exceptions.ResourceDoesNotExist during undo if the Article does not exist 

1686 """ 

1687 

1688 def __init__(self, params=None): 

1689 # parents are used for book parts. 

1690 self.pseq = 0 # parent seq 

1691 self.parent = None # article parent 

1692 

1693 # Container containing the article 

1694 self.container = None 

1695 self.collection = None 

1696 

1697 self.assign_doi = False 

1698 self.seq = 0 

1699 

1700 self.translated_articles = [] 

1701 

1702 super().__init__(params) 

1703 

1704 def check_params(self): 

1705 super().check_params() 

1706 

1707 check_title = True 

1708 if hasattr(self.xobj, "doi") and self.xobj.doi and self.xobj.doi.find("pcjournal") > 0: 1708 ↛ 1709line 1708 didn't jump to line 1709, because the condition on line 1708 was never true

1709 check_title = False 

1710 if "original_article" in self.required_params: 1710 ↛ 1712line 1710 didn't jump to line 1712, because the condition on line 1710 was never true

1711 # A Translation may not have a title 

1712 check_title = False 

1713 if ( 1713 ↛ 1719line 1713 didn't jump to line 1719

1714 check_title 

1715 and self.is_add_cmd 

1716 and not self.xobj.title_tex 

1717 and not self.xobj.trans_title_tex 

1718 ): 

1719 raise ValueError("title_tex et trans_title_tex sont vides") 

1720 

1721 def set_container(self, container): 

1722 self.container = container 

1723 self.collection = container.my_collection 

1724 self.set_provider(container.provider) 

1725 

1726 def set_collection(self, collection): 

1727 self.collection = collection 

1728 self.set_provider(collection.provider) 

1729 

1730 def set_parent(self, parent): 

1731 self.parent = parent 

1732 

1733 def parse_dates(self): 

1734 dates = { 

1735 "accepted": None, 

1736 "received": None, 

1737 "revised": None, 

1738 "online": None, 

1739 "published": None, 

1740 } 

1741 

1742 for date_entry in self.xobj.history_dates: 

1743 if date_entry["date"] is None: 1743 ↛ 1744line 1743 didn't jump to line 1744, because the condition on line 1743 was never true

1744 raise ValueError( 

1745 f"The date {date_entry['type']} of the article {self.xobj.pid} is None" 

1746 ) 

1747 

1748 date = model_helpers.parse_date_str(date_entry["date"]) 

1749 dates[date_entry["type"]] = date 

1750 

1751 if self.xobj.date_published_iso_8601_date_str: 

1752 dates["published"] = model_helpers.parse_date_str( 

1753 self.xobj.date_published_iso_8601_date_str 

1754 ) 

1755 

1756 if self.xobj.prod_deployed_date_iso_8601_date_str: 

1757 self._prod_deployed_date = model_helpers.parse_date_str( 

1758 self.xobj.prod_deployed_date_iso_8601_date_str 

1759 ) 

1760 

1761 return dates 

1762 

1763 def add_translations(self, xobj, article): 

1764 if hasattr(xobj, "translations") and xobj.translations is not None: 1764 ↛ exitline 1764 didn't return from function 'add_translations', because the condition on line 1764 was never false

1765 for xarticle in xobj.translations: 1765 ↛ 1766line 1765 didn't jump to line 1766, because the loop on line 1765 never started

1766 cmd = addTranslatedArticleDatabaseCmd({"xobj": xarticle}) 

1767 cmd.set_original_article(article) 

1768 cmd.set_provider(article.provider) 

1769 trans_article = cmd.do() 

1770 self.translated_articles.append(trans_article) 

1771 

1772 def internal_do(self): 

1773 super().internal_do() 

1774 

1775 doi = self.xobj.doi 

1776 if self.assign_doi and not doi and self.container: 

1777 colid = self.container.my_collection.pid 

1778 doi = model_helpers.assign_doi(colid) 

1779 

1780 seq = self.xobj.seq or self.seq 

1781 dates = self.parse_dates() 

1782 

1783 try: 

1784 Article.objects.get( 

1785 pid=self.xobj.pid, doi=doi, provider=self.provider, my_container=self.container 

1786 ) 

1787 raise exceptions.ResourceExists("The article " + self.xobj.pid + " already exists") 

1788 except Article.DoesNotExist: 

1789 article = Article( 

1790 pid=self.xobj.pid, 

1791 doi=doi, 

1792 lang=self.xobj.lang, 

1793 title_xml=self.xobj.title_xml, 

1794 title_tex=self.xobj.title_tex, 

1795 title_html=self.xobj.title_html, 

1796 trans_lang=self.xobj.trans_lang, 

1797 trans_title_tex=self.xobj.trans_title_tex, 

1798 trans_title_html=self.xobj.trans_title_html, 

1799 provider=self.provider, 

1800 my_container=self.container, 

1801 fpage=self.xobj.fpage, 

1802 lpage=self.xobj.lpage, 

1803 seq=seq, 

1804 atype=self.xobj.atype, 

1805 page_range=self.xobj.page_range, 

1806 page_type=self.xobj.page_type, 

1807 elocation=self.xobj.elocation, 

1808 article_number=self.xobj.article_number, 

1809 talk_number=self.xobj.talk_number, 

1810 pseq=self.pseq, 

1811 parent=self.parent, 

1812 date_accepted=dates["accepted"], 

1813 date_received=dates["received"], 

1814 date_revised=dates["revised"], 

1815 date_online_first=dates["online"], 

1816 date_published=dates["published"], 

1817 coi_statement=self.xobj.coi_statement, 

1818 funding_statement_html=self.xobj.funding_statement_html, 

1819 funding_statement_xml=self.xobj.funding_statement_xml, 

1820 footnotes_html=self.xobj.footnotes_html, 

1821 footnotes_xml=self.xobj.footnotes_xml, 

1822 body_html=self.xobj.body_html, 

1823 body_tex=self.xobj.body_tex, 

1824 body_xml=self.xobj.body_xml, 

1825 ) 

1826 

1827 article.save() 

1828 

1829 if doi: 

1830 collection = self.collection 

1831 doi_number = model_helpers.get_number_from_doi(doi) 

1832 if doi_number > collection.last_doi: 

1833 collection.last_doi = doi_number 

1834 collection.save() 

1835 

1836 return article 

1837 

1838 def post_do(self, article): 

1839 super().post_do(article) 

1840 

1841 add_biblio(self.xobj, article) 

1842 add_counts(self.xobj, article, add_total=True) 

1843 add_relations(self.xobj, article) 

1844 self.add_translations(self.xobj, article) 

1845 

1846 

1847class addCollectionDatabaseCmd(addResourceDatabaseCmd): 

1848 """ 

1849 addCollectionDatabaseCmd: adds/remove a collection 

1850 

1851 Exception raised: 

1852 - ValueError if the init params are empty 

1853 - exceptions.ResourceExists during do if the book already exists 

1854 - exceptions.ResourceDoesNotExist during undo if the book does not exist 

1855 """ 

1856 

1857 def __init__(self, params=None): 

1858 # self.coltype = None 

1859 # self.wall = 5 

1860 self.parent = None 

1861 

1862 super().__init__(params) 

1863 

1864 def set_parent(self, parent): 

1865 self.parent = parent 

1866 

1867 def internal_do(self): 

1868 super().internal_do() 

1869 

1870 title_sort = ( 

1871 self.xobj.title_tex if len(self.xobj.title_tex) < 129 else self.xobj.title_tex[0:127] 

1872 ) 

1873 

1874 try: 

1875 col = Collection.objects.get( 

1876 pid=self.xobj.pid, 

1877 title_tex=self.xobj.title_tex, 

1878 provider__pid_type=self.provider.pid_type, 

1879 ) 

1880 except Collection.DoesNotExist: 

1881 col = Collection.objects.create( 

1882 coltype=self.xobj.coltype, 

1883 abbrev=self.xobj.abbrev, 

1884 wall=self.xobj.wall, 

1885 pid=self.xobj.pid, 

1886 lang=self.xobj.lang, 

1887 title_xml=self.xobj.title_xml, 

1888 title_tex=self.xobj.title_tex, 

1889 title_html=self.xobj.title_html, 

1890 title_sort=title_sort, 

1891 trans_lang=self.xobj.trans_lang, 

1892 trans_title_tex=self.xobj.trans_title_tex, 

1893 trans_title_html=self.xobj.trans_title_html, 

1894 provider=self.provider, 

1895 parent=self.parent, 

1896 ) 

1897 else: 

1898 raise exceptions.ResourceExists(f"The collection pid:{self.xobj.pid} already exists") 

1899 return col 

1900 

1901 # def internal_undo(self): 

1902 # super().internal_undo() 

1903 # 

1904 # try: 

1905 # col = Collection.objects.get(pid=self.pid, 

1906 # provider__pid_type=self.provider.pid_type) 

1907 # id = col.id 

1908 # if col.parent and not col.ancestors.all().count() : 

1909 # col.parent = None 

1910 # col.delete() 

1911 # 

1912 # 

1913 # elif not col.parent and not col.ancestors.all().count() : 

1914 # col.delete() 

1915 # 

1916 # except Collection.DoesNotExist: 

1917 # raise exceptions.ResourceDoesNotExist( 

1918 # "The collection " + self.pid + " does not exist") 

1919 # 

1920 # return id 

1921 

1922 

1923class addTranslatedArticleDatabaseCmd(addArticleDatabaseCmd): 

1924 """ 

1925 addTranslatedArticleDatabaseCmd: adds/remove a translated article 

1926 """ 

1927 

1928 def __init__(self, params=None): 

1929 super().__init__(params) 

1930 

1931 self.original_article = None 

1932 

1933 self.required_params = ["xobj", "original_article"] 

1934 

1935 def set_original_article(self, original_article): 

1936 self.original_article = original_article 

1937 

1938 def internal_do(self): 

1939 # DO NOT CALL the parent internal_do or it will create an Article 

1940 

1941 dates = self.parse_dates() 

1942 

1943 try: 

1944 TranslatedArticle.objects.get(pid=self.xobj.pid) 

1945 raise exceptions.ResourceExists( 

1946 "The translated article " + self.xobj.pid + " already exists" 

1947 ) 

1948 except Article.DoesNotExist: 

1949 article = TranslatedArticle( 

1950 original_article=self.original_article, 

1951 pid=self.xobj.pid, 

1952 doi=self.xobj.doi, 

1953 lang=self.xobj.lang, 

1954 title_xml=self.xobj.title_xml, 

1955 title_tex=self.xobj.title_tex, 

1956 title_html=self.xobj.title_html, 

1957 trans_lang=self.xobj.trans_lang, 

1958 trans_title_tex=self.xobj.trans_title_tex, 

1959 trans_title_html=self.xobj.trans_title_html, 

1960 provider=self.provider, 

1961 my_container=None, 

1962 fpage=self.xobj.fpage, 

1963 lpage=self.xobj.lpage, 

1964 seq=self.xobj.seq, 

1965 atype=self.xobj.atype, 

1966 page_range=self.xobj.page_range, 

1967 page_type=self.xobj.page_type, 

1968 elocation=self.xobj.elocation, 

1969 article_number=self.xobj.article_number, 

1970 talk_number=self.xobj.talk_number, 

1971 pseq=self.pseq, 

1972 parent=self.parent, 

1973 date_accepted=dates["accepted"], 

1974 date_received=dates["received"], 

1975 date_revised=dates["revised"], 

1976 date_online_first=dates["online"], 

1977 date_published=dates["published"], 

1978 coi_statement=self.xobj.coi_statement, 

1979 funding_statement_html=self.xobj.funding_statement_html, 

1980 funding_statement_xml=self.xobj.funding_statement_xml, 

1981 footnotes_html=self.xobj.footnotes_html, 

1982 footnotes_xml=self.xobj.footnotes_xml, 

1983 body_html=self.xobj.body_html, 

1984 body_tex=self.xobj.body_tex, 

1985 body_xml=self.xobj.body_xml, 

1986 ) 

1987 

1988 article.save() 

1989 

1990 return article 

1991 

1992 def post_do(self, container): 

1993 super().post_do(container) 

1994 

1995 if hasattr(self.xobj, "incollection"): 

1996 for incol in self.xobj.incollection: 

1997 # Ignore the first incollection which was treated as the main collection 

1998 if incol.pid != self.collection.pid: 

1999 collection = model_helpers.get_collection(incol.pid) 

2000 if collection: 

2001 collection_membership = CollectionMembership( 

2002 collection=collection, 

2003 container=container, 

2004 seq=incol.seq, 

2005 vseries=incol.vseries, 

2006 volume="", 

2007 number=incol.volume, 

2008 vseries_int=make_int(incol.vseries), 

2009 volume_int=0, 

2010 number_int=make_int(incol.volume), 

2011 ) 

2012 collection_membership.save() 

2013 

2014 add_biblio(self.xobj, container) 

2015 add_counts(self.xobj, container, add_total=True) 

2016 add_relations(self.xobj, container) 

2017 add_frontmatter(self.xobj, container) 

2018 

2019 def post_undo(self): 

2020 collection = self.object_to_be_deleted.get_collection() 

2021 super().post_undo() 

2022 

2023 if self._publisher is not None: 

2024 if self._publisher.publishes.count() == 0: 

2025 self._publisher.delete() 

2026 self._publisher = None 

2027 

2028 if collection.parent and collection.content.count() == 0: 

2029 # Child collection that was created on the fly is removed automatically 

2030 # if it no longer has any content 

2031 collection.delete() 

2032 

2033 

2034########################################################################## 

2035########################################################################## 

2036# 

2037# Update Commands 

2038# 

2039########################################################################## 

2040########################################################################## 

2041 

2042 

2043class updateCollectionDatabaseCmd(addResourceDatabaseCmd): 

2044 """ 

2045 updateCollectionDatabaseCmd: updates a Collection (journal, acta) 

2046 

2047 a Collection needs a Provider 

2048 

2049 Exception raised: 

2050 - ValueError if the init params are empty 

2051 - exceptions.ResourceDoesNotExist during do if the Collection does not exist 

2052 """ 

2053 

2054 def __init__(self, params=None): 

2055 super().__init__(params) 

2056 

2057 def internal_do(self): 

2058 super().internal_do() 

2059 

2060 try: 

2061 collection = Collection.objects.get( 

2062 pid=self.xobj.pid, provider__pid_type=self.provider.pid_type 

2063 ) 

2064 except Collection.DoesNotExist: 

2065 raise exceptions.ResourceDoesNotExist(f"The journal {self.xobj.pid} does not exist") 

2066 

2067 # delete objects in direct relation with the collection 

2068 # the new related objects (extlink, resourceid...) will be added in 

2069 # addResourceDatabaseCmd::post_do 

2070 collection.extlink_set.all().delete() 

2071 collection.resourceid_set.all().delete() 

2072 collection.abstract_set.all().delete() 

2073 

2074 title_sort = ( 

2075 self.xobj.title_tex if len(self.xobj.title_tex) < 129 else self.xobj.title_tex[0:127] 

2076 ) 

2077 

2078 collection.coltype = self.xobj.coltype 

2079 collection.lang = self.xobj.lang 

2080 collection.title_xml = self.xobj.title_xml 

2081 collection.title_tex = self.xobj.title_tex 

2082 collection.title_html = self.xobj.title_html 

2083 collection.title_sort = title_sort 

2084 collection.abbrev = self.xobj.abbrev 

2085 

2086 collection.wall = self.xobj.wall 

2087 collection.save() 

2088 

2089 return collection 

2090 

2091 

2092class updateExtLinkDatabaseCmd(baseCmd): 

2093 """ 

2094 An extlink is a link to an external object (website, image...) 

2095 updateExtLinkDatabaseCmd: 

2096 - updates an ExtLink, or 

2097 - creates the object if it does not exist, or 

2098 - deletes the object if it exists and the new location value is empty 

2099 

2100 Exception raised: 

2101 - ValueError if the init params are empty 

2102 """ 

2103 

2104 def __init__(self, params=None): 

2105 self.rel = None # 'website' or 'small_icon' 

2106 self.mimetype = None 

2107 self.location = None 

2108 self.metadata = None 

2109 self.seq = None 

2110 self.resource = None 

2111 self.base = None 

2112 

2113 super().__init__(params) 

2114 

2115 self.required_params.extend(["rel", "resource"]) 

2116 

2117 def set_resource(self, resource): 

2118 self.resource = resource 

2119 

2120 def set_base(self, base): 

2121 self.base = base 

2122 

2123 def internal_do(self): 

2124 super().internal_do() 

2125 

2126 extlink = None 

2127 

2128 try: 

2129 extlink = ExtLink.objects.get(resource=self.resource, rel=self.rel) 

2130 self.seq = extlink.seq 

2131 

2132 except ExtLink.DoesNotExist: 

2133 if self.location: 

2134 if not self.seq: 

2135 self.seq = ExtLink.objects.filter(resource=self.resource).count() + 1 

2136 

2137 extlink = ExtLink(resource=self.resource, rel=self.rel, seq=self.seq) 

2138 extlink.save() 

2139 

2140 if self.location: 

2141 extlink.location = self.location 

2142 

2143 if self.rel in ["website", "test_website"]: 

2144 self.metadata = "website" 

2145 

2146 if self.base: 

2147 extlink.base = self.base 

2148 if self.mimetype: 

2149 extlink.mimetype = self.mimetype 

2150 if self.metadata: 

2151 extlink.metadata = self.metadata 

2152 

2153 extlink.seq = self.seq 

2154 

2155 extlink.save() 

2156 elif extlink: 

2157 extlink.delete() 

2158 extlink = None 

2159 

2160 return extlink 

2161 

2162 

2163class updateResourceIdDatabaseCmd(baseCmd): 

2164 """ 

2165 A ResourceId is another id of the resource (doi, issn...) 

2166 updateResourceIdDatabaseCmd: 

2167 - updates an ResourceId, or 

2168 - creates the object if it does not exist, or 

2169 - deletes the object if it exists and the new location value is empty 

2170 

2171 Exception raised: 

2172 - ValueError if the init params are empty 

2173 """ 

2174 

2175 def __init__(self, params={}): 

2176 self.id_type = None # 'doi', 'issn', 'e-issn' 

2177 self.id_value = None 

2178 self.resource = None 

2179 

2180 super().__init__(params) 

2181 

2182 self.required_params.extend(["id_type", "resource"]) 

2183 

2184 def set_resource(self, resource): 

2185 self.resource = resource 

2186 

2187 def internal_do(self): 

2188 super().internal_do() 

2189 

2190 resourceid = None 

2191 id_type = self.id_type 

2192 id_value = self.id_value 

2193 

2194 if id_type == "ojs-id": 2194 ↛ 2209line 2194 didn't jump to line 2209, because the condition on line 2194 was never false

2195 # ojs-id (aka article folder name in /cedram_dev) may not be unique 

2196 # create an internal id 

2197 if id_value == "edito": 2197 ↛ 2198line 2197 didn't jump to line 2198, because the condition on line 2197 was never true

2198 qs = ResourceId.objects.filter( 

2199 id_type="ojs-id", id_value__startswith=id_value + "$$" 

2200 ) 

2201 count = qs.count() 

2202 if count: 

2203 id_value = id_value + "$$" + str(count + 1) 

2204 else: 

2205 qs = ResourceId.objects.filter(id_type="ojs-id", id_value__startswith=id_value) 

2206 count = qs.count() 

2207 if count: 2207 ↛ 2208line 2207 didn't jump to line 2208, because the condition on line 2207 was never true

2208 id_value = id_value + "$$" + str(count + 1) 

2209 try: 

2210 resourceid = ResourceId.objects.get(resource=self.resource, id_type=id_type) 

2211 

2212 except ResourceId.DoesNotExist: 

2213 if id_value: 2213 ↛ 2216line 2213 didn't jump to line 2216, because the condition on line 2213 was never false

2214 resourceid = ResourceId(resource=self.resource, id_type=id_type, id_value=id_value) 

2215 

2216 if id_value: 2216 ↛ 2219line 2216 didn't jump to line 2219, because the condition on line 2216 was never false

2217 resourceid.id_value = id_value 

2218 resourceid.save() 

2219 elif resourceid: 

2220 resourceid.delete() 

2221 resourceid = None 

2222 

2223 return resourceid 

2224 

2225 

2226class deleteResourceDatabaseCmd(baseCmd): 

2227 """ 

2228 deleteResourceDatabaseCmd: base class for all resources 

2229 NOT USED. TODO: remove 

2230 """ 

2231 

2232 def __init__(self, params=None): 

2233 self.pid = None # primary id given by the provider 

2234 self.sid = None # surrogate id given by the provider 

2235 self.provider = None 

2236 

2237 super().__init__(params) 

2238 

2239 def pre_do(self): 

2240 super().pre_do() 

2241 

2242 if self.pid is None and self.sid is None: 

2243 raise ValueError("pid et sid sont vides") 

2244 

2245 if self.provider is None: 

2246 raise ValueError("provider est vide") 

2247 

2248 def set_provider(self, provider): 

2249 self.provider = provider 

2250 

2251 # May raise Provider.DoesNotExist 

2252 def set_provider_by_name_or_id(self, provider_name="", pid_type="", sid_type=None): 

2253 self.provider = Provider.objects.get( 

2254 name=provider_name, pid_type=pid_type, sid_type=sid_type 

2255 ) 

2256 

2257 

2258class publishArticleDatabaseCmd(baseCmd): 

2259 """ 

2260 Publish an article <=> Create a pub-date 

2261 @return: list of updated articles 

2262 """ 

2263 

2264 def __init__(self, params=None): 

2265 self.article = None 

2266 self.container = None 

2267 self.pre_publish = False # Publish on the test website 

2268 self.update_db = True 

2269 super().__init__(params) 

2270 

2271 self.required_params.extend(["article"]) 

2272 

2273 def set_article(self, article): 

2274 self.article = article 

2275 self.container = article.my_container 

2276 if self.container is None and article.classname == "TranslatedArticle": 

2277 self.container = self.article.original_article.my_container 

2278 

2279 def publish_article(self, article, update_articles): 

2280 # In a collection with standalone articles, the article number is based on 

2281 # the publication order. 

2282 # It has to be updated when we publish because of the articles excluded for publication 

2283 update_article_number = False 

2284 # TODO: use a param instead of checking PCJ 

2285 if self.container.my_collection.pid == "PCJ" and not self.pre_publish: 2285 ↛ 2286line 2285 didn't jump to line 2286, because the condition on line 2285 was never true

2286 update_article_number = True 

2287 

2288 article_number = ( 

2289 self.container.article_set.filter(date_published__isnull=False).count() + 1 

2290 ) 

2291 

2292 if (not article.date_published and not self.pre_publish) or ( 2292 ↛ exitline 2292 didn't return from function 'publish_article', because the condition on line 2292 was never false

2293 not article.date_pre_published and self.pre_publish 

2294 ): 

2295 today = model_helpers.parse_date_str(timezone.now().isoformat()) 

2296 

2297 # Les articles numérisés n'ont pas à avoir de date_published 

2298 # Les anciens articles issus de Cedrics ont déjà une date_published. 

2299 # Les nouveaux articles du Centre Mersenne sont publiés à partir de 2019. 

2300 year = article.get_year() 

2301 fyear, lyear = model_helpers.get_first_last_years(year) 

2302 try: 

2303 fyear = int(fyear) 

2304 except ValueError: 

2305 fyear = 0 

2306 

2307 if fyear > 2016 and not self.container.with_online_first: 

2308 if self.pre_publish: 2308 ↛ 2309line 2308 didn't jump to line 2309, because the condition on line 2308 was never true

2309 article.date_pre_published = today 

2310 else: 

2311 article.date_published = today 

2312 if update_article_number: 2312 ↛ 2313line 2312 didn't jump to line 2313, because the condition on line 2312 was never true

2313 article.article_number = "e" + str(article_number) 

2314 article_number += 1 

2315 if self.update_db: 2315 ↛ 2317line 2315 didn't jump to line 2317, because the condition on line 2315 was never false

2316 article.save() 

2317 update_articles.append(article) 

2318 elif fyear == 0 or self.container.with_online_first: 2318 ↛ 2319line 2318 didn't jump to line 2319, because the condition on line 2318 was never true

2319 if not article.date_online_first and not self.pre_publish: 

2320 # Online First 

2321 article.date_online_first = today 

2322 if self.update_db: 

2323 article.save() 

2324 update_articles.append(article) 

2325 elif self.pre_publish: 

2326 article.date_pre_published = today 

2327 if self.update_db: 

2328 article.save() 

2329 update_articles.append(article) 

2330 

2331 def internal_do(self): 

2332 update_articles = [] 

2333 

2334 # In a collection with standalone articles, the article number is based on 

2335 # the publication order. 

2336 # It has to be updated when we publish because of the articles excluded for publication 

2337 update_article_number = False 

2338 # TODO: use a param instead of checking PCJ 

2339 if self.container.my_collection.pid == "PCJ" and not self.pre_publish: 

2340 update_article_number = True 

2341 

2342 self.publish_article(self.article, update_articles) 

2343 

2344 # TODO: update in upload articles ? 

2345 

2346 # PCJ: update the article seq, it is used by the breadcrumb 

2347 if update_article_number: 

2348 i = 1 

2349 for article in self.container.article_set.exclude(do_not_publish=True).order_by( 

2350 "-date_published" 

2351 ): 

2352 article.seq = i 

2353 i += 1 

2354 article.save() 

2355 

2356 return update_articles 

2357 

2358 

2359class publishContainerDatabaseCmd(publishArticleDatabaseCmd): 

2360 """ 

2361 Publish a container <=> Create a pub-date for all articles/book-parts of the container 

2362 @var : fake : if True, return list of potentially updated articles BUT don't update database 

2363 @return: list of updated articles 

2364 """ 

2365 

2366 def __init__(self, params=None): 

2367 super().__init__(params) 

2368 

2369 self.required_params = ["container"] 

2370 

2371 def set_container(self, container): 

2372 self.container = container 

2373 

2374 def internal_do(self): 

2375 update_articles = [] 

2376 

2377 # In a collection with standalone articles, the article number is based on 

2378 # the publication order. 

2379 # It has to be updated when we publish because of the articles excluded for publication 

2380 update_article_number = False 

2381 # TODO: use a param instead of checking PCJ 

2382 if self.container.my_collection.pid == "PCJ" and not self.pre_publish: 2382 ↛ 2383line 2382 didn't jump to line 2383, because the condition on line 2382 was never true

2383 update_article_number = True 

2384 

2385 for article in self.container.article_set.exclude(do_not_publish=True): 

2386 self.publish_article(article, update_articles) 

2387 

2388 # PCJ: update the article seq, it is used by the breadcrumb 

2389 if update_article_number: 2389 ↛ 2390line 2389 didn't jump to line 2390, because the condition on line 2389 was never true

2390 i = 1 

2391 for article in self.container.article_set.exclude(do_not_publish=True).order_by( 

2392 "-date_published" 

2393 ): 

2394 article.seq = i 

2395 i += 1 

2396 article.save() 

2397 

2398 return update_articles 

2399 

2400 # TODO Le container(book) peut également avoir une date de publication 

2401 

2402 

2403def convert_contribs(pid, delete=False): 

2404 if pid == "PCJ": 

2405 # PCJ: pid start with "10_24072" 

2406 pid = "10_24072" 

2407 

2408 if delete: 

2409 revert_contribs(pid) 

2410 

2411 if pid is not None: 

2412 qs = Contrib.objects.filter( 

2413 Q(group__resource__pid__startswith=pid) 

2414 | Q(group__bibitem__resource__pid__startswith=pid) 

2415 ) 

2416 else: 

2417 qs = Contrib.objects.all()[0:100] 

2418 

2419 total = qs.count() 

2420 i = 1 

2421 percent = 0 

2422 

2423 for contrib in qs: 

2424 if int(i / total * 100) > percent: 

2425 percent += 1 

2426 if percent % 5 == 0: 

2427 print(pid, percent) 

2428 i += 1 

2429 

2430 # contrib_fields_list = Contrib.get_fields_list() 

2431 # contrib_fields = { 

2432 # attr_name: getattr(contrib, attr_name) for attr_name in contrib_fields_list 

2433 # } 

2434 

2435 # Augment the contrib attributes to match Contribution fields 

2436 role = contrib.contrib_type 

2437 if not role: 

2438 role = contrib.group.content_type 

2439 if not role: 

2440 role = "author" 

2441 if role[-1] == "s": 

2442 role = role[0:-1] 

2443 contrib.corresponding = role == "corresponding" 

2444 contrib.role = role if role != "corresponding" else "author" 

2445 

2446 ref_name = contrib.last_name if contrib.last_name else None 

2447 if ref_name is None: 

2448 ref_name = contrib.string_name if contrib.string_name else None 

2449 letter = get_first_letter(ref_name) if ref_name else "" 

2450 contrib.first_letter = letter 

2451 

2452 contrib.deceased_before_publication = contrib.deceased 

2453 contrib.idref = None 

2454 contrib.mid = None 

2455 

2456 contribution_fields_list = Contribution.get_fields_list() 

2457 contributions_fields = { 

2458 attr_name: getattr(contrib, attr_name) for attr_name in contribution_fields_list 

2459 } 

2460 

2461 contribution = Contribution( 

2462 resource=contrib.group.resource, bibitem=contrib.group.bibitem, **contributions_fields 

2463 ) 

2464 contribution.save() 

2465 

2466 for contrib_address in contrib.contribaddress_set.all(): 

2467 contrib_address.contribution = contribution 

2468 contrib_address.save() 

2469 

2470 qs = Contribution.objects.filter( 

2471 Q(resource__pid__startswith=pid) | Q(bibitem__resource__pid__startswith=pid) 

2472 ) 

2473 print(qs.count()) 

2474 

2475 

2476def revert_contribs(pid): 

2477 print(f"Delete Contribution for {pid}", end=" ") 

2478 Contribution.objects.filter( 

2479 Q(resource__pid__startswith=pid) | Q(bibitem__resource__pid__startswith=pid) 

2480 ).delete() 

2481 print("done")