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\EditorialGroupableTrait,
38.     App\Entity\Trait\ImportIdTrait,
39.     App\Entity\Interface\TranslatableInterface,
40.     App\Entity\Interface\OrdStatableInterface,
41.     App\Entity\Interface\LanguageableInterface,
42.     App\Entity\Interface\EditorialGroupableInterface,
43.     App\Entity\Interface\ArchivableInterface,
44.     App\Entity\Interface\OwnerableInterface,
45.     App\Entity\Interface\CloneableInterface,
46.     App\Repository\JournalRepository;
48. use App\Enum\Language,
49.     App\Enum\JournalCoverType,
50.     App\Enum\JournalDefaultPage,
51.     App\Entity\Admin,
52.     App\Security\Voter\ArchivableVoter,
53.     App\Lib\Actions,
54.     App\DTO\CloneDTO,
55.     App\StateProcessor\CloneProcessor,
56.     App\Security\Voter\CloneVoter;
58. use App\Attribute\DenormalizationInject,
59.     App\Util\ClassUtils,
60.     App\Filter\IriFilter;
62. use App\Controller\Export\Journal\JournalCrossrefExporter,
63.     App\Controller\Export\Journal\JournalSimcheckCrossrefExporter,
64.     App\Controller\Export\Journal\JournalLicenceFulltextCrossrefExporter;
66. use App\Controller\Stats\StatsJournalXlsxGenerator;
67. use App\Filter\OrderByUnmapped;
68. use App\StateProvider\StatsJournalProvider;
69. use App\StateProvider\StatsSystemProvider;
71. #[ApiResource(
72.     description: 'Journals',
73.     normalizationContext: ['groups' => [
74.         'read',
75.         'read:' . self::class,
76.         'read:' . self::class . 'Translation'
77.     ]],
78.     denormalizationContext: ['groups' => ['write']],
79.     security: 'is_granted("' . self::class . '")',
80.     order: ['ord' => 'desc'],
81.     operations: [
82.         new GetCollection(),
83.         new GetCollection(
84.             uriTemplate: '/journals/list',
85.             normalizationContext: [ 'groups' => ['read', 'read:list' ]],
86.         ),
87.         new GetCollection(
88.             name: 'get_journal_stats_system',
89.             uriTemplate: '/journals/stats/system',
90.             provider: StatsSystemProvider::class,
91.             security: 'is_granted("ROLE_MODULE_STATS")',
92.             normalizationContext: ['groups' => ['read:stats']],
93.         ),
94.         new GetCollection(
95.             name: 'get_journal_stats',
96.             uriTemplate: '/journals/stats',
97.             provider: StatsJournalProvider::class,
98.             security: 'is_granted("ROLE_MODULE_STATS")',
99.             normalizationContext: ['groups' => ['read:stats']],
100.             paginationMaximumItemsPerPage: 500
101.         ),
102.         new GetCollection(
103.             name: 'get_journal_stats_xlsx',
104.             uriTemplate: '/journals/stats/xlsx',
105.             provider: StatsJournalProvider::class,
106.             controller: StatsJournalXlsxGenerator::class,
107.             security: 'is_granted("ROLE_MODULE_STATS")',
108.         ),
109.         new Post(
110.             uriTemplate: '/journals/clone',
111.             input: CloneDTO::class,
112.             processor: CloneProcessor::class,
113.             security: 'is_granted("' . Actions::CLONE .'")',
114.             securityMessage: CloneVoter::MESSAGE
115.         ),
116.         new Post(),
117.         new Get(),
118.         new Get(
119.             name: 'get_journal_crossref',
120.             uriTemplate: '/journals/{uuid}/export/crossref',
121.             controller: JournalCrossrefExporter::class
122.         ),
123.         new Get(
124.             name: 'get_journal_simcheck_crossref',
125.             uriTemplate: '/journals/{uuid}/export/simcheck_crossref',
126.             controller: JournalSimcheckCrossrefExporter::class
127.         ),
128.         new Get(
129.             name: 'get_journal_licence_fulltext_crossref',
130.             uriTemplate: '/journals/{uuid}/export/licence_fulltext_crossref',
131.             controller: JournalLicenceFulltextCrossrefExporter::class
132.         ),
133.         new Put(),
134.         new Delete(
135.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
136.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
137.         ),
138.     ],
139.     extraProperties: ['standard_put' => false],
140. )]
141. #[ApiFilter(SearchFilter::class, properties: [
142.     'translations.title' => 'partial',
143.     'nativeTitle' => 'partial',
144.     'data.workingTitle' => 'partial',
145.     'data.issn' => 'exact',
146.     'data.eIssn' => 'exact',
147. ])]
148. #[ApiFilter(RangeFilter::class, properties: ['meinScore'])]
149. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
150. #[ApiFilter(IriFilter::class, properties: [
151.     'nativeLanguage',
152.     'domains.domain',
153.     'affiliations.affiliation',
154.     'data.periodicity',
155.     'data.type',
156.     'data.licence',
157.     'data.state'
158. ])]
159. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
160. #[ApiFilter(OrderFilter::class, properties: [
161.     'nativeTitle',
162.     'nativeLanguage',
163.     'data.type',
164.     'data.state',
165.     'affiliations.affiliation.nativeTitle',
166.     'affiliations.affiliation.type.title',
167.     'domains.domain.nativeTitle',
168.     'data.workingTitle',
169.     'data.periodicity',
170.     'updatedAt',
171.     'stat',
172.     'ord'
173. ])]
174. #[ApiFilter(OrderByUnmapped::class, properties: [
175.     'statsEarliestArticlePublicationDate',
176.     'statsLatestArticlePublicationDate',
177.     'statsAmountOfArticles',
178.     'statsAmountOfArticles',
179.     'statsAmountOfIssues',
180.     'statsAmountOfVolumes',
181.     'statsAmountOfViews',
182.     'statsAmountOfDownloads'
183. ])]
184. #[Index(fields: ["nativeLanguage"], name: "native_language_idx")]
185. #[Index(fields: ["stat"], name: "stat_idx")]
186. #[ORM\Entity(repositoryClass: JournalRepository::class)]
187. class Journal implements
188.     TranslatableInterface,
189.     OrdStatableInterface,
190.     LanguageableInterface,
191.     EditorialGroupableInterface,
192.     ArchivableInterface,
193.     OwnerableInterface,
194.     CloneableInterface
195. {
196.     use IdTrait,
197.         UuidTrait,
198.         OrdStatTrait,
199.         TimestampableTrait,
200.         TranslatableTrait,
201.         JournalLanguagesTrait,
202.         ArchivedTrait,
203.         EditorialGroupableTrait,
204.         ImportIdTrait;
206.     #[ApiProperty(description: 'Native title sort key')]
207.     #[Groups(['read:' . self::class])]
208.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
209.     private ?string $nativeTitleSortKey = null;
211.     #[ApiProperty(description: 'Data subresource', writable: true)]
212.     #[Groups(['read:'. self::class, 'read:list', 'write'])]
213.     #[Assert\Valid]
214.     #[DenormalizationInject(method: ['name' => 'getData'])]
215.     #[ORM\OneToOne(targetEntity: JournalData::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
216.     private JournalData $data;
218.     #[ApiProperty(description: 'View subresource', writable: true)]
219.     #[Groups(['read:' . self::class, 'write'])]
220.     #[Assert\Valid]
221.     #[DenormalizationInject(method: ['name' => 'getView'])]
222.     #[ORM\OneToOne(targetEntity: JournalView::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
223.     private JournalView $view;
225.     #[ApiProperty(description: 'Newest new issue', writable: true)]
226.     #[ORM\OneToOne(targetEntity: JournalIssue::class)]
227.     #[ORM\JoinColumn(onDelete: 'set null', nullable: true)]
228.     private ?JournalIssue $newestNewIssue = null;
230.     #[ApiProperty(description: 'Slug')]
231.     #[Groups(['read:' . self::class, 'write'])]
232.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitle'])]
233.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
234.     private ?string $slug = null;
236.     #[ApiProperty(description: 'Slug')]
237.     #[Groups(['read:' . self::class, 'write'])]
238.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
239.     private ?string $importSlug = null;
241.     #[ApiProperty(description: 'Slug')]
242.     #[Groups(['read:' . self::class, 'write'])]
243.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
244.     private ?string $importSlugEn = null;
246.     #[ApiProperty(description: 'Created by')]
247.     #[Groups(['read:' . self::class])]
248.     #[ORM\ManyToOne(targetEntity: Admin::class, inversedBy: 'journals')]
249.     #[ORM\JoinColumn(onDelete: 'set null')]
250.     private Admin $createdBy;
252.     #[ApiProperty(description: 'Updated by')]
253.     #[Groups(['read:' . self::class])]
254.     #[ORM\ManyToOne(targetEntity: Admin::class)]
255.     #[ORM\JoinColumn(onDelete: 'set null')]
256.     private Admin $updatedBy;
258.     #[ApiProperty(description: 'Scientific council members', writableLink: false)]
259.     #[ORM\OneToMany(targetEntity: JournalScientificCouncilMember::class, mappedBy: 'parent', cascade: ['persist'])]
260.     #[ORM\OrderBy(['ord' => 'desc'])]
261.     private Collection $scientificCouncilMembers;
263.     #[ApiProperty(description: 'Domains', fetchEager: false)]
264.     #[Groups(['read', 'read:list'])]
265.     #[ORM\OneToMany(targetEntity: JournalDomain::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
266.     #[ORM\OrderBy(['ord' => 'desc'])]
267.     private Collection $domains;
269.     #[ApiProperty(description: 'Indexation collections')]
270.     #[ORM\OneToMany(targetEntity: JournalIndexationCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
271.     #[ORM\OrderBy(['ord' => 'desc'])]
272.     private Collection $indexationCollections;
274.     #[ApiProperty(description: 'Indicators')]
275.     #[ORM\OneToMany(targetEntity: JournalIndicator::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
276.     #[ORM\OrderBy(['ord' => 'desc'])]
277.     private Collection $indicators;
279.     #[ApiProperty(description: 'Affiliations', fetchEager: false)]
280.     #[Groups(['read','read:list'])]
281.     #[ORM\OneToMany(targetEntity: JournalAffiliation::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
282.     #[ORM\OrderBy(['ord' => 'desc'])]
283.     private Collection $affiliations;
285.     #[ApiProperty(description: 'Publishers')]
286.     #[ORM\OneToMany(targetEntity: JournalPublisher::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
287.     #[ORM\OrderBy(['ord' => 'desc'])]
288.     private Collection $publishers;
290.     #[ApiProperty(description: 'Partners')]
291.     #[ORM\OneToMany(targetEntity: JournalPartner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
292.     #[ORM\OrderBy(['ord' => 'desc'])]
293.     private Collection $partners;
295.     #[ApiProperty(description: 'Slides')]
296.     #[ORM\OneToMany(targetEntity: JournalSlide::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
297.     #[ORM\OrderBy(['ord' => 'desc'])]
298.     private Collection $slides;
300.     #[ApiProperty(description: 'Sections')]
301.     #[ORM\OneToMany(targetEntity: JournalSection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
302.     #[ORM\OrderBy(['ord' => 'desc'])]
303.     private Collection $sections;
305.     #[ApiProperty(description: 'Menu items')]
306.     #[ORM\OneToMany(targetEntity: JournalMenuItem::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
307.     #[ORM\OrderBy(['ord' => 'desc'])]
308.     private Collection $menuItems;
310.     #[ApiProperty(description: 'Submenu groups')]
311.     #[ORM\OneToMany(targetEntity: JournalSubmenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
312.     #[ORM\OrderBy(['ord' => 'desc'])]
313.     private Collection $submenuGroups;
315.     #[ApiProperty(description: 'Sidemenu groups')]
316.     #[ORM\OneToMany(targetEntity: JournalSidemenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
317.     #[ORM\OrderBy(['ord' => 'desc'])]
318.     private Collection $sidemenuGroups;
320.     #[ApiProperty(description: 'Banners')]
321.     #[ORM\OneToMany(targetEntity: JournalBanner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
322.     #[ORM\OrderBy(['ord' => 'desc'])]
323.     private Collection $banners;
325.     #[ApiProperty(description: 'Volumes')]
326.     #[ORM\OneToMany(targetEntity: JournalVolume::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
327.     #[ORM\OrderBy(['ord' => 'desc'])]
328.     private Collection $volumes;
330.     #[ApiProperty(description: 'Issues')]
331.     #[ORM\OneToMany(targetEntity: JournalIssue::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
332.     #[ORM\OrderBy(['ord' => 'desc'])]
333.     private Collection $issues;
335.     #[ApiProperty(description: 'Articles')]
336.     #[ORM\OneToMany(targetEntity: JournalArticle::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
337.     #[ORM\OrderBy(['ord' => 'desc'])]
338.     private Collection $articles;
340.     #[ApiProperty(description: 'Pages')]
341.     #[ORM\OneToMany(targetEntity: JournalPage::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
342.     #[ORM\OrderBy(['ord' => 'desc'])]
343.     private Collection $pages;
345.     #[ApiProperty(description: 'News')]
346.     #[ORM\OneToMany(targetEntity: JournalNews::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
347.     #[ORM\OrderBy(['ord' => 'desc'])]
348.     private Collection $news;
350.     #[ApiProperty(description: 'Collections')]
351.     #[ORM\OneToMany(targetEntity: JournalCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
352.     #[ORM\OrderBy(['ord' => 'desc'])]
353.     private Collection $collections;
355.     #[ApiProperty(description: 'Sort article by ord')]
356.     #[Groups(['read:' . self::class, 'write'])]
357.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
358.     private bool $sortArticlesByOrd = false;
360.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalFooter::class, orphanRemoval: true)]
361.     private Collection $smallFooters;
363.     #[ApiProperty(description: 'Statistics: earliest article publication date')]
364.     #[Groups(['read:stats'])]
365.     private ?\DateTimeImmutable $statsEarliestArticlePublicationDate = null;
367.     #[ApiProperty(description: 'Statistics: latest article publication date')]
368.     #[Groups(['read:stats'])]
369.     private ?\DateTimeImmutable $statsLatestArticlePublicationDate = null;
371.     #[ApiProperty(description: 'Statistics: amount of views')]
372.     #[Groups(['read:stats'])]
373.     private int $statsAmountOfArticles = 0;
375.     #[ApiProperty(description: 'Statistics: amount of views')]
376.     #[Groups(['read:stats'])]
377.     private int $statsAmountOfIssues = 0;
379.     #[ApiProperty(description: 'Statistics: amount of views')]
380.     #[Groups(['read:stats'])]
381.     private int $statsAmountOfVolumes = 0;
383.     #[ApiProperty(description: 'Statistics: amount of views')]
384.     #[Groups(['read:stats'])]
385.     private int $statsAmountOfViews = 0;
387.     #[ApiProperty(description: 'Statistics: amount of downloads')]
388.     #[Groups(['read:stats'])]
389.     private int $statsAmountOfDownloads = 0;
391.     public function __construct(Admin $createdBy, ?array $languages)
392.     {
393.         $this->setUuid();
395.         $this->data = new JournalData($this);
396.         $this->view = new JournalView($this);
398.         $this->createdBy = $createdBy;
399.         $this->updatedBy = $createdBy;
401.         $this->translations = new ArrayCollection();
403.         $this->domains = new ArrayCollection();
404.         $this->indexationCollections = new ArrayCollection();
405.         $this->indicators = new ArrayCollection();
407.         $this->affiliations = new ArrayCollection();
408.         $this->publishers = new ArrayCollection();
409.         $this->partners = new ArrayCollection();
411.         $this->slides = new ArrayCollection();
412.         $this->editorialGroups = new ArrayCollection();
413.         $this->scientificCouncilMembers = new ArrayCollection();
414.         $this->sections = new ArrayCollection();
416.         $this->menuItems = new ArrayCollection();
417.         $this->submenuGroups = new ArrayCollection();
418.         $this->sidemenuGroups = new ArrayCollection();
419.         $this->banners = new ArrayCollection();
421.         $this->volumes = new ArrayCollection();
422.         $this->issues = new ArrayCollection();
423.         $this->articles = new ArrayCollection();
425.         $this->pages = new ArrayCollection();
426.         $this->news = new ArrayCollection();
428.         $this->collections = new ArrayCollection();
430.         $this->setLanguages($languages ?? Language::DEFAULT_JOURNAL);
432.         foreach (array_reverse(JournalDefaultPage::cases()) as $index => $idName) {
433.             new JournalPage(
434.                 parent: $this,
435.                 workingTitle: $idName->value,
436.                 idName: $idName->value,
437.                 ord: $index + 1,
438.                 stat: true
439.             );
440.         }
442.         $this->createdAt = new \DateTimeImmutable();
443.         $this->updatedAt = new \DateTimeImmutable();
444.         $this->smallFooters = new ArrayCollection();
445.     }
447.     public function getTitle(): string
448.     {
449.         return $this->data->getWorkingTitle();
450.     }
452.     public function setNativeTitleSortKey(string $nativeTitleSortKey): self
453.     {
454.         $this->nativeTitleSortKey = $nativeTitleSortKey;
456.         return $this;
457.     }
459.     public function getNativeTitleSortKey(): ?string
460.     {
461.         return $this->nativeTitleSortKey;
462.     }
464.     public function getData(): JournalData
465.     {
466.         return $this->data;
467.     }
469.     public function getView(): JournalView
470.     {
471.         return $this->view;
472.     }
474.     public function getCover(Language $lang): ?Media
475.     {
476.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
477.             return $this->readAvailableTranslation($lang, 'cover');
478.         }
480.         if ($cover = $this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
481.             return $cover;
482.         }
484.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
485.             ? $this->readAvailableTranslation($lang, 'cover')
486.             : null;
487.     }
489.     public function getCoverAlt(Language $lang): ?string
490.     {
491.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
492.             return $this->readAvailableTranslation($lang, 'coverAlt');
493.         }
495.         if ($this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
496.             return $this->getNewestIssue()?->readAvailableTranslation($lang, 'coverAlt');
497.         }
499.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
500.             ? $this->readAvailableTranslation($lang, 'coverAlt')
501.             : null;
502.     }
504.     public function getNewestNewIssue(): ?JournalIssue
505.     {
506.         return $this->newestNewIssue;
507.     }
509.     public function setNewestNewIssue(?JournalIssue $newestNewIssue): self
510.     {
511.         $this->newestNewIssue = $newestNewIssue;
513.         return $this;
514.     }
516.     public function getNewestIssue(): ?JournalIssue
517.     {
518.         foreach ($this->getIssues() as $issue) {
519.             if ($issue->getStat() && $issue->getIsNewestIssue()) {
520.                 return $issue;
521.             }
522.         }
524.         return null;
525.     }
527.     public function getSlug(): ?string
528.     {
529.         return $this->slug;
530.     }
532.     public function setSlug(?string $slug): self
533.     {
534.         $this->slug = $slug;
536.         return $this;
537.     }
539.     public function getImportSlug(): ?string
540.     {
541.         return $this->importSlug;
542.     }
544.     public function setImportSlug(?string $importSlug): self
545.     {
546.         $this->importSlug = $importSlug;
548.         return $this;
549.     }
551.     public function getImportSlugEn(): ?string
552.     {
553.         return $this->importSlugEn;
554.     }
556.     public function setImportSlugEn(?string $importSlugEn): self
557.     {
558.         $this->importSlugEn = $importSlugEn;
560.         return $this;
561.     }
563.     public function getCreatedBy(): Admin
564.     {
565.         return $this->createdBy;
566.     }
568.     public function getUpdatedBy(): Admin
569.     {
570.         return $this->updatedBy;
571.     }
573.     public function setUpdatedBy(Admin $updatedBy): self
574.     {
575.         $this->updatedBy = $updatedBy;
577.         return $this;
578.     }
580.     /**
581.      * @return Collection|JournalScientificCouncilMember[]
582.      */
583.     public function getScientificCouncilMembers(): Collection
584.     {
585.         return $this->scientificCouncilMembers;
586.     }
588.     public function addScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
589.     {
590.         if ($this->scientificCouncilMembers->contains($scientificCouncilMember)) {
591.             return $this;
592.         }
594.         $this->scientificCouncilMembers[] = $scientificCouncilMember;
596.         return $this;
597.     }
599.     public function removeScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
600.     {
601.         $this->scientificCouncilMembers->removeElement($scientificCouncilMember);
603.         return $this;
604.     }
606.     public function resetScientificCouncilMembers(): self
607.     {
608.         $this->scientificCouncilMembers = new ArrayCollection();
610.         return $this;
611.     }
613.     /**
614.      * @return Collection|JournalDomain[]
615.      */
616.     public function getDomains(): Collection
617.     {
618.         return $this->domains;
619.     }
621.     public function addDomain(JournalDomain $domain): self
622.     {
623.         if ($this->domains->contains($domain)) {
624.             return $this;
625.         }
627.         $this->domains[] = $domain;
629.         return $this;
630.     }
632.     public function removeDomain(JournalDomain $domain): self
633.     {
634.         $this->domains->removeElement($domain);
636.         return $this;
637.     }
639.     public function resetDomains(): self
640.     {
641.         $this->domains = new ArrayCollection();
643.         return $this;
644.     }
646.     /**
647.      * @return Collection|JournalIndexationCollection[]
648.      */
649.     public function getIndexationCollections(): Collection
650.     {
651.         return $this->indexationCollections;
652.     }
654.     public function addIndexationCollection(JournalIndexationCollection $indexationCollection): self
655.     {
656.         if ($this->indexationCollections->contains($indexationCollection)) {
657.             return $this;
658.         }
660.         $this->indexationCollections[] = $indexationCollection;
662.         return $this;
663.     }
665.     public function removeIndexationCollection(JournalIndexationCollection $indexationCollection): self
666.     {
667.         $this->indexationCollections->removeElement($indexationCollection);
669.         return $this;
670.     }
672.     public function resetIndexationCollections(): self
673.     {
674.         $this->indexationCollections = new ArrayCollection();
676.         return $this;
677.     }
679.     /**
680.      * @return Collection|JournalIndicator[]
681.      */
682.     public function getIndicators(): Collection
683.     {
684.         return $this->indicators;
685.     }
687.     public function addIndicator(JournalIndicator $indicator): self
688.     {
689.         if ($this->indicators->contains($indicator)) {
690.             return $this;
691.         }
693.         $this->indicators[] = $indicator;
695.         return $this;
696.     }
698.     public function removeIndicator(JournalIndicator $indicator): self
699.     {
700.         $this->indicators->removeElement($indicator);
702.         return $this;
703.     }
705.     public function resetIndicators(): self
706.     {
707.         $this->indicators = new ArrayCollection();
709.         return $this;
710.     }
712.     /**
713.      * @return Collection|JournalAffiliation[]
714.      */
715.     public function getAffiliations(): Collection
716.     {
717.         return $this->affiliations;
718.     }
720.     public function addAffiliation(JournalAffiliation $affiliation): self
721.     {
722.         if ($this->affiliations->contains($affiliation)) {
723.             return $this;
724.         }
726.         $this->affiliations[] = $affiliation;
728.         return $this;
729.     }
731.     public function removeAffiliation(JournalAffiliation $affiliation): self
732.     {
733.         $this->affiliations->removeElement($affiliation);
735.         return $this;
736.     }
738.     public function resetAffiliations(): self
739.     {
740.         $this->affiliations = new ArrayCollection();
742.         return $this;
743.     }
745.     /**
746.      * @return Collection|JournalPublisher[]
747.      */
748.     public function getPublishers(): Collection
749.     {
750.         return $this->publishers;
751.     }
753.     public function addPublisher(JournalPublisher $publisher): self
754.     {
755.         if ($this->publishers->contains($publisher)) {
756.             return $this;
757.         }
759.         $this->publishers[] = $publisher;
761.         return $this;
762.     }
764.     public function removePublisher(JournalPublisher $publisher): self
765.     {
766.         $this->publishers->removeElement($publisher);
768.         return $this;
769.     }
771.     public function resetPublishers(): self
772.     {
773.         $this->publishers = new ArrayCollection();
775.         return $this;
776.     }
778.     public function getVisiblePublishers(): Collection
779.     {
780.         return $this->publishers->filter(
781.             fn (JournalPublisher $publisher) =>
782.                 $publisher->getStat() === true &&
783.                 $publisher->getPublisher()->getStat() === true
784.         );
785.     }
787.     /**
788.      * @return Collection|JournalPartner[]
789.      */
790.     public function getPartners(): Collection
791.     {
792.         return $this->partners;
793.     }
795.     public function addPartner(JournalPartner $partner): self
796.     {
797.         if ($this->partners->contains($partner)) {
798.             return $this;
799.         }
801.         $this->partners[] = $partner;
803.         return $this;
804.     }
806.     public function removePartner(JournalPartner $partner): self
807.     {
808.         $this->partners->removeElement($partner);
810.         return $this;
811.     }
813.     public function resetPartners(): self
814.     {
815.         $this->partners = new ArrayCollection();
817.         return $this;
818.     }
820.     /**
821.      * @return Collection|JournalSlide[]
822.      */
823.     public function getSlides(): Collection
824.     {
825.         return $this->slides;
826.     }
828.     public function addSlide(JournalSlide $slide): self
829.     {
830.         if ($this->slides->contains($slide)) {
831.             return $this;
832.         }
834.         $this->slides[] = $slide;
836.         return $this;
837.     }
839.     public function removeSlide(JournalSlide $slide): self
840.     {
841.         $this->slides->removeElement($slide);
843.         return $this;
844.     }
846.     public function resetSlides(): self
847.     {
848.         $this->slides = new ArrayCollection();
850.         return $this;
851.     }
853.     /**
854.      * @return Collection|JournalSection[]
855.      */
856.     public function getSections(): Collection
857.     {
858.         return $this->sections;
859.     }
861.     public function addSection(JournalSection $section): self
862.     {
863.         if ($this->sections->contains($section)) {
864.             return $this;
865.         }
867.         $this->sections[] = $section;
869.         return $this;
870.     }
872.     public function removeSection(JournalSection $section): self
873.     {
874.         $this->sections->removeElement($section);
876.         return $this;
877.     }
879.     public function resetSections(): self
880.     {
881.         $this->sections = new ArrayCollection();
883.         return $this;
884.     }
886.     /**
887.      * @return Collection|JournalMenuItem[]
888.      */
889.     public function getMenuItems(): Collection
890.     {
891.         return $this->menuItems;
892.     }
894.     public function addMenuItem(JournalMenuItem $menuItem): self
895.     {
896.         if ($this->menuItems->contains($menuItem)) {
897.             return $this;
898.         }
900.         $this->menuItems[] = $menuItem;
902.         return $this;
903.     }
905.     public function removeMenuItem(JournalMenuItem $menuItem): self
906.     {
907.         $this->menuItems->removeElement($menuItem);
909.         return $this;
910.     }
912.     public function resetMenuItems(): self
913.     {
914.         $this->menuItems = new ArrayCollection();
916.         return $this;
917.     }
919.     /**
920.      * @return Collection|JournalSubmenuGroup[]
921.      */
922.     public function getSubmenuGroups(): Collection
923.     {
924.         return $this->submenuGroups;
925.     }
927.     public function addSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
928.     {
929.         if ($this->submenuGroups->contains($submenuGroup)) {
930.             return $this;
931.         }
933.         $this->submenuGroups[] = $submenuGroup;
935.         return $this;
936.     }
938.     public function removeSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
939.     {
940.         $this->submenuGroups->removeElement($submenuGroup);
942.         return $this;
943.     }
945.     public function resetSubmenuGroups(): self
946.     {
947.         $this->submenuGroups = new ArrayCollection();
949.         return $this;
950.     }
952.     /**
953.      * @return Collection|JournalSidemenuGroup[]
954.      */
955.     public function getSidemenuGroups(): Collection
956.     {
957.         return $this->sidemenuGroups;
958.     }
960.     public function addSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
961.     {
962.         if ($this->sidemenuGroups->contains($sidemenuGroup)) {
963.             return $this;
964.         }
966.         $this->sidemenuGroups[] = $sidemenuGroup;
968.         return $this;
969.     }
971.     public function removeSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
972.     {
973.         $this->sidemenuGroups->removeElement($sidemenuGroup);
975.         return $this;
976.     }
978.     public function resetSidemenuGroups(): self
979.     {
980.         $this->sidemenuGroups = new ArrayCollection();
982.         return $this;
983.     }
985.     /**
986.      * @return Collection|JournalBanner[]
987.      */
988.     public function getBanners(): Collection
989.     {
990.         return $this->banners;
991.     }
993.     public function addBanner(JournalBanner $banner): self
994.     {
995.         if ($this->banners->contains($banner)) {
996.             return $this;
997.         }
999.         $this->banners[] = $banner;
1001.         return $this;
1002.     }
1004.     public function removeBanner(JournalBanner $banner): self
1005.     {
1006.         $this->banners->removeElement($banner);
1008.         return $this;
1009.     }
1011.     public function resetBanners(): self
1012.     {
1013.         $this->banners = new ArrayCollection();
1015.         return $this;
1016.     }
1018.     /**
1019.      * @return Collection|JournalVolume[]
1020.      */
1021.     public function getVolumes(): Collection
1022.     {
1023.         return $this->volumes;
1024.     }
1026.     public function addVolume(JournalVolume $volume): self
1027.     {
1028.         if ($this->volumes->contains($volume)) {
1029.             return $this;
1030.         }
1032.         $this->volumes[] = $volume;
1034.         return $this;
1035.     }
1037.     public function removeVolume(JournalVolume $volume): self
1038.     {
1039.         $this->volumes->removeElement($volume);
1041.         return $this;
1042.     }
1044.     public function resetVolumes(): self
1045.     {
1046.         $this->volumes = new ArrayCollection();
1048.         return $this;
1049.     }
1051.     /**
1052.      * @return Collection<int, JournalIssue>
1053.      */
1054.     public function getIssues(): Collection
1055.     {
1056.         return $this->issues;
1057.     }
1059.     /**
1060.      * @return Collection<int, JournalIssue>
1061.      */
1062.     public function getVisibleIssues(): Collection
1063.     {
1064.         return $this->issues->filter(fn (JournalIssue $issue) => $issue->getStat());
1065.     }
1067.     public function addIssue(JournalIssue $issue): self
1068.     {
1069.         if ($this->issues->contains($issue)) {
1070.             return $this;
1071.         }
1073.         $this->issues[] = $issue;
1075.         return $this;
1076.     }
1078.     public function removeIssue(JournalIssue $issue): self
1079.     {
1080.         $this->issues->removeElement($issue);
1082.         return $this;
1083.     }
1085.     public function resetIssues(): self
1086.     {
1087.         $this->issues = new ArrayCollection();
1089.         return $this;
1090.     }
1092.     public function getOldestIssue(): ?JournalIssue
1093.     {
1094.         $filtered = new ArrayCollection();
1096.         foreach ($this->getIssues() as $issue) {
1097.             if ($issue->getStat() && $issue->getPublishedAt()) {
1098.                 $filtered->add($issue);
1099.             }
1100.         }
1102.         if (count($filtered) === 0) {
1103.             return null;
1104.         }
1106.         $criteria = Criteria::create()->orderBy(['publishedAt' => Criteria::ASC]);
1108.         return $filtered
1109.             ->matching($criteria)
1110.             ->first();
1111.     }
1113.     /**
1114.      * @return Collection|JournalArticle[]
1115.      */
1116.     public function getArticles(): Collection
1117.     {
1118.         return $this->articles;
1119.     }
1121.     /**
1122.      * @return Collection<int, JournalArticle>
1123.      */
1124.     public function getArticlesVisible(): Collection
1125.     {
1126.         return $this->articles->filter(fn (JournalArticle $article) => $article->getStat());
1127.     }
1129.     public function addArticle(JournalArticle $article): self
1130.     {
1131.         if ($this->articles->contains($article)) {
1132.             return $this;
1133.         }
1135.         $this->articles[] = $article;
1137.         return $this;
1138.     }
1140.     public function removeArticle(JournalArticle $article): self
1141.     {
1142.         $this->articles->removeElement($article);
1144.         return $this;
1145.     }
1147.     public function resetArticles(): self
1148.     {
1149.         $this->articles = new ArrayCollection();
1151.         return $this;
1152.     }
1154.     /**
1155.      * @return Collection|JournalPage[]
1156.      */
1157.     public function getPages(): Collection
1158.     {
1159.         return $this->pages;
1160.     }
1162.     public function addPage(JournalPage $page): self
1163.     {
1164.         if ($this->pages->contains($page)) {
1165.             return $this;
1166.         }
1168.         $this->pages[] = $page;
1170.         return $this;
1171.     }
1173.     public function removePage(JournalPage $page): self
1174.     {
1175.         $this->pages->removeElement($page);
1177.         return $this;
1178.     }
1180.     public function resetPages(): self
1181.     {
1182.         $this->pages = new ArrayCollection();
1184.         return $this;
1185.     }
1187.     /**
1188.      * @return Collection|JournalNews[]
1189.      */
1190.     public function getNews(): Collection
1191.     {
1192.         return $this->news;
1193.     }
1195.     public function addNews(JournalNews $news): self
1196.     {
1197.         if ($this->news->contains($news)) {
1198.             return $this;
1199.         }
1201.         $this->news[] = $news;
1203.         return $this;
1204.     }
1206.     public function removeNews(JournalNews $news): self
1207.     {
1208.         $this->news->removeElement($news);
1210.         return $this;
1211.     }
1213.     public function resetNews(): self
1214.     {
1215.         $this->news = new ArrayCollection();
1217.         return $this;
1218.     }
1220.     /**
1221.      * @return Collection|JournalCollection[]
1222.      */
1223.     public function getCollections(): Collection
1224.     {
1225.         return $this->collections;
1226.     }
1228.     public function addCollection(JournalCollection $collection): self
1229.     {
1230.         if ($this->collections->contains($collection)) {
1231.             return $this;
1232.         }
1234.         $this->collections[] = $collection;
1236.         return $this;
1237.     }
1239.     public function removeCollection(JournalCollection $news): self
1240.     {
1241.         $this->news->removeElement($news);
1243.         return $this;
1244.     }
1246.     public function resetCollections(): self
1247.     {
1248.         $this->collections = new ArrayCollection();
1250.         return $this;
1251.     }
1253.     public function clone(Admin $createdBy = null): self
1254.     {
1255.         $clone = clone $this;
1257.         $clone->id = null;
1258.         $clone->setUuid();
1260.         $clone->ord = 0;
1261.         $clone->stat = false;
1262.         $clone->importId = null;
1264.         $clone->data = $this->data->clone($clone);
1265.         $clone->view = $this->view->clone($clone);
1267.         $nativeLanguage = $clone->getNativeLanguage();
1268.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
1269.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
1271.         ClassUtils::cloneCollection($this, $clone, 'translations');
1273.         $clone
1274.             ->resetDomains()
1275.             ->resetIndexationCollections()
1276.             ->resetIndicators()
1277.             ->resetAffiliations()
1278.             ->resetPublishers()
1279.             ->resetPartners()
1280.             ->resetSlides()
1281.             ->resetSections()
1282.             ->resetMenuItems()
1283.             ->resetSubmenuGroups()
1284.             ->resetBanners()
1285.             ->resetVolumes()
1286.             ->resetIssues()
1287.             ->resetArticles()
1288.             ->resetPages()
1289.             ->resetNews()
1290.             ->resetCollections()
1291.             ->resetEditorialGroups()
1292.             ->resetScientificCouncilMembers();
1294.         $clone->createdBy = $createdBy ?? $clone->createdBy;
1295.         $clone->updatedBy = $createdBy ?? $clone->updatedBy;
1297.         $clone->createdAt = new \DateTimeImmutable();
1298.         $clone->updatedAt = new \DateTimeImmutable();
1300.         return $clone;
1301.     }
1303.     public function isSortArticlesByOrd(): bool
1304.     {
1305.         return $this->sortArticlesByOrd;
1306.     }
1308.     public function setSortArticlesByOrd(bool $sortArticlesByOrd): self
1309.     {
1310.         $this->sortArticlesByOrd = $sortArticlesByOrd;
1312.         return $this;
1313.     }
1315.     /**
1316.      * @return Collection<int, JournalFooter>
1317.      */
1318.     public function getSmallFooters(): Collection
1319.     {
1320.         return $this->smallFooters;
1321.     }
1323.     public function addSmallFooter(JournalFooter $smallFooter): self
1324.     {
1325.         if (!$this->smallFooters->contains($smallFooter)) {
1326.             $this->smallFooters->add($smallFooter);
1327.             $smallFooter->setParent($this);
1328.         }
1330.         return $this;
1331.     }
1333.     public function removeSmallFooter(JournalFooter $smallFooter): self
1334.     {
1335.         if ($this->smallFooters->removeElement($smallFooter)) {
1336.             // set the owning side to null (unless already changed)
1337.             if ($smallFooter->getParent() === $this) {
1338.                 $smallFooter->setParent(null);
1339.             }
1340.         }
1342.         return $this;
1343.     }
1345.     public function getVisibleSmallFooters(): Collection
1346.     {
1347.         return $this->smallFooters->filter(fn (JournalFooter $smallFooter) => $smallFooter->getStat());
1348.     }
1350.     public function getStatsAmountOfArticles(): int
1351.     {
1352.         return $this->statsAmountOfArticles;
1353.     }
1355.     public function setStatsAmountOfArticles(int $statsAmountOfArticles): self
1356.     {
1357.         $this->statsAmountOfArticles = $statsAmountOfArticles;
1359.         return $this;
1360.     }
1362.     public function getStatsAmountOfIssues(): int
1363.     {
1364.         return $this->statsAmountOfIssues;
1365.     }
1367.     public function setStatsAmountOfIssues(int $statsAmountOfIssues): self
1368.     {
1369.         $this->statsAmountOfIssues = $statsAmountOfIssues;
1371.         return $this;
1372.     }
1374.     public function getStatsAmountOfVolumes(): int
1375.     {
1376.         return $this->statsAmountOfVolumes;
1377.     }
1379.     public function setStatsAmountOfVolumes(int $statsAmountOfVolumes): self
1380.     {
1381.         $this->statsAmountOfVolumes = $statsAmountOfVolumes;
1383.         return $this;
1384.     }
1386.     public function getStatsAmountOfViews(): int
1387.     {
1388.         return $this->statsAmountOfViews;
1389.     }
1391.     public function setStatsAmountOfViews(int $statsAmountOfViews): self
1392.     {
1393.         $this->statsAmountOfViews = $statsAmountOfViews;
1395.         return $this;
1396.     }
1398.     public function getStatsAmountOfDownloads(): int
1399.     {
1400.         return $this->statsAmountOfDownloads;
1401.     }
1403.     public function setStatsAmountOfDownloads(int $statsAmountOfDownloads): self
1404.     {
1405.         $this->statsAmountOfDownloads = $statsAmountOfDownloads;
1407.         return $this;
1408.     }
1410.     public function getStatsEarliestArticlePublicationDate(): ?\DateTimeImmutable
1411.     {
1412.         return $this->statsEarliestArticlePublicationDate;
1413.     }
1415.     public function setStatsEarliestArticlePublicationDate(?string $statsEarliestArticlePublicationDate): self
1416.     {
1417.         if (! $statsEarliestArticlePublicationDate) {
1418.             return $this;
1419.         }
1421.         $this->statsEarliestArticlePublicationDate = new \DateTimeImmutable($statsEarliestArticlePublicationDate);
1423.         return $this;
1424.     }
1426.     public function getStatsLatestArticlePublicationDate(): ?\DateTimeImmutable
1427.     {
1428.         return $this->statsLatestArticlePublicationDate;
1429.     }
1431.     public function setStatsLatestArticlePublicationDate(?string $statsLatestArticlePublicationDate): self
1432.     {
1433.         if (! $statsLatestArticlePublicationDate) {
1434.             return $this;
1435.         }
1437.         $this->statsLatestArticlePublicationDate = new \DateTimeImmutable($statsLatestArticlePublicationDate);
1439.         return $this;
1440.     }
1442.     #[Groups(['read:stats'])]
1443.     public function getStatsAffiliations(): ?string
1444.     {
1445.         $affiliations = [];
1447.         /** @var JournalAffiliation */
1448.         foreach($this->affiliations as $entry) {
1449.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
1450.                 continue;
1451.             }
1453.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
1454.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
1455.         }
1457.         sort($affiliations);
1459.         return implode(', ',  $affiliations);
1460.     }
1462.     #[Groups(['read:stats'])]
1463.     public function getStatsAffiliationTypes(): ?string
1464.     {
1465.         $types = [];
1467.         /** @var JournalAffiliation */
1468.         foreach($this->affiliations as $entry) {
1469.             if (! ($type = $entry->getAffiliation()?->getType())) {
1470.                 continue;
1471.             }
1473.             if (isset($types[$type->getUuid()->toString()])) {
1474.                 continue;
1475.             }
1477.             $types[$type->getUuid()->toString()] = $type->getTitle();
1478.         }
1480.         sort($types);
1482.         return implode(', ',  $types);
1483.     }
1485.     #[Groups(['read:stats'])]
1486.     public function getStatsDomains(): ?string
1487.     {
1488.         $domains = [];
1490.         /** @var JournalDomain */
1491.         foreach($this->domains as $entry) {
1492.             if (isset($domains[$entry->getDomain()->getUuid()->toString()])) {
1493.                 continue;
1494.             }
1496.             $domains[$entry->getDomain()->getUuid()->toString()] =
1497.                 $entry->getDomain()->readNativeLanguageTranslation('title');
1498.         }
1500.         sort($domains);
1502.         return implode(', ',  $domains);
1503.     }
1505.     #[Groups(['read:stats'])]
1506.     public function getStatsType(): ?string
1507.     {
1508.         return $this->data->getType()?->getTitle();
1509.     }
1511.     #[Groups(['read:stats'])]
1512.     public function getStatsState(): ?string
1513.     {
1514.         return $this->data->getState()?->getTitle();
1515.     }
1516. }