1. <?php
3. namespace App\Entity;
5. use Doctrine\ORM\Mapping as ORM,
6.     Doctrine\Common\Collections\Collection,
7.     Doctrine\Common\Collections\ArrayCollection,
8.     Doctrine\DBAL\Types\Types,
9.     Doctrine\Common\Collections\Criteria;
11. use Doctrine\ORM\Mapping\Index;
12. use Gedmo\Mapping\Annotation as Gedmo;
14. use Symfony\Component\Serializer\Annotation\Groups,
15.     Symfony\Component\Validator\Constraints as Assert;
17. use ApiPlatform\Metadata\ApiResource,
18.     ApiPlatform\Metadata\ApiProperty,
19.     ApiPlatform\Metadata\Get,
20.     ApiPlatform\Metadata\GetCollection,
21.     ApiPlatform\Metadata\Post,
22.     ApiPlatform\Metadata\Put,
23.     ApiPlatform\Metadata\Delete,
24.     ApiPlatform\Metadata\ApiFilter,
25.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
26.     ApiPlatform\Doctrine\Orm\Filter\RangeFilter,
27.     ApiPlatform\Doctrine\Orm\Filter\DateFilter,
28.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
29.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter;
31. use App\Entity\Trait\IdTrait,
32.     App\Entity\Trait\UuidTrait,
33.     App\Entity\Trait\OrdStatTrait,
34.     App\Entity\Trait\TimestampableTrait,
35.     App\Entity\Trait\TranslatableTrait,
36.     App\Entity\Trait\Languages\JournalLanguagesTrait,
37.     App\Entity\Trait\ArchivedTrait,
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. use App\Controller\Stats\StatsJournalXlsxGenerator;
68. use App\Filter\DateUnmapped;
69. use App\Filter\OrderByUnmapped;
70. use App\Filter\RangeUnmapped;
71. use App\StateProvider\StatsJournalProvider;
72. use App\StateProvider\StatsSystemProvider;
74. #[ApiResource(
75.     description: 'Journals',
76.     normalizationContext: ['groups' => [
77.         'read',
78.         'read:' . self::class,
79.         'read:' . self::class . 'Translation'
80.     ]],
81.     denormalizationContext: ['groups' => ['write']],
82.     security: 'is_granted("' . self::class . '")',
83.     order: ['ord' => 'desc'],
84.     operations: [
85.         new GetCollection(),
86.         new GetCollection(
87.             uriTemplate: '/journals/list',
88.             normalizationContext: ['groups' => ['read', 'read:list']],
89.         ),
90.         new GetCollection(
91.             name: 'get_journal_stats_system',
92.             uriTemplate: '/journals/stats/system',
93.             provider: StatsSystemProvider::class,
94.             security: 'is_granted("ROLE_MODULE_STATS")',
95.             normalizationContext: ['groups' => ['read:stats']],
96.         ),
97.         new GetCollection(
98.             name: 'get_journal_stats',
99.             uriTemplate: '/journals/stats',
100.             provider: StatsJournalProvider::class,
101.             security: 'is_granted("ROLE_MODULE_STATS")',
102.             normalizationContext: ['groups' => ['read:stats']],
103.             paginationMaximumItemsPerPage: 500
104.         ),
105.         new GetCollection(
106.             name: 'get_journal_stats_xlsx',
107.             uriTemplate: '/journals/stats/xlsx',
108.             provider: StatsJournalProvider::class,
109.             controller: StatsJournalXlsxGenerator::class,
110.             security: 'is_granted("ROLE_MODULE_STATS")',
111.         ),
112.         new Post(
113.             uriTemplate: '/journals/clone',
114.             input: CloneDTO::class,
115.             processor: CloneProcessor::class,
116.             security: 'is_granted("' . Actions::CLONE . '")',
117.             securityMessage: CloneVoter::MESSAGE
118.         ),
119.         new Post(),
120.         new Get(),
121.         new Get(
122.             name: 'get_journal_crossref',
123.             uriTemplate: '/journals/{uuid}/export/crossref',
124.             controller: JournalCrossrefExporter::class
125.         ),
126.         new Get(
127.             name: 'get_journal_simcheck_crossref',
128.             uriTemplate: '/journals/{uuid}/export/simcheck_crossref',
129.             controller: JournalSimcheckCrossrefExporter::class
130.         ),
131.         new Get(
132.             name: 'get_journal_licence_fulltext_crossref',
133.             uriTemplate: '/journals/{uuid}/export/licence_fulltext_crossref',
134.             controller: JournalLicenceFulltextCrossrefExporter::class
135.         ),
136.         new Put(),
137.         new Delete(
138.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
139.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
140.         ),
141.     ],
142.     extraProperties: ['standard_put' => false],
143. )]
144. #[ApiFilter(SearchFilter::class, properties: [
145.     'translations.title' => 'partial',
146.     'nativeTitle' => 'partial',
147.     'data.workingTitle' => 'partial',
148.     'data.issn' => 'exact',
149.     'data.eIssn' => 'exact',
150.     'data.state' => 'exact',
151.     'data.type' => 'exact',
152.     'domains.domain.nativeTitle' => 'partial',
153.     'affiliations.affiliation.nativeTitle' => 'partial',
154.     'affiliations.affiliation.type.title' => 'partial'
155. ])]
156. #[ApiFilter(RangeFilter::class, properties: ['meinScore'])]
157. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
158. #[ApiFilter(IriFilter::class, properties: [
159.     'nativeLanguage',
160.     'domains.domain',
161.     'affiliations.affiliation',
162.     'data.periodicity',
163.     'data.type',
164.     'data.licence',
165.     'data.state'
166. ])]
167. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
168. #[ApiFilter(OrderFilter::class, properties: [
169.     'nativeTitle',
170.     'nativeLanguage',
171.     'data.type',
172.     'data.state',
173.     'affiliations.affiliation.nativeTitle',
174.     'affiliations.affiliation.type.title',
175.     'domains.domain.nativeTitle',
176.     'data.workingTitle',
177.     'data.periodicity',
178.     'updatedAt',
179.     'stat',
180.     'ord'
181. ])]
182. #[ApiFilter(OrderByUnmapped::class, properties: [
183.     'statsEarliestArticlePublicationDate',
184.     'statsLatestArticlePublicationDate',
185.     'statsAmountOfArticles',
186.     'statsAmountOfArticles',
187.     'statsAmountOfIssues',
188.     'statsAmountOfVolumes',
189.     'statsAmountOfViews',
190.     'statsAmountOfDownloads'
191. ])]
192. #[ApiFilter(RangeUnmapped::class, properties: [
193.     'statsAmountOfVolumes',
194.     'statsAmountOfIssues',
195.     'statsAmountOfArticles',
196.     'statsAmountOfViews',
197.     'statsAmountOfDownloads'
198. ])]
199. #[ApiFilter(DateUnmapped::class, properties: ['statsEarliestArticlePublicationDate','statsLatestArticlePublicationDate'])]
200. #[Index(fields: ["nativeLanguage"], name: "native_language_idx")]
201. #[Index(fields: ["stat"], name: "stat_idx")]
202. #[ORM\Entity(repositoryClass: JournalRepository::class)]
203. class Journal implements
204.     TranslatableInterface,
205.     OrdStatableInterface,
206.     LanguageableInterface,
207.     EditorialGroupableInterface,
208.     ArchivableInterface,
209.     OwnerableInterface,
210.     CloneableInterface
211. {
212.     use IdTrait,
213.         UuidTrait,
214.         OrdStatTrait,
215.         TimestampableTrait,
216.         TranslatableTrait,
217.         JournalLanguagesTrait,
218.         ArchivedTrait,
219.         EditorialGroupableTrait,
220.         ImportIdTrait;
222.     #[ApiProperty(description: 'Native title sort key')]
223.     #[Groups(['read:' . self::class, 'read:stats'])]
224.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
225.     private ?string $nativeTitleSortKey = null;
227.     #[ApiProperty(description: 'Data subresource', writable: true)]
228.     #[Groups(['read:' . self::class, 'read:list', 'write'])]
229.     #[Assert\Valid]
230.     #[DenormalizationInject(method: ['name' => 'getData'])]
231.     #[ORM\OneToOne(targetEntity: JournalData::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
232.     private JournalData $data;
234.     #[ApiProperty(description: 'View subresource', writable: true)]
235.     #[Groups(['read:' . self::class, 'write'])]
236.     #[Assert\Valid]
237.     #[DenormalizationInject(method: ['name' => 'getView'])]
238.     #[ORM\OneToOne(targetEntity: JournalView::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
239.     private JournalView $view;
241.     #[ApiProperty(description: 'Newest new issue', writable: true)]
242.     #[ORM\OneToOne(targetEntity: JournalIssue::class)]
243.     #[ORM\JoinColumn(onDelete: 'set null', nullable: true)]
244.     private ?JournalIssue $newestNewIssue = null;
246.     #[ApiProperty(description: 'Slug')]
247.     #[Groups(['read:' . self::class, 'write'])]
248.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitle'])]
249.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
250.     private ?string $slug = null;
252.     #[ApiProperty(description: 'Slug')]
253.     #[Groups(['read:' . self::class, 'write'])]
254.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
255.     private ?string $importSlug = null;
257.     #[ApiProperty(description: 'Slug')]
258.     #[Groups(['read:' . self::class, 'write'])]
259.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
260.     private ?string $importSlugEn = null;
262.     #[ApiProperty(description: 'Created by')]
263.     #[Groups(['read:' . self::class])]
264.     #[ORM\ManyToOne(targetEntity: Admin::class, inversedBy: 'journals')]
265.     #[ORM\JoinColumn(onDelete: 'set null')]
266.     private Admin $createdBy;
268.     #[ApiProperty(description: 'Updated by')]
269.     #[Groups(['read:' . self::class])]
270.     #[ORM\ManyToOne(targetEntity: Admin::class)]
271.     #[ORM\JoinColumn(onDelete: 'set null')]
272.     private Admin $updatedBy;
274.     #[ApiProperty(description: 'Scientific council members', writableLink: false)]
275.     #[ORM\OneToMany(targetEntity: JournalScientificCouncilMember::class, mappedBy: 'parent', cascade: ['persist'])]
276.     #[ORM\OrderBy(['ord' => 'desc'])]
277.     private Collection $scientificCouncilMembers;
279.     #[ApiProperty(description: 'Domains', fetchEager: false)]
280.     #[Groups(['read', 'read:list'])]
281.     #[ORM\OneToMany(targetEntity: JournalDomain::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
282.     #[ORM\OrderBy(['ord' => 'desc'])]
283.     private Collection $domains;
285.     #[ApiProperty(description: 'Indexation collections')]
286.     #[ORM\OneToMany(targetEntity: JournalIndexationCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
287.     #[ORM\OrderBy(['ord' => 'desc'])]
288.     private Collection $indexationCollections;
290.     #[ApiProperty(description: 'Indicators')]
291.     #[ORM\OneToMany(targetEntity: JournalIndicator::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
292.     #[ORM\OrderBy(['ord' => 'desc'])]
293.     private Collection $indicators;
295.     #[ApiProperty(description: 'Affiliations', fetchEager: false)]
296.     #[Groups(['read', 'read:list'])]
297.     #[ORM\OneToMany(targetEntity: JournalAffiliation::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
298.     #[ORM\OrderBy(['ord' => 'desc'])]
299.     private Collection $affiliations;
301.     #[ApiProperty(description: 'Publishers')]
302.     #[ORM\OneToMany(targetEntity: JournalPublisher::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
303.     #[ORM\OrderBy(['ord' => 'desc'])]
304.     private Collection $publishers;
306.     #[ApiProperty(description: 'Partners')]
307.     #[ORM\OneToMany(targetEntity: JournalPartner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
308.     #[ORM\OrderBy(['ord' => 'desc'])]
309.     private Collection $partners;
311.     #[ApiProperty(description: 'Slides')]
312.     #[ORM\OneToMany(targetEntity: JournalSlide::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
313.     #[ORM\OrderBy(['ord' => 'desc'])]
314.     private Collection $slides;
316.     #[ApiProperty(description: 'Sections')]
317.     #[ORM\OneToMany(targetEntity: JournalSection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
318.     #[ORM\OrderBy(['ord' => 'desc'])]
319.     private Collection $sections;
321.     #[ApiProperty(description: 'Menu items')]
322.     #[ORM\OneToMany(targetEntity: JournalMenuItem::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
323.     #[ORM\OrderBy(['ord' => 'desc'])]
324.     private Collection $menuItems;
326.     #[ApiProperty(description: 'Submenu groups')]
327.     #[ORM\OneToMany(targetEntity: JournalSubmenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
328.     #[ORM\OrderBy(['ord' => 'desc'])]
329.     private Collection $submenuGroups;
331.     #[ApiProperty(description: 'Sidemenu groups')]
332.     #[ORM\OneToMany(targetEntity: JournalSidemenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
333.     #[ORM\OrderBy(['ord' => 'desc'])]
334.     private Collection $sidemenuGroups;
336.     #[ApiProperty(description: 'Banners')]
337.     #[ORM\OneToMany(targetEntity: JournalBanner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
338.     #[ORM\OrderBy(['ord' => 'desc'])]
339.     private Collection $banners;
341.     #[ApiProperty(description: 'Volumes')]
342.     #[ORM\OneToMany(targetEntity: JournalVolume::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
343.     #[ORM\OrderBy(['ord' => 'desc'])]
344.     private Collection $volumes;
346.     #[ApiProperty(description: 'Issues')]
347.     #[ORM\OneToMany(targetEntity: JournalIssue::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
348.     #[ORM\OrderBy(['ord' => 'desc'])]
349.     private Collection $issues;
351.     #[ApiProperty(description: 'Articles')]
352.     #[ORM\OneToMany(targetEntity: JournalArticle::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
353.     #[ORM\OrderBy(['ord' => 'desc'])]
354.     private Collection $articles;
356.     #[ApiProperty(description: 'Pages')]
357.     #[ORM\OneToMany(targetEntity: JournalPage::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
358.     #[ORM\OrderBy(['ord' => 'desc'])]
359.     private Collection $pages;
361.     #[ApiProperty(description: 'News')]
362.     #[ORM\OneToMany(targetEntity: JournalNews::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
363.     #[ORM\OrderBy(['ord' => 'desc'])]
364.     private Collection $news;
366.     #[ApiProperty(description: 'Collections')]
367.     #[ORM\OneToMany(targetEntity: JournalCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
368.     #[ORM\OrderBy(['ord' => 'desc'])]
369.     private Collection $collections;
371.     #[ApiProperty(description: 'Sort article by ord')]
372.     #[Groups(['read:' . self::class, 'write'])]
373.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
374.     private bool $sortArticlesByOrd = false;
376.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalFooter::class, orphanRemoval: true)]
377.     private Collection $smallFooters;
379.     #[ApiProperty(description: 'Statistics: earliest article publication date')]
380.     #[Groups(['read:stats'])]
381.     private ?\DateTimeImmutable $statsEarliestArticlePublicationDate = null;
383.     #[ApiProperty(description: 'Statistics: latest article publication date')]
384.     #[Groups(['read:stats'])]
385.     private ?\DateTimeImmutable $statsLatestArticlePublicationDate = null;
387.     #[ApiProperty(description: 'Statistics: amount of views')]
388.     #[Groups(['read:stats'])]
389.     private int $statsAmountOfArticles = 0;
391.     #[ApiProperty(description: 'Statistics: amount of views')]
392.     #[Groups(['read:stats'])]
393.     private int $statsAmountOfIssues = 0;
395.     #[ApiProperty(description: 'Statistics: amount of views')]
396.     #[Groups(['read:stats'])]
397.     private int $statsAmountOfVolumes = 0;
399.     #[ApiProperty(description: 'Statistics: amount of views')]
400.     #[Groups(['read:stats'])]
401.     private int $statsAmountOfViews = 0;
403.     #[ApiProperty(description: 'Statistics: amount of downloads')]
404.     #[Groups(['read:stats'])]
405.     private int $statsAmountOfDownloads = 0;
407.     public function __construct(Admin $createdBy, ?array $languages)
408.     {
409.         $this->setUuid();
411.         $this->data = new JournalData($this);
412.         $this->view = new JournalView($this);
414.         $this->createdBy = $createdBy;
415.         $this->updatedBy = $createdBy;
417.         $this->translations = new ArrayCollection();
419.         $this->domains = new ArrayCollection();
420.         $this->indexationCollections = new ArrayCollection();
421.         $this->indicators = new ArrayCollection();
423.         $this->affiliations = new ArrayCollection();
424.         $this->publishers = new ArrayCollection();
425.         $this->partners = new ArrayCollection();
427.         $this->slides = new ArrayCollection();
428.         $this->editorialGroups = new ArrayCollection();
429.         $this->scientificCouncilMembers = new ArrayCollection();
430.         $this->sections = new ArrayCollection();
432.         $this->menuItems = new ArrayCollection();
433.         $this->submenuGroups = new ArrayCollection();
434.         $this->sidemenuGroups = new ArrayCollection();
435.         $this->banners = new ArrayCollection();
437.         $this->volumes = new ArrayCollection();
438.         $this->issues = new ArrayCollection();
439.         $this->articles = new ArrayCollection();
441.         $this->pages = new ArrayCollection();
442.         $this->news = new ArrayCollection();
444.         $this->collections = new ArrayCollection();
446.         $this->setLanguages($languages ?? Language::DEFAULT_JOURNAL);
448.         foreach (array_reverse(JournalDefaultPage::cases()) as $index => $idName) {
449.             new JournalPage(
450.                 parent: $this,
451.                 workingTitle: $idName->value,
452.                 idName: $idName->value,
453.                 ord: $index + 1,
454.                 stat: true
455.             );
456.         }
458.         $this->createdAt = new \DateTimeImmutable();
459.         $this->updatedAt = new \DateTimeImmutable();
460.         $this->smallFooters = new ArrayCollection();
461.     }
463.     public function getTitle(): string
464.     {
465.         return $this->data->getWorkingTitle();
466.     }
468.     public function setNativeTitleSortKey(string $nativeTitleSortKey): self
469.     {
470.         $this->nativeTitleSortKey = $nativeTitleSortKey;
472.         return $this;
473.     }
475.     public function getNativeTitleSortKey(): ?string
476.     {
477.         return $this->nativeTitleSortKey;
478.     }
480.     public function getData(): JournalData
481.     {
482.         return $this->data;
483.     }
485.     public function getView(): JournalView
486.     {
487.         return $this->view;
488.     }
490.     public function getCover(Language $lang): ?Media
491.     {
492.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
493.             return $this->readAvailableTranslation($lang, 'cover');
494.         }
496.         if ($cover = $this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
497.             return $cover;
498.         }
500.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
501.             ? $this->readAvailableTranslation($lang, 'cover')
502.             : null;
503.     }
505.     public function getCoverAlt(Language $lang): ?string
506.     {
507.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
508.             return $this->readAvailableTranslation($lang, 'coverAlt');
509.         }
511.         if ($this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
512.             return $this->getNewestIssue()?->readAvailableTranslation($lang, 'coverAlt');
513.         }
515.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
516.             ? $this->readAvailableTranslation($lang, 'coverAlt')
517.             : null;
518.     }
520.     public function getNewestNewIssue(): ?JournalIssue
521.     {
522.         return $this->newestNewIssue;
523.     }
525.     public function setNewestNewIssue(?JournalIssue $newestNewIssue): self
526.     {
527.         $this->newestNewIssue = $newestNewIssue;
529.         return $this;
530.     }
532.     public function getNewestIssue(): ?JournalIssue
533.     {
534.         foreach ($this->getIssues() as $issue) {
535.             if ($issue->getStat() && $issue->getIsNewestIssue()) {
536.                 return $issue;
537.             }
538.         }
540.         return null;
541.     }
543.     public function getSlug(): ?string
544.     {
545.         return $this->slug;
546.     }
548.     public function setSlug(?string $slug): self
549.     {
550.         $this->slug = $slug;
552.         return $this;
553.     }
555.     public function getImportSlug(): ?string
556.     {
557.         return $this->importSlug;
558.     }
560.     public function setImportSlug(?string $importSlug): self
561.     {
562.         $this->importSlug = $importSlug;
564.         return $this;
565.     }
567.     public function getImportSlugEn(): ?string
568.     {
569.         return $this->importSlugEn;
570.     }
572.     public function setImportSlugEn(?string $importSlugEn): self
573.     {
574.         $this->importSlugEn = $importSlugEn;
576.         return $this;
577.     }
579.     public function getCreatedBy(): Admin
580.     {
581.         return $this->createdBy;
582.     }
584.     public function getUpdatedBy(): Admin
585.     {
586.         return $this->updatedBy;
587.     }
589.     public function setUpdatedBy(Admin $updatedBy): self
590.     {
591.         $this->updatedBy = $updatedBy;
593.         return $this;
594.     }
596.     /**
597.      * @return Collection|JournalScientificCouncilMember[]
598.      */
599.     public function getScientificCouncilMembers(): Collection
600.     {
601.         return $this->scientificCouncilMembers;
602.     }
604.     public function addScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
605.     {
606.         if ($this->scientificCouncilMembers->contains($scientificCouncilMember)) {
607.             return $this;
608.         }
610.         $this->scientificCouncilMembers[] = $scientificCouncilMember;
612.         return $this;
613.     }
615.     public function removeScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
616.     {
617.         $this->scientificCouncilMembers->removeElement($scientificCouncilMember);
619.         return $this;
620.     }
622.     public function resetScientificCouncilMembers(): self
623.     {
624.         $this->scientificCouncilMembers = new ArrayCollection();
626.         return $this;
627.     }
629.     /**
630.      * @return Collection|JournalDomain[]
631.      */
632.     public function getDomains(): Collection
633.     {
634.         return $this->domains;
635.     }
637.     public function addDomain(JournalDomain $domain): self
638.     {
639.         if ($this->domains->contains($domain)) {
640.             return $this;
641.         }
643.         $this->domains[] = $domain;
645.         return $this;
646.     }
648.     public function removeDomain(JournalDomain $domain): self
649.     {
650.         $this->domains->removeElement($domain);
652.         return $this;
653.     }
655.     public function resetDomains(): self
656.     {
657.         $this->domains = new ArrayCollection();
659.         return $this;
660.     }
662.     /**
663.      * @return Collection|JournalIndexationCollection[]
664.      */
665.     public function getIndexationCollections(): Collection
666.     {
667.         return $this->indexationCollections;
668.     }
670.     public function addIndexationCollection(JournalIndexationCollection $indexationCollection): self
671.     {
672.         if ($this->indexationCollections->contains($indexationCollection)) {
673.             return $this;
674.         }
676.         $this->indexationCollections[] = $indexationCollection;
678.         return $this;
679.     }
681.     public function removeIndexationCollection(JournalIndexationCollection $indexationCollection): self
682.     {
683.         $this->indexationCollections->removeElement($indexationCollection);
685.         return $this;
686.     }
688.     public function resetIndexationCollections(): self
689.     {
690.         $this->indexationCollections = new ArrayCollection();
692.         return $this;
693.     }
695.     /**
696.      * @return Collection|JournalIndicator[]
697.      */
698.     public function getIndicators(): Collection
699.     {
700.         return $this->indicators;
701.     }
703.     public function addIndicator(JournalIndicator $indicator): self
704.     {
705.         if ($this->indicators->contains($indicator)) {
706.             return $this;
707.         }
709.         $this->indicators[] = $indicator;
711.         return $this;
712.     }
714.     public function removeIndicator(JournalIndicator $indicator): self
715.     {
716.         $this->indicators->removeElement($indicator);
718.         return $this;
719.     }
721.     public function resetIndicators(): self
722.     {
723.         $this->indicators = new ArrayCollection();
725.         return $this;
726.     }
728.     /**
729.      * @return Collection|JournalAffiliation[]
730.      */
731.     public function getAffiliations(): Collection
732.     {
733.         return $this->affiliations;
734.     }
736.     public function addAffiliation(JournalAffiliation $affiliation): self
737.     {
738.         if ($this->affiliations->contains($affiliation)) {
739.             return $this;
740.         }
742.         $this->affiliations[] = $affiliation;
744.         return $this;
745.     }
747.     public function removeAffiliation(JournalAffiliation $affiliation): self
748.     {
749.         $this->affiliations->removeElement($affiliation);
751.         return $this;
752.     }
754.     public function resetAffiliations(): self
755.     {
756.         $this->affiliations = new ArrayCollection();
758.         return $this;
759.     }
761.     /**
762.      * @return Collection|JournalPublisher[]
763.      */
764.     public function getPublishers(): Collection
765.     {
766.         return $this->publishers;
767.     }
769.     public function addPublisher(JournalPublisher $publisher): self
770.     {
771.         if ($this->publishers->contains($publisher)) {
772.             return $this;
773.         }
775.         $this->publishers[] = $publisher;
777.         return $this;
778.     }
780.     public function removePublisher(JournalPublisher $publisher): self
781.     {
782.         $this->publishers->removeElement($publisher);
784.         return $this;
785.     }
787.     public function resetPublishers(): self
788.     {
789.         $this->publishers = new ArrayCollection();
791.         return $this;
792.     }
794.     public function getVisiblePublishers(): Collection
795.     {
796.         return $this->publishers->filter(
797.             fn (JournalPublisher $publisher) =>
798.             $publisher->getStat() === true &&
799.                 $publisher->getPublisher()->getStat() === true
800.         );
801.     }
803.     /**
804.      * @return Collection|JournalPartner[]
805.      */
806.     public function getPartners(): Collection
807.     {
808.         return $this->partners;
809.     }
811.     public function addPartner(JournalPartner $partner): self
812.     {
813.         if ($this->partners->contains($partner)) {
814.             return $this;
815.         }
817.         $this->partners[] = $partner;
819.         return $this;
820.     }
822.     public function removePartner(JournalPartner $partner): self
823.     {
824.         $this->partners->removeElement($partner);
826.         return $this;
827.     }
829.     public function resetPartners(): self
830.     {
831.         $this->partners = new ArrayCollection();
833.         return $this;
834.     }
836.     /**
837.      * @return Collection|JournalSlide[]
838.      */
839.     public function getSlides(): Collection
840.     {
841.         return $this->slides;
842.     }
844.     public function addSlide(JournalSlide $slide): self
845.     {
846.         if ($this->slides->contains($slide)) {
847.             return $this;
848.         }
850.         $this->slides[] = $slide;
852.         return $this;
853.     }
855.     public function removeSlide(JournalSlide $slide): self
856.     {
857.         $this->slides->removeElement($slide);
859.         return $this;
860.     }
862.     public function resetSlides(): self
863.     {
864.         $this->slides = new ArrayCollection();
866.         return $this;
867.     }
869.     /**
870.      * @return Collection|JournalSection[]
871.      */
872.     public function getSections(): Collection
873.     {
874.         return $this->sections;
875.     }
877.     public function addSection(JournalSection $section): self
878.     {
879.         if ($this->sections->contains($section)) {
880.             return $this;
881.         }
883.         $this->sections[] = $section;
885.         return $this;
886.     }
888.     public function removeSection(JournalSection $section): self
889.     {
890.         $this->sections->removeElement($section);
892.         return $this;
893.     }
895.     public function resetSections(): self
896.     {
897.         $this->sections = new ArrayCollection();
899.         return $this;
900.     }
902.     /**
903.      * @return Collection|JournalMenuItem[]
904.      */
905.     public function getMenuItems(): Collection
906.     {
907.         return $this->menuItems;
908.     }
910.     public function addMenuItem(JournalMenuItem $menuItem): self
911.     {
912.         if ($this->menuItems->contains($menuItem)) {
913.             return $this;
914.         }
916.         $this->menuItems[] = $menuItem;
918.         return $this;
919.     }
921.     public function removeMenuItem(JournalMenuItem $menuItem): self
922.     {
923.         $this->menuItems->removeElement($menuItem);
925.         return $this;
926.     }
928.     public function resetMenuItems(): self
929.     {
930.         $this->menuItems = new ArrayCollection();
932.         return $this;
933.     }
935.     /**
936.      * @return Collection|JournalSubmenuGroup[]
937.      */
938.     public function getSubmenuGroups(): Collection
939.     {
940.         return $this->submenuGroups;
941.     }
943.     public function addSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
944.     {
945.         if ($this->submenuGroups->contains($submenuGroup)) {
946.             return $this;
947.         }
949.         $this->submenuGroups[] = $submenuGroup;
951.         return $this;
952.     }
954.     public function removeSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
955.     {
956.         $this->submenuGroups->removeElement($submenuGroup);
958.         return $this;
959.     }
961.     public function resetSubmenuGroups(): self
962.     {
963.         $this->submenuGroups = new ArrayCollection();
965.         return $this;
966.     }
968.     /**
969.      * @return Collection|JournalSidemenuGroup[]
970.      */
971.     public function getSidemenuGroups(): Collection
972.     {
973.         return $this->sidemenuGroups;
974.     }
976.     public function addSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
977.     {
978.         if ($this->sidemenuGroups->contains($sidemenuGroup)) {
979.             return $this;
980.         }
982.         $this->sidemenuGroups[] = $sidemenuGroup;
984.         return $this;
985.     }
987.     public function removeSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
988.     {
989.         $this->sidemenuGroups->removeElement($sidemenuGroup);
991.         return $this;
992.     }
994.     public function resetSidemenuGroups(): self
995.     {
996.         $this->sidemenuGroups = new ArrayCollection();
998.         return $this;
999.     }
1001.     /**
1002.      * @return Collection|JournalBanner[]
1003.      */
1004.     public function getBanners(): Collection
1005.     {
1006.         return $this->banners;
1007.     }
1009.     public function addBanner(JournalBanner $banner): self
1010.     {
1011.         if ($this->banners->contains($banner)) {
1012.             return $this;
1013.         }
1015.         $this->banners[] = $banner;
1017.         return $this;
1018.     }
1020.     public function removeBanner(JournalBanner $banner): self
1021.     {
1022.         $this->banners->removeElement($banner);
1024.         return $this;
1025.     }
1027.     public function resetBanners(): self
1028.     {
1029.         $this->banners = new ArrayCollection();
1031.         return $this;
1032.     }
1034.     /**
1035.      * @return Collection|JournalVolume[]
1036.      */
1037.     public function getVolumes(): Collection
1038.     {
1039.         return $this->volumes;
1040.     }
1042.     public function addVolume(JournalVolume $volume): self
1043.     {
1044.         if ($this->volumes->contains($volume)) {
1045.             return $this;
1046.         }
1048.         $this->volumes[] = $volume;
1050.         return $this;
1051.     }
1053.     public function removeVolume(JournalVolume $volume): self
1054.     {
1055.         $this->volumes->removeElement($volume);
1057.         return $this;
1058.     }
1060.     public function resetVolumes(): self
1061.     {
1062.         $this->volumes = new ArrayCollection();
1064.         return $this;
1065.     }
1067.     /**
1068.      * @return Collection<int, JournalIssue>
1069.      */
1070.     public function getIssues(): Collection
1071.     {
1072.         return $this->issues;
1073.     }
1075.     /**
1076.      * @return Collection<int, JournalIssue>
1077.      */
1078.     public function getVisibleIssues(): Collection
1079.     {
1080.         return $this->issues->filter(fn (JournalIssue $issue) => $issue->getStat());
1081.     }
1083.     public function addIssue(JournalIssue $issue): self
1084.     {
1085.         if ($this->issues->contains($issue)) {
1086.             return $this;
1087.         }
1089.         $this->issues[] = $issue;
1091.         return $this;
1092.     }
1094.     public function removeIssue(JournalIssue $issue): self
1095.     {
1096.         $this->issues->removeElement($issue);
1098.         return $this;
1099.     }
1101.     public function resetIssues(): self
1102.     {
1103.         $this->issues = new ArrayCollection();
1105.         return $this;
1106.     }
1108.     public function getOldestIssue(): ?JournalIssue
1109.     {
1110.         $filtered = new ArrayCollection();
1112.         foreach ($this->getIssues() as $issue) {
1113.             if ($issue->getStat() && $issue->getPublishedAt()) {
1114.                 $filtered->add($issue);
1115.             }
1116.         }
1118.         if (count($filtered) === 0) {
1119.             return null;
1120.         }
1122.         $criteria = Criteria::create()->orderBy(['publishedAt' => Criteria::ASC]);
1124.         return $filtered
1125.             ->matching($criteria)
1126.             ->first();
1127.     }
1129.     /**
1130.      * @return Collection|JournalArticle[]
1131.      */
1132.     public function getArticles(): Collection
1133.     {
1134.         return $this->articles;
1135.     }
1137.     /**
1138.      * @return Collection<int, JournalArticle>
1139.      */
1140.     public function getArticlesVisible(): Collection
1141.     {
1142.         return $this->articles->filter(fn (JournalArticle $article) => $article->getStat());
1143.     }
1145.     public function addArticle(JournalArticle $article): self
1146.     {
1147.         if ($this->articles->contains($article)) {
1148.             return $this;
1149.         }
1151.         $this->articles[] = $article;
1153.         return $this;
1154.     }
1156.     public function removeArticle(JournalArticle $article): self
1157.     {
1158.         $this->articles->removeElement($article);
1160.         return $this;
1161.     }
1163.     public function resetArticles(): self
1164.     {
1165.         $this->articles = new ArrayCollection();
1167.         return $this;
1168.     }
1170.     /**
1171.      * @return Collection|JournalPage[]
1172.      */
1173.     public function getPages(): Collection
1174.     {
1175.         return $this->pages;
1176.     }
1178.     public function addPage(JournalPage $page): self
1179.     {
1180.         if ($this->pages->contains($page)) {
1181.             return $this;
1182.         }
1184.         $this->pages[] = $page;
1186.         return $this;
1187.     }
1189.     public function removePage(JournalPage $page): self
1190.     {
1191.         $this->pages->removeElement($page);
1193.         return $this;
1194.     }
1196.     public function resetPages(): self
1197.     {
1198.         $this->pages = new ArrayCollection();
1200.         return $this;
1201.     }
1203.     /**
1204.      * @return Collection|JournalNews[]
1205.      */
1206.     public function getNews(): Collection
1207.     {
1208.         return $this->news;
1209.     }
1211.     public function addNews(JournalNews $news): self
1212.     {
1213.         if ($this->news->contains($news)) {
1214.             return $this;
1215.         }
1217.         $this->news[] = $news;
1219.         return $this;
1220.     }
1222.     public function removeNews(JournalNews $news): self
1223.     {
1224.         $this->news->removeElement($news);
1226.         return $this;
1227.     }
1229.     public function resetNews(): self
1230.     {
1231.         $this->news = new ArrayCollection();
1233.         return $this;
1234.     }
1236.     /**
1237.      * @return Collection|JournalCollection[]
1238.      */
1239.     public function getCollections(): Collection
1240.     {
1241.         return $this->collections;
1242.     }
1244.     public function addCollection(JournalCollection $collection): self
1245.     {
1246.         if ($this->collections->contains($collection)) {
1247.             return $this;
1248.         }
1250.         $this->collections[] = $collection;
1252.         return $this;
1253.     }
1255.     public function removeCollection(JournalCollection $news): self
1256.     {
1257.         $this->news->removeElement($news);
1259.         return $this;
1260.     }
1262.     public function resetCollections(): self
1263.     {
1264.         $this->collections = new ArrayCollection();
1266.         return $this;
1267.     }
1269.     public function clone(Admin $createdBy = null): self
1270.     {
1271.         $clone = clone $this;
1273.         $clone->id = null;
1274.         $clone->setUuid();
1276.         $clone->ord = 0;
1277.         $clone->stat = false;
1278.         $clone->importId = null;
1280.         $clone->data = $this->data->clone($clone);
1281.         $clone->view = $this->view->clone($clone);
1283.         $nativeLanguage = $clone->getNativeLanguage();
1284.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
1285.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
1287.         ClassUtils::cloneCollection($this, $clone, 'translations');
1289.         $clone
1290.             ->resetDomains()
1291.             ->resetIndexationCollections()
1292.             ->resetIndicators()
1293.             ->resetAffiliations()
1294.             ->resetPublishers()
1295.             ->resetPartners()
1296.             ->resetSlides()
1297.             ->resetSections()
1298.             ->resetMenuItems()
1299.             ->resetSubmenuGroups()
1300.             ->resetBanners()
1301.             ->resetVolumes()
1302.             ->resetIssues()
1303.             ->resetArticles()
1304.             ->resetPages()
1305.             ->resetNews()
1306.             ->resetCollections()
1307.             ->resetEditorialGroups()
1308.             ->resetScientificCouncilMembers();
1310.         $clone->createdBy = $createdBy ?? $clone->createdBy;
1311.         $clone->updatedBy = $createdBy ?? $clone->updatedBy;
1313.         $clone->createdAt = new \DateTimeImmutable();
1314.         $clone->updatedAt = new \DateTimeImmutable();
1316.         return $clone;
1317.     }
1319.     public function isSortArticlesByOrd(): bool
1320.     {
1321.         return $this->sortArticlesByOrd;
1322.     }
1324.     public function setSortArticlesByOrd(bool $sortArticlesByOrd): self
1325.     {
1326.         $this->sortArticlesByOrd = $sortArticlesByOrd;
1328.         return $this;
1329.     }
1331.     /**
1332.      * @return Collection<int, JournalFooter>
1333.      */
1334.     public function getSmallFooters(): Collection
1335.     {
1336.         return $this->smallFooters;
1337.     }
1339.     public function addSmallFooter(JournalFooter $smallFooter): self
1340.     {
1341.         if (!$this->smallFooters->contains($smallFooter)) {
1342.             $this->smallFooters->add($smallFooter);
1343.             $smallFooter->setParent($this);
1344.         }
1346.         return $this;
1347.     }
1349.     public function removeSmallFooter(JournalFooter $smallFooter): self
1350.     {
1351.         if ($this->smallFooters->removeElement($smallFooter)) {
1352.             // set the owning side to null (unless already changed)
1353.             if ($smallFooter->getParent() === $this) {
1354.                 $smallFooter->setParent(null);
1355.             }
1356.         }
1358.         return $this;
1359.     }
1361.     public function getVisibleSmallFooters(): Collection
1362.     {
1363.         return $this->smallFooters->filter(fn (JournalFooter $smallFooter) => $smallFooter->getStat());
1364.     }
1366.     public function getStatsAmountOfArticles(): int
1367.     {
1368.         return $this->statsAmountOfArticles;
1369.     }
1371.     public function setStatsAmountOfArticles(int $statsAmountOfArticles): self
1372.     {
1373.         $this->statsAmountOfArticles = $statsAmountOfArticles;
1375.         return $this;
1376.     }
1378.     public function getStatsAmountOfIssues(): int
1379.     {
1380.         return $this->statsAmountOfIssues;
1381.     }
1383.     public function setStatsAmountOfIssues(int $statsAmountOfIssues): self
1384.     {
1385.         $this->statsAmountOfIssues = $statsAmountOfIssues;
1387.         return $this;
1388.     }
1390.     public function getStatsAmountOfVolumes(): int
1391.     {
1392.         return $this->statsAmountOfVolumes;
1393.     }
1395.     public function setStatsAmountOfVolumes(int $statsAmountOfVolumes): self
1396.     {
1397.         $this->statsAmountOfVolumes = $statsAmountOfVolumes;
1399.         return $this;
1400.     }
1402.     public function getStatsAmountOfViews(): int
1403.     {
1404.         return $this->statsAmountOfViews;
1405.     }
1407.     public function setStatsAmountOfViews(int $statsAmountOfViews): self
1408.     {
1409.         $this->statsAmountOfViews = $statsAmountOfViews;
1411.         return $this;
1412.     }
1414.     public function getStatsAmountOfDownloads(): int
1415.     {
1416.         return $this->statsAmountOfDownloads;
1417.     }
1419.     public function setStatsAmountOfDownloads(int $statsAmountOfDownloads): self
1420.     {
1421.         $this->statsAmountOfDownloads = $statsAmountOfDownloads;
1423.         return $this;
1424.     }
1426.     public function getStatsEarliestArticlePublicationDate(): ?\DateTimeImmutable
1427.     {
1428.         return $this->statsEarliestArticlePublicationDate;
1429.     }
1431.     public function setStatsEarliestArticlePublicationDate(?string $statsEarliestArticlePublicationDate): self
1432.     {
1433.         if (!$statsEarliestArticlePublicationDate) {
1434.             return $this;
1435.         }
1437.         $this->statsEarliestArticlePublicationDate = new \DateTimeImmutable($statsEarliestArticlePublicationDate);
1439.         return $this;
1440.     }
1442.     public function getStatsLatestArticlePublicationDate(): ?\DateTimeImmutable
1443.     {
1444.         return $this->statsLatestArticlePublicationDate;
1445.     }
1447.     public function setStatsLatestArticlePublicationDate(?string $statsLatestArticlePublicationDate): self
1448.     {
1449.         if (!$statsLatestArticlePublicationDate) {
1450.             return $this;
1451.         }
1453.         $this->statsLatestArticlePublicationDate = new \DateTimeImmutable($statsLatestArticlePublicationDate);
1455.         return $this;
1456.     }
1458.     #[Groups(['read:stats'])]
1459.     public function getStatsAffiliations(): ?string
1460.     {
1461.         $affiliations = [];
1463.         /** @var JournalAffiliation */
1464.         foreach ($this->affiliations as $entry) {
1465.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
1466.                 continue;
1467.             }
1469.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
1470.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
1471.         }
1473.         sort($affiliations);
1475.         return implode(', ',  $affiliations);
1476.     }
1478.     #[Groups(['read:stats'])]
1479.     public function getStatsAffiliationTypes(): ?string
1480.     {
1481.         $types = [];
1483.         /** @var JournalAffiliation */
1484.         foreach ($this->affiliations as $entry) {
1485.             if (!($type = $entry->getAffiliation()?->getType())) {
1486.                 continue;
1487.             }
1489.             if (isset($types[$type->getUuid()->toString()])) {
1490.                 continue;
1491.             }
1493.             $types[$type->getUuid()->toString()] = $type->getTitle();
1494.         }
1496.         sort($types);
1498.         return implode(', ',  $types);
1499.     }
1501.     #[Groups(['read:stats'])]
1502.     public function getStatsDomains(): ?string
1503.     {
1504.         $domains = [];
1506.         /** @var JournalDomain */
1507.         foreach ($this->domains as $entry) {
1508.             if (isset($domains[$entry->getDomain()->getUuid()->toString()])) {
1509.                 continue;
1510.             }
1512.             $domains[$entry->getDomain()->getUuid()->toString()] =
1513.                 $entry->getDomain()->readNativeLanguageTranslation('title');
1514.         }
1516.         sort($domains);
1518.         return implode(', ',  $domains);
1519.     }
1521.     #[Groups(['read:stats'])]
1522.     public function getStatsType(): ?string
1523.     {
1524.         return $this->data->getType()?->getTitle();
1525.     }
1527.     #[Groups(['read:stats'])]
1528.     public function getStatsState(): ?string
1529.     {
1530.         return $this->data->getState()?->getTitle();
1531.     }
1532. }