1. <?php
2. namespace App\Entity;
4. use Doctrine\ORM\Mapping as ORM,
5.     Doctrine\Common\Collections\Collection,
6.     Doctrine\Common\Collections\ArrayCollection,
7.     Doctrine\DBAL\Types\Types,
8.     Doctrine\Common\Collections\Criteria;
10. use Doctrine\ORM\Mapping\Index;
11. use Gedmo\Mapping\Annotation as Gedmo;
13. use Symfony\Component\Serializer\Annotation\Groups,
14.     Symfony\Component\Validator\Constraints as Assert;
16. use ApiPlatform\Metadata\ApiResource,
17.     ApiPlatform\Metadata\ApiProperty,
18.     ApiPlatform\Metadata\Get,
19.     ApiPlatform\Metadata\GetCollection,
20.     ApiPlatform\Metadata\Post,
21.     ApiPlatform\Metadata\Put,
22.     ApiPlatform\Metadata\Delete,
23.     ApiPlatform\Metadata\ApiFilter,
24.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
25.     ApiPlatform\Doctrine\Orm\Filter\RangeFilter,
26.     ApiPlatform\Doctrine\Orm\Filter\DateFilter,
27.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
28.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
30. use App\Entity\Trait\IdTrait,
31.     App\Entity\Trait\UuidTrait,
32.     App\Entity\Trait\OrdStatTrait,
33.     App\Entity\Trait\TimestampableTrait,
34.     App\Entity\Trait\TranslatableTrait,
35.     App\Entity\Trait\Languages\JournalLanguagesTrait,
36.     App\Entity\Trait\ArchivedTrait,
37.     App\Entity\Trait\OwnerTrait,
38.     App\Entity\Trait\EditorialGroupableTrait,
39.     App\Entity\Trait\ImportIdTrait,
40.     App\Entity\Interface\TranslatableInterface,
41.     App\Entity\Interface\OrdStatableInterface,
42.     App\Entity\Interface\LanguageableInterface,
43.     App\Entity\Interface\EditorialGroupableInterface,
44.     App\Entity\Interface\ArchivableInterface,
45.     App\Entity\Interface\OwnerableInterface,
46.     App\Entity\Interface\CloneableInterface,
47.     App\Repository\JournalRepository;
49. use App\Enum\Language,
50.     App\Enum\JournalCoverType,
51.     App\Enum\JournalDefaultPage,
52.     App\Entity\Admin,
53.     App\Security\Voter\ArchivableVoter,
54.     App\Lib\Actions,
55.     App\DTO\CloneDTO,
56.     App\StateProcessor\CloneProcessor,
57.     App\Security\Voter\CloneVoter;
59. use App\Attribute\DenormalizationInject,
60.     App\Util\ClassUtils,
61.     App\Filter\IriFilter;
63. use App\Controller\Export\Journal\JournalCrossrefExporter,
64.     App\Controller\Export\Journal\JournalSimcheckCrossrefExporter,
65.     App\Controller\Export\Journal\JournalLicenceFulltextCrossrefExporter;
67. #[ApiResource(
68.     description: 'Journals',
69.     normalizationContext: ['groups' => [
70.         'read',
71.         'read:' . self::class,
72.         'read:' . self::class . 'Translation'
73.     ]],
74.     denormalizationContext: ['groups' => ['write']],
75.     security: 'is_granted("' . self::class . '")',
76.     order: ['ord' => 'desc'],
77.     operations: [
78.         new GetCollection(),
79.         new GetCollection(
80.             uriTemplate: '/journals/list',
81.             normalizationContext: [ 'groups' => ['read', 'read:list' ]],
82.         ),
83.         new Post(
84.             uriTemplate: '/journals/clone',
85.             input: CloneDTO::class,
86.             processor: CloneProcessor::class,
87.             security: 'is_granted("' . Actions::CLONE .'")',
88.             securityMessage: CloneVoter::MESSAGE
89.         ),
90.         new Post(),
91.         new Get(),
92.         new Get(
93.             name: 'get_journal_crossref',
94.             uriTemplate: '/journals/{uuid}/export/crossref',
95.             controller: JournalCrossrefExporter::class
96.         ),
97.         new Get(
98.             name: 'get_journal_simcheck_crossref',
99.             uriTemplate: '/journals/{uuid}/export/simcheck_crossref',
100.             controller: JournalSimcheckCrossrefExporter::class
101.         ),
102.         new Get(
103.             name: 'get_journal_licence_fulltext_crossref',
104.             uriTemplate: '/journals/{uuid}/export/licence_fulltext_crossref',
105.             controller: JournalLicenceFulltextCrossrefExporter::class
106.         ),
107.         new Put(),
108.         new Delete(
109.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
110.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
111.         ),
112.     ],
113.     extraProperties: ['standard_put' => false],
114. )]
115. #[ApiFilter(SearchFilter::class, properties: [
116.     'translations.title' => 'partial',
117.     'nativeTitle' => 'partial',
118.     'data.workingTitle' => 'partial',
119.     'data.issn' => 'exact',
120.     'data.eIssn' => 'exact',
121. ])]
122. #[ApiFilter(RangeFilter::class, properties: ['meinScore'])]
123. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
124. #[ApiFilter(IriFilter::class, properties: [
125.     'nativeLanguage',
126.     'domains.domain',
127.     'affiliations.affiliation',
128.     'data.periodicity',
129.     'data.type',
130.     'data.licence',
131.     'data.state'
132. ])]
133. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
134. #[ApiFilter(OrderFilter::class, properties: [
135.     'nativeTitle',
136.     'nativeLanguage',
137.     'data.workingTitle',
138.     'data.periodicity',
139.     'updatedAt',
140.     'stat',
141.     'ord'
142. ])]
143. #[Index(fields: ["nativeLanguage"], name: "native_language_idx")]
144. #[Index(fields: ["stat"], name: "stat_idx")]
145. #[ORM\Entity(repositoryClass: JournalRepository::class)]
146. class Journal implements
147.     TranslatableInterface,
148.     OrdStatableInterface,
149.     LanguageableInterface,
150.     EditorialGroupableInterface,
151.     ArchivableInterface,
152.     OwnerableInterface,
153.     CloneableInterface
154. {
155.     use IdTrait,
156.         UuidTrait,
157.         OrdStatTrait,
158.         TimestampableTrait,
159.         TranslatableTrait,
160.         JournalLanguagesTrait,
161.         ArchivedTrait,
162.         OwnerTrait,
163.         EditorialGroupableTrait,
164.         ImportIdTrait;
166.     #[ApiProperty(description: 'Native title sort key')]
167.     #[Groups(['read:' . self::class])]
168.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
169.     private ?string $nativeTitleSortKey = null;
171.     #[ApiProperty(description: 'Data subresource', writable: true)]
172.     #[Groups(['read:'. self::class, 'read:list', 'write'])]
173.     #[Assert\Valid]
174.     #[DenormalizationInject(method: ['name' => 'getData'])]
175.     #[ORM\OneToOne(targetEntity: JournalData::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
176.     private JournalData $data;
178.     #[ApiProperty(description: 'View subresource', writable: true)]
179.     #[Groups(['read:' . self::class, 'write'])]
180.     #[Assert\Valid]
181.     #[DenormalizationInject(method: ['name' => 'getView'])]
182.     #[ORM\OneToOne(targetEntity: JournalView::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
183.     private JournalView $view;
185.     #[ApiProperty(description: 'Slug')]
186.     #[Groups(['read:' . self::class, 'write'])]
187.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitle'])]
188.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
189.     private ?string $slug = null;
191.     #[ApiProperty(description: 'Slug')]
192.     #[Groups(['read:' . self::class, 'write'])]
193.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
194.     private ?string $importSlug = null;
196.     #[ApiProperty(description: 'Slug')]
197.     #[Groups(['read:' . self::class, 'write'])]
198.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
199.     private ?string $importSlugEn = null;
201.     #[ApiProperty(description: 'Scientific council members', writableLink: false)]
202.     #[ORM\OneToMany(targetEntity: JournalScientificCouncilMember::class, mappedBy: 'parent', cascade: ['persist'])]
203.     #[ORM\OrderBy(['ord' => 'desc'])]
204.     private Collection $scientificCouncilMembers;
206.     #[ApiProperty(description: 'Domains', fetchEager: false)]
207.     #[Groups(['read', 'read:list'])]
208.     #[ORM\OneToMany(targetEntity: JournalDomain::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
209.     #[ORM\OrderBy(['ord' => 'desc'])]
210.     private Collection $domains;
212.     #[ApiProperty(description: 'Indexation collections')]
213.     #[ORM\OneToMany(targetEntity: JournalIndexationCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
214.     #[ORM\OrderBy(['ord' => 'desc'])]
215.     private Collection $indexationCollections;
217.     #[ApiProperty(description: 'Indicators')]
218.     #[ORM\OneToMany(targetEntity: JournalIndicator::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
219.     #[ORM\OrderBy(['ord' => 'desc'])]
220.     private Collection $indicators;
222.     #[ApiProperty(description: 'Affiliations', fetchEager: false)]
223.     #[Groups(['read','read:list'])]
224.     #[ORM\OneToMany(targetEntity: JournalAffiliation::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
225.     #[ORM\OrderBy(['ord' => 'desc'])]
226.     private Collection $affiliations;
228.     #[ApiProperty(description: 'Publishers')]
229.     #[ORM\OneToMany(targetEntity: JournalPublisher::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
230.     #[ORM\OrderBy(['ord' => 'desc'])]
231.     private Collection $publishers;
233.     #[ApiProperty(description: 'Partners')]
234.     #[ORM\OneToMany(targetEntity: JournalPartner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
235.     #[ORM\OrderBy(['ord' => 'desc'])]
236.     private Collection $partners;
238.     #[ApiProperty(description: 'Slides')]
239.     #[ORM\OneToMany(targetEntity: JournalSlide::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
240.     #[ORM\OrderBy(['ord' => 'desc'])]
241.     private Collection $slides;
243.     #[ApiProperty(description: 'Sections')]
244.     #[ORM\OneToMany(targetEntity: JournalSection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
245.     #[ORM\OrderBy(['ord' => 'desc'])]
246.     private Collection $sections;
248.     #[ApiProperty(description: 'Menu items')]
249.     #[ORM\OneToMany(targetEntity: JournalMenuItem::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
250.     #[ORM\OrderBy(['ord' => 'desc'])]
251.     private Collection $menuItems;
253.     #[ApiProperty(description: 'Submenu groups')]
254.     #[ORM\OneToMany(targetEntity: JournalSubmenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
255.     #[ORM\OrderBy(['ord' => 'desc'])]
256.     private Collection $submenuGroups;
258.     #[ApiProperty(description: 'Sidemenu groups')]
259.     #[ORM\OneToMany(targetEntity: JournalSidemenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
260.     #[ORM\OrderBy(['ord' => 'desc'])]
261.     private Collection $sidemenuGroups;
263.     #[ApiProperty(description: 'Banners')]
264.     #[ORM\OneToMany(targetEntity: JournalBanner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
265.     #[ORM\OrderBy(['ord' => 'desc'])]
266.     private Collection $banners;
268.     #[ApiProperty(description: 'Volumes')]
269.     #[ORM\OneToMany(targetEntity: JournalVolume::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
270.     #[ORM\OrderBy(['ord' => 'desc'])]
271.     private Collection $volumes;
273.     #[ApiProperty(description: 'Issues')]
274.     #[ORM\OneToMany(targetEntity: JournalIssue::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
275.     #[ORM\OrderBy(['ord' => 'desc'])]
276.     private Collection $issues;
278.     #[ApiProperty(description: 'Articles')]
279.     #[ORM\OneToMany(targetEntity: JournalArticle::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
280.     #[ORM\OrderBy(['ord' => 'desc'])]
281.     private Collection $articles;
283.     #[ApiProperty(description: 'Pages')]
284.     #[ORM\OneToMany(targetEntity: JournalPage::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
285.     #[ORM\OrderBy(['ord' => 'desc'])]
286.     private Collection $pages;
288.     #[ApiProperty(description: 'News')]
289.     #[ORM\OneToMany(targetEntity: JournalNews::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
290.     #[ORM\OrderBy(['ord' => 'desc'])]
291.     private Collection $news;
293.     #[ApiProperty(description: 'Collections')]
294.     #[ORM\OneToMany(targetEntity: JournalCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
295.     #[ORM\OrderBy(['ord' => 'desc'])]
296.     private Collection $collections;
298.     #[ApiProperty(description: 'Sort article by ord')]
299.     #[Groups(['read:' . self::class, 'write'])]
300.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
301.     private bool $sortArticlesByOrd = false;
303.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalFooter::class, orphanRemoval: true)]
304.     private Collection $smallFooters;
306.     public function __construct(Admin $createdBy, ?array $languages)
307.     {
308.         $this->setUuid();
310.         $this->data = new JournalData($this);
311.         $this->view = new JournalView($this);
313.         $this->createdBy = $createdBy;
314.         $this->updatedBy = $createdBy;
316.         $this->translations = new ArrayCollection();
318.         $this->domains = new ArrayCollection();
319.         $this->indexationCollections = new ArrayCollection();
320.         $this->indicators = new ArrayCollection();
322.         $this->affiliations = new ArrayCollection();
323.         $this->publishers = new ArrayCollection();
324.         $this->partners = new ArrayCollection();
326.         $this->slides = new ArrayCollection();
327.         $this->editorialGroups = new ArrayCollection();
328.         $this->scientificCouncilMembers = new ArrayCollection();
329.         $this->sections = new ArrayCollection();
331.         $this->menuItems = new ArrayCollection();
332.         $this->submenuGroups = new ArrayCollection();
333.         $this->sidemenuGroups = new ArrayCollection();
334.         $this->banners = new ArrayCollection();
336.         $this->volumes = new ArrayCollection();
337.         $this->issues = new ArrayCollection();
338.         $this->articles = new ArrayCollection();
340.         $this->pages = new ArrayCollection();
341.         $this->news = new ArrayCollection();
343.         $this->collections = new ArrayCollection();
345.         $this->setLanguages($languages ?? Language::DEFAULT_JOURNAL);
347.         foreach (array_reverse(JournalDefaultPage::cases()) as $index => $idName) {
348.             new JournalPage(
349.                 parent: $this,
350.                 workingTitle: $idName->value,
351.                 idName: $idName->value,
352.                 ord: $index + 1,
353.                 stat: true
354.             );
355.         }
357.         $this->createdAt = new \DateTimeImmutable();
358.         $this->updatedAt = new \DateTimeImmutable();
359.         $this->smallFooters = new ArrayCollection();
360.     }
362.     public function getTitle(): string
363.     {
364.         return $this->data->getWorkingTitle();
365.     }
367.     public function setNativeTitleSortKey(string $nativeTitleSortKey): self
368.     {
369.         $this->nativeTitleSortKey = $nativeTitleSortKey;
371.         return $this;
372.     }
374.     public function getNativeTitleSortKey(): ?string
375.     {
376.         return $this->nativeTitleSortKey;
377.     }
379.     public function getData(): JournalData
380.     {
381.         return $this->data;
382.     }
384.     public function getView(): JournalView
385.     {
386.         return $this->view;
387.     }
389.     public function getCover(Language $lang): ?Media
390.     {
391.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
392.             return $this->readAvailableTranslation($lang, 'cover');
393.         }
395.         if ($cover = $this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
396.             return $cover;
397.         }
399.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
400.             ? $this->readAvailableTranslation($lang, 'cover')
401.             : null;
402.     }
404.     public function getCoverAlt(Language $lang): ?string
405.     {
406.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
407.             return $this->readAvailableTranslation($lang, 'coverAlt');
408.         }
410.         if ($this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
411.             return $this->getNewestIssue()?->readAvailableTranslation($lang, 'coverAlt');
412.         }
414.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
415.             ? $this->readAvailableTranslation($lang, 'coverAlt')
416.             : null;
417.     }
419.     public function getSlug(): ?string
420.     {
421.         return $this->slug;
422.     }
424.     public function setSlug(?string $slug): self
425.     {
426.         $this->slug = $slug;
428.         return $this;
429.     }
431.     public function getImportSlug(): ?string
432.     {
433.         return $this->importSlug;
434.     }
436.     public function setImportSlug(?string $importSlug): self
437.     {
438.         $this->importSlug = $importSlug;
440.         return $this;
441.     }
443.     public function getImportSlugEn(): ?string
444.     {
445.         return $this->importSlugEn;
446.     }
448.     public function setImportSlugEn(?string $importSlugEn): self
449.     {
450.         $this->importSlugEn = $importSlugEn;
452.         return $this;
453.     }
455.     /**
456.      * @return Collection|JournalScientificCouncilMember[]
457.      */
458.     public function getScientificCouncilMembers(): Collection
459.     {
460.         return $this->scientificCouncilMembers;
461.     }
463.     public function addScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
464.     {
465.         if ($this->scientificCouncilMembers->contains($scientificCouncilMember)) {
466.             return $this;
467.         }
469.         $this->scientificCouncilMembers[] = $scientificCouncilMember;
471.         return $this;
472.     }
474.     public function removeScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
475.     {
476.         $this->scientificCouncilMembers->removeElement($scientificCouncilMember);
478.         return $this;
479.     }
481.     public function resetScientificCouncilMembers(): self
482.     {
483.         $this->scientificCouncilMembers = new ArrayCollection();
485.         return $this;
486.     }
488.     /**
489.      * @return Collection|JournalDomain[]
490.      */
491.     public function getDomains(): Collection
492.     {
493.         return $this->domains;
494.     }
496.     public function addDomain(JournalDomain $domain): self
497.     {
498.         if ($this->domains->contains($domain)) {
499.             return $this;
500.         }
502.         $this->domains[] = $domain;
504.         return $this;
505.     }
507.     public function removeDomain(JournalDomain $domain): self
508.     {
509.         $this->domains->removeElement($domain);
511.         return $this;
512.     }
514.     public function resetDomains(): self
515.     {
516.         $this->domains = new ArrayCollection();
518.         return $this;
519.     }
521.     /**
522.      * @return Collection|JournalIndexationCollection[]
523.      */
524.     public function getIndexationCollections(): Collection
525.     {
526.         return $this->indexationCollections;
527.     }
529.     public function addIndexationCollection(JournalIndexationCollection $indexationCollection): self
530.     {
531.         if ($this->indexationCollections->contains($indexationCollection)) {
532.             return $this;
533.         }
535.         $this->indexationCollections[] = $indexationCollection;
537.         return $this;
538.     }
540.     public function removeIndexationCollection(JournalIndexationCollection $indexationCollection): self
541.     {
542.         $this->indexationCollections->removeElement($indexationCollection);
544.         return $this;
545.     }
547.     public function resetIndexationCollections(): self
548.     {
549.         $this->indexationCollections = new ArrayCollection();
551.         return $this;
552.     }
554.     /**
555.      * @return Collection|JournalIndicator[]
556.      */
557.     public function getIndicators(): Collection
558.     {
559.         return $this->indicators;
560.     }
562.     public function addIndicator(JournalIndicator $indicator): self
563.     {
564.         if ($this->indicators->contains($indicator)) {
565.             return $this;
566.         }
568.         $this->indicators[] = $indicator;
570.         return $this;
571.     }
573.     public function removeIndicator(JournalIndicator $indicator): self
574.     {
575.         $this->indicators->removeElement($indicator);
577.         return $this;
578.     }
580.     public function resetIndicators(): self
581.     {
582.         $this->indicators = new ArrayCollection();
584.         return $this;
585.     }
587.     /**
588.      * @return Collection|JournalAffiliation[]
589.      */
590.     public function getAffiliations(): Collection
591.     {
592.         return $this->affiliations;
593.     }
595.     public function addAffiliation(JournalAffiliation $affiliation): self
596.     {
597.         if ($this->affiliations->contains($affiliation)) {
598.             return $this;
599.         }
601.         $this->affiliations[] = $affiliation;
603.         return $this;
604.     }
606.     public function removeAffiliation(JournalAffiliation $affiliation): self
607.     {
608.         $this->affiliations->removeElement($affiliation);
610.         return $this;
611.     }
613.     public function resetAffiliations(): self
614.     {
615.         $this->affiliations = new ArrayCollection();
617.         return $this;
618.     }
620.     /**
621.      * @return Collection|JournalPublisher[]
622.      */
623.     public function getPublishers(): Collection
624.     {
625.         return $this->publishers;
626.     }
628.     public function addPublisher(JournalPublisher $publisher): self
629.     {
630.         if ($this->publishers->contains($publisher)) {
631.             return $this;
632.         }
634.         $this->publishers[] = $publisher;
636.         return $this;
637.     }
639.     public function removePublisher(JournalPublisher $publisher): self
640.     {
641.         $this->publishers->removeElement($publisher);
643.         return $this;
644.     }
646.     public function resetPublishers(): self
647.     {
648.         $this->publishers = new ArrayCollection();
650.         return $this;
651.     }
653.     public function getVisiblePublishers(): Collection
654.     {
655.         return $this->publishers->filter(
656.             fn (JournalPublisher $publisher) =>
657.                 $publisher->getStat() === true &&
658.                 $publisher->getPublisher()->getStat() === true
659.         );
660.     }
662.     /**
663.      * @return Collection|JournalPartner[]
664.      */
665.     public function getPartners(): Collection
666.     {
667.         return $this->partners;
668.     }
670.     public function addPartner(JournalPartner $partner): self
671.     {
672.         if ($this->partners->contains($partner)) {
673.             return $this;
674.         }
676.         $this->partners[] = $partner;
678.         return $this;
679.     }
681.     public function removePartner(JournalPartner $partner): self
682.     {
683.         $this->partners->removeElement($partner);
685.         return $this;
686.     }
688.     public function resetPartners(): self
689.     {
690.         $this->partners = new ArrayCollection();
692.         return $this;
693.     }
695.     /**
696.      * @return Collection|JournalSlide[]
697.      */
698.     public function getSlides(): Collection
699.     {
700.         return $this->slides;
701.     }
703.     public function addSlide(JournalSlide $slide): self
704.     {
705.         if ($this->slides->contains($slide)) {
706.             return $this;
707.         }
709.         $this->slides[] = $slide;
711.         return $this;
712.     }
714.     public function removeSlide(JournalSlide $slide): self
715.     {
716.         $this->slides->removeElement($slide);
718.         return $this;
719.     }
721.     public function resetSlides(): self
722.     {
723.         $this->slides = new ArrayCollection();
725.         return $this;
726.     }
728.     /**
729.      * @return Collection|JournalSection[]
730.      */
731.     public function getSections(): Collection
732.     {
733.         return $this->sections;
734.     }
736.     public function addSection(JournalSection $section): self
737.     {
738.         if ($this->sections->contains($section)) {
739.             return $this;
740.         }
742.         $this->sections[] = $section;
744.         return $this;
745.     }
747.     public function removeSection(JournalSection $section): self
748.     {
749.         $this->sections->removeElement($section);
751.         return $this;
752.     }
754.     public function resetSections(): self
755.     {
756.         $this->sections = new ArrayCollection();
758.         return $this;
759.     }
761.     /**
762.      * @return Collection|JournalMenuItem[]
763.      */
764.     public function getMenuItems(): Collection
765.     {
766.         return $this->menuItems;
767.     }
769.     public function addMenuItem(JournalMenuItem $menuItem): self
770.     {
771.         if ($this->menuItems->contains($menuItem)) {
772.             return $this;
773.         }
775.         $this->menuItems[] = $menuItem;
777.         return $this;
778.     }
780.     public function removeMenuItem(JournalMenuItem $menuItem): self
781.     {
782.         $this->menuItems->removeElement($menuItem);
784.         return $this;
785.     }
787.     public function resetMenuItems(): self
788.     {
789.         $this->menuItems = new ArrayCollection();
791.         return $this;
792.     }
794.     /**
795.      * @return Collection|JournalSubmenuGroup[]
796.      */
797.     public function getSubmenuGroups(): Collection
798.     {
799.         return $this->submenuGroups;
800.     }
802.     public function addSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
803.     {
804.         if ($this->submenuGroups->contains($submenuGroup)) {
805.             return $this;
806.         }
808.         $this->submenuGroups[] = $submenuGroup;
810.         return $this;
811.     }
813.     public function removeSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
814.     {
815.         $this->submenuGroups->removeElement($submenuGroup);
817.         return $this;
818.     }
820.     public function resetSubmenuGroups(): self
821.     {
822.         $this->submenuGroups = new ArrayCollection();
824.         return $this;
825.     }
827.     /**
828.      * @return Collection|JournalSidemenuGroup[]
829.      */
830.     public function getSidemenuGroups(): Collection
831.     {
832.         return $this->sidemenuGroups;
833.     }
835.     public function addSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
836.     {
837.         if ($this->sidemenuGroups->contains($sidemenuGroup)) {
838.             return $this;
839.         }
841.         $this->sidemenuGroups[] = $sidemenuGroup;
843.         return $this;
844.     }
846.     public function removeSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
847.     {
848.         $this->sidemenuGroups->removeElement($sidemenuGroup);
850.         return $this;
851.     }
853.     public function resetSidemenuGroups(): self
854.     {
855.         $this->sidemenuGroups = new ArrayCollection();
857.         return $this;
858.     }
860.     /**
861.      * @return Collection|JournalBanner[]
862.      */
863.     public function getBanners(): Collection
864.     {
865.         return $this->banners;
866.     }
868.     public function addBanner(JournalBanner $banner): self
869.     {
870.         if ($this->banners->contains($banner)) {
871.             return $this;
872.         }
874.         $this->banners[] = $banner;
876.         return $this;
877.     }
879.     public function removeBanner(JournalBanner $banner): self
880.     {
881.         $this->banners->removeElement($banner);
883.         return $this;
884.     }
886.     public function resetBanners(): self
887.     {
888.         $this->banners = new ArrayCollection();
890.         return $this;
891.     }
893.     /**
894.      * @return Collection|JournalVolume[]
895.      */
896.     public function getVolumes(): Collection
897.     {
898.         return $this->volumes;
899.     }
901.     public function addVolume(JournalVolume $volume): self
902.     {
903.         if ($this->volumes->contains($volume)) {
904.             return $this;
905.         }
907.         $this->volumes[] = $volume;
909.         return $this;
910.     }
912.     public function removeVolume(JournalVolume $volume): self
913.     {
914.         $this->volumes->removeElement($volume);
916.         return $this;
917.     }
919.     public function resetVolumes(): self
920.     {
921.         $this->volumes = new ArrayCollection();
923.         return $this;
924.     }
926.     /**
927.      * @return Collection<int, JournalIssue>
928.      */
929.     public function getIssues(): Collection
930.     {
931.         return $this->issues;
932.     }
934.     /**
935.      * @return Collection<int, JournalIssue>
936.      */
937.     public function getVisibleIssues(): Collection
938.     {
939.         return $this->issues->filter(fn (JournalIssue $issue) => $issue->getStat());
940.     }
942.     public function addIssue(JournalIssue $issue): self
943.     {
944.         if ($this->issues->contains($issue)) {
945.             return $this;
946.         }
948.         $this->issues[] = $issue;
950.         return $this;
951.     }
953.     public function removeIssue(JournalIssue $issue): self
954.     {
955.         $this->issues->removeElement($issue);
957.         return $this;
958.     }
960.     public function resetIssues(): self
961.     {
962.         $this->issues = new ArrayCollection();
964.         return $this;
965.     }
967.     public function getNewestIssue(): ?JournalIssue
968.     {
969.         foreach ($this->getIssues() as $issue) {
970.             if ($issue->getStat() && $issue->getIsNewestIssue()) {
971.                 return $issue;
972.             }
973.         }
975.         return null;
976.     }
978.     public function getOldestIssue(): ?JournalIssue
979.     {
980.         $filtered = new ArrayCollection();
982.         foreach ($this->getIssues() as $issue) {
983.             if ($issue->getStat() && $issue->getPublishedAt()) {
984.                 $filtered->add($issue);
985.             }
986.         }
988.         if (count($filtered) === 0) {
989.             return null;
990.         }
992.         $criteria = Criteria::create()->orderBy(['publishedAt' => Criteria::ASC]);
994.         return $filtered
995.             ->matching($criteria)
996.             ->first();
997.     }
999.     /**
1000.      * @return Collection|JournalArticle[]
1001.      */
1002.     public function getArticles(): Collection
1003.     {
1004.         return $this->articles;
1005.     }
1007.     /**
1008.      * @return Collection<int, JournalArticle>
1009.      */
1010.     public function getArticlesVisible(): Collection
1011.     {
1012.         return $this->articles->filter(fn (JournalArticle $article) => $article->getStat());
1013.     }
1015.     public function addArticle(JournalArticle $article): self
1016.     {
1017.         if ($this->articles->contains($article)) {
1018.             return $this;
1019.         }
1021.         $this->articles[] = $article;
1023.         return $this;
1024.     }
1026.     public function removeArticle(JournalArticle $article): self
1027.     {
1028.         $this->articles->removeElement($article);
1030.         return $this;
1031.     }
1033.     public function resetArticles(): self
1034.     {
1035.         $this->articles = new ArrayCollection();
1037.         return $this;
1038.     }
1040.     /**
1041.      * @return Collection|JournalPage[]
1042.      */
1043.     public function getPages(): Collection
1044.     {
1045.         return $this->pages;
1046.     }
1048.     public function addPage(JournalPage $page): self
1049.     {
1050.         if ($this->pages->contains($page)) {
1051.             return $this;
1052.         }
1054.         $this->pages[] = $page;
1056.         return $this;
1057.     }
1059.     public function removePage(JournalPage $page): self
1060.     {
1061.         $this->pages->removeElement($page);
1063.         return $this;
1064.     }
1066.     public function resetPages(): self
1067.     {
1068.         $this->pages = new ArrayCollection();
1070.         return $this;
1071.     }
1073.     /**
1074.      * @return Collection|JournalNews[]
1075.      */
1076.     public function getNews(): Collection
1077.     {
1078.         return $this->news;
1079.     }
1081.     public function addNews(JournalNews $news): self
1082.     {
1083.         if ($this->news->contains($news)) {
1084.             return $this;
1085.         }
1087.         $this->news[] = $news;
1089.         return $this;
1090.     }
1092.     public function removeNews(JournalNews $news): self
1093.     {
1094.         $this->news->removeElement($news);
1096.         return $this;
1097.     }
1099.     public function resetNews(): self
1100.     {
1101.         $this->news = new ArrayCollection();
1103.         return $this;
1104.     }
1106.     /**
1107.      * @return Collection|JournalCollection[]
1108.      */
1109.     public function getCollections(): Collection
1110.     {
1111.         return $this->collections;
1112.     }
1114.     public function addCollection(JournalCollection $collection): self
1115.     {
1116.         if ($this->collections->contains($collection)) {
1117.             return $this;
1118.         }
1120.         $this->collections[] = $collection;
1122.         return $this;
1123.     }
1125.     public function removeCollection(JournalCollection $news): self
1126.     {
1127.         $this->news->removeElement($news);
1129.         return $this;
1130.     }
1132.     public function resetCollections(): self
1133.     {
1134.         $this->collections = new ArrayCollection();
1136.         return $this;
1137.     }
1139.     public function clone(Admin $createdBy = null): self
1140.     {
1141.         $clone = clone $this;
1143.         $clone->id = null;
1144.         $clone->setUuid();
1146.         $clone->ord = 0;
1147.         $clone->stat = false;
1148.         $clone->importId = null;
1150.         $clone->data = $this->data->clone($clone);
1151.         $clone->view = $this->view->clone($clone);
1153.         $nativeLanguage = $clone->getNativeLanguage();
1154.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
1155.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
1157.         ClassUtils::cloneCollection($this, $clone, 'translations');
1159.         $clone
1160.             ->resetDomains()
1161.             ->resetIndexationCollections()
1162.             ->resetIndicators()
1163.             ->resetAffiliations()
1164.             ->resetPublishers()
1165.             ->resetPartners()
1166.             ->resetSlides()
1167.             ->resetSections()
1168.             ->resetMenuItems()
1169.             ->resetSubmenuGroups()
1170.             ->resetBanners()
1171.             ->resetVolumes()
1172.             ->resetIssues()
1173.             ->resetArticles()
1174.             ->resetPages()
1175.             ->resetNews()
1176.             ->resetCollections()
1177.             ->resetEditorialGroups()
1178.             ->resetScientificCouncilMembers();
1180.         $clone->createdBy = $createdBy ?? $clone->createdBy;
1181.         $clone->updatedBy = $createdBy ?? $clone->updatedBy;
1183.         $clone->createdAt = new \DateTimeImmutable();
1184.         $clone->updatedAt = new \DateTimeImmutable();
1186.         return $clone;
1187.     }
1189.     public function isSortArticlesByOrd(): bool
1190.     {
1191.         return $this->sortArticlesByOrd;
1192.     }
1194.     public function setSortArticlesByOrd(bool $sortArticlesByOrd): self
1195.     {
1196.         $this->sortArticlesByOrd = $sortArticlesByOrd;
1198.         return $this;
1199.     }
1201.     /**
1202.      * @return Collection<int, JournalFooter>
1203.      */
1204.     public function getSmallFooters(): Collection
1205.     {
1206.         return $this->smallFooters;
1207.     }
1209.     public function addSmallFooter(JournalFooter $smallFooter): self
1210.     {
1211.         if (!$this->smallFooters->contains($smallFooter)) {
1212.             $this->smallFooters->add($smallFooter);
1213.             $smallFooter->setParent($this);
1214.         }
1216.         return $this;
1217.     }
1219.     public function removeSmallFooter(JournalFooter $smallFooter): self
1220.     {
1221.         if ($this->smallFooters->removeElement($smallFooter)) {
1222.             // set the owning side to null (unless already changed)
1223.             if ($smallFooter->getParent() === $this) {
1224.                 $smallFooter->setParent(null);
1225.             }
1226.         }
1228.         return $this;
1229.     }
1231.     public function getVisibleSmallFooters(): Collection
1232.     {
1233.         return $this->smallFooters->filter(fn (JournalFooter $smallFooter) => $smallFooter->getStat());
1234.     }
1235. }