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.     'nativeLanguage' => 'partial',
148.     'data.workingTitle' => 'partial',
149.     'data.issn' => 'exact',
150.     'data.eIssn' => 'exact',
151.     'data.state' => 'exact',
152.     'data.type' => 'exact',
153.     'domains.domain.nativeTitle' => 'partial',
154.     'affiliations.affiliation.nativeTitle' => 'partial',
155.     'affiliations.affiliation.type.title' => 'partial'
156. ])]
157. #[ApiFilter(RangeFilter::class, properties: ['data.meinScore'])]
158. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
159. #[ApiFilter(IriFilter::class, properties: [
160.     'nativeLanguage',
161.     'domains.domain',
162.     'affiliations.affiliation',
163.     'data.periodicity',
164.     'data.type',
165.     'data.licence',
166.     'data.state'
167. ])]
168. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
169. #[ApiFilter(OrderFilter::class, properties: [
170.     'nativeTitle',
171.     'nativeLanguage',
172.     'data.type',
173.     'data.state',
174.     'affiliations.affiliation.nativeTitle',
175.     'affiliations.affiliation.type.title',
176.     'domains.domain.nativeTitle',
177.     'data.workingTitle',
178.     'data.periodicity',
179.     'updatedAt',
180.     'stat',
181.     'ord'
182. ])]
183. #[ApiFilter(OrderByUnmapped::class, properties: [
184.     'statsEarliestArticlePublicationDate',
185.     'statsLatestArticlePublicationDate',
186.     'statsAmountOfArticles',
187.     'statsAmountOfArticles',
188.     'statsAmountOfIssues',
189.     'statsAmountOfVolumes',
190.     'statsAmountOfViews',
191.     'statsAmountOfDownloads'
192. ])]
193. #[ApiFilter(RangeUnmapped::class, properties: [
194.     'statsAmountOfVolumes',
195.     'statsAmountOfIssues',
196.     'statsAmountOfArticles',
197.     'statsAmountOfViews',
198.     'statsAmountOfDownloads'
199. ])]
200. #[ApiFilter(DateUnmapped::class, properties: ['statsEarliestArticlePublicationDate','statsLatestArticlePublicationDate'])]
201. #[Index(fields: ["nativeLanguage"], name: "native_language_idx")]
202. #[Index(fields: ["stat"], name: "stat_idx")]
203. #[ORM\Entity(repositoryClass: JournalRepository::class)]
204. class Journal implements
205.     TranslatableInterface,
206.     OrdStatableInterface,
207.     LanguageableInterface,
208.     EditorialGroupableInterface,
209.     ArchivableInterface,
210.     OwnerableInterface,
211.     CloneableInterface
212. {
213.     use IdTrait,
214.         UuidTrait,
215.         OrdStatTrait,
216.         TimestampableTrait,
217.         TranslatableTrait,
218.         JournalLanguagesTrait,
219.         ArchivedTrait,
220.         EditorialGroupableTrait,
221.         ImportIdTrait;
223.     #[ApiProperty(description: 'Native title sort key')]
224.     #[Groups(['read:' . self::class, 'read:stats'])]
225.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
226.     private ?string $nativeTitleSortKey = null;
228.     #[ApiProperty(description: 'Data subresource', writable: true)]
229.     #[Groups(['read:' . self::class, 'read:list', 'write'])]
230.     #[Assert\Valid]
231.     #[DenormalizationInject(method: ['name' => 'getData'])]
232.     #[ORM\OneToOne(targetEntity: JournalData::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
233.     private JournalData $data;
235.     #[ApiProperty(description: 'View subresource', writable: true)]
236.     #[Groups(['read:' . self::class, 'write'])]
237.     #[Assert\Valid]
238.     #[DenormalizationInject(method: ['name' => 'getView'])]
239.     #[ORM\OneToOne(targetEntity: JournalView::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
240.     private JournalView $view;
242.     #[ApiProperty(description: 'Newest new issue', writable: true)]
243.     #[ORM\OneToOne(targetEntity: JournalIssue::class)]
244.     #[ORM\JoinColumn(onDelete: 'set null', nullable: true)]
245.     private ?JournalIssue $newestNewIssue = null;
247.     #[ApiProperty(description: 'Slug')]
248.     #[Groups(['read:' . self::class, 'write'])]
249.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitle'])]
250.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
251.     private ?string $slug = null;
253.     #[ApiProperty(description: 'Slug')]
254.     #[Groups(['read:' . self::class, 'write'])]
255.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
256.     private ?string $importSlug = null;
258.     #[ApiProperty(description: 'Slug')]
259.     #[Groups(['read:' . self::class, 'write'])]
260.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
261.     private ?string $importSlugEn = null;
263.     #[ApiProperty(description: 'Created by')]
264.     #[Groups(['read:' . self::class])]
265.     #[ORM\ManyToOne(targetEntity: Admin::class, inversedBy: 'journals')]
266.     #[ORM\JoinColumn(onDelete: 'set null')]
267.     private Admin $createdBy;
269.     #[ApiProperty(description: 'Updated by')]
270.     #[Groups(['read:' . self::class])]
271.     #[ORM\ManyToOne(targetEntity: Admin::class)]
272.     #[ORM\JoinColumn(onDelete: 'set null')]
273.     private Admin $updatedBy;
275.     #[ApiProperty(description: 'Scientific council members', writableLink: false)]
276.     #[ORM\OneToMany(targetEntity: JournalScientificCouncilMember::class, mappedBy: 'parent', cascade: ['persist'])]
277.     #[ORM\OrderBy(['ord' => 'desc'])]
278.     private Collection $scientificCouncilMembers;
280.     #[ApiProperty(description: 'Domains', fetchEager: false)]
281.     #[Groups(['read', 'read:list'])]
282.     #[ORM\OneToMany(targetEntity: JournalDomain::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
283.     #[ORM\OrderBy(['ord' => 'desc'])]
284.     private Collection $domains;
286.     #[ApiProperty(description: 'Indexation collections')]
287.     #[ORM\OneToMany(targetEntity: JournalIndexationCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
288.     #[ORM\OrderBy(['ord' => 'desc'])]
289.     private Collection $indexationCollections;
291.     #[ApiProperty(description: 'Indicators')]
292.     #[ORM\OneToMany(targetEntity: JournalIndicator::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
293.     #[ORM\OrderBy(['ord' => 'desc'])]
294.     private Collection $indicators;
296.     #[ApiProperty(description: 'Affiliations', fetchEager: false)]
297.     #[Groups(['read', 'read:list'])]
298.     #[ORM\OneToMany(targetEntity: JournalAffiliation::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
299.     #[ORM\OrderBy(['ord' => 'desc'])]
300.     private Collection $affiliations;
302.     #[ApiProperty(description: 'Publishers')]
303.     #[ORM\OneToMany(targetEntity: JournalPublisher::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
304.     #[ORM\OrderBy(['ord' => 'desc'])]
305.     private Collection $publishers;
307.     #[ApiProperty(description: 'Partners')]
308.     #[ORM\OneToMany(targetEntity: JournalPartner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
309.     #[ORM\OrderBy(['ord' => 'desc'])]
310.     private Collection $partners;
312.     #[ApiProperty(description: 'Slides')]
313.     #[ORM\OneToMany(targetEntity: JournalSlide::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
314.     #[ORM\OrderBy(['ord' => 'desc'])]
315.     private Collection $slides;
317.     #[ApiProperty(description: 'Sections')]
318.     #[ORM\OneToMany(targetEntity: JournalSection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
319.     #[ORM\OrderBy(['ord' => 'desc'])]
320.     private Collection $sections;
322.     #[ApiProperty(description: 'Menu items')]
323.     #[ORM\OneToMany(targetEntity: JournalMenuItem::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
324.     #[ORM\OrderBy(['ord' => 'desc'])]
325.     private Collection $menuItems;
327.     #[ApiProperty(description: 'Submenu groups')]
328.     #[ORM\OneToMany(targetEntity: JournalSubmenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
329.     #[ORM\OrderBy(['ord' => 'desc'])]
330.     private Collection $submenuGroups;
332.     #[ApiProperty(description: 'Sidemenu groups')]
333.     #[ORM\OneToMany(targetEntity: JournalSidemenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
334.     #[ORM\OrderBy(['ord' => 'desc'])]
335.     private Collection $sidemenuGroups;
337.     #[ApiProperty(description: 'Banners')]
338.     #[ORM\OneToMany(targetEntity: JournalBanner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
339.     #[ORM\OrderBy(['ord' => 'desc'])]
340.     private Collection $banners;
342.     #[ApiProperty(description: 'Volumes')]
343.     #[ORM\OneToMany(targetEntity: JournalVolume::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
344.     #[ORM\OrderBy(['ord' => 'desc'])]
345.     private Collection $volumes;
347.     #[ApiProperty(description: 'Issues')]
348.     #[ORM\OneToMany(targetEntity: JournalIssue::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
349.     #[ORM\OrderBy(['ord' => 'desc'])]
350.     private Collection $issues;
352.     #[ApiProperty(description: 'Articles')]
353.     #[ORM\OneToMany(targetEntity: JournalArticle::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
354.     #[ORM\OrderBy(['ord' => 'desc'])]
355.     private Collection $articles;
357.     #[ApiProperty(description: 'Pages')]
358.     #[ORM\OneToMany(targetEntity: JournalPage::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
359.     #[ORM\OrderBy(['ord' => 'desc'])]
360.     private Collection $pages;
362.     #[ApiProperty(description: 'News')]
363.     #[ORM\OneToMany(targetEntity: JournalNews::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
364.     #[ORM\OrderBy(['ord' => 'desc'])]
365.     private Collection $news;
367.     #[ApiProperty(description: 'Collections')]
368.     #[ORM\OneToMany(targetEntity: JournalCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
369.     #[ORM\OrderBy(['ord' => 'desc'])]
370.     private Collection $collections;
372.     #[ApiProperty(description: 'Sort article by ord')]
373.     #[Groups(['read:' . self::class, 'write'])]
374.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
375.     private bool $sortArticlesByOrd = false;
377.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalFooter::class, orphanRemoval: true)]
378.     private Collection $smallFooters;
380.     #[ApiProperty(description: 'Statistics: earliest article publication date')]
381.     #[Groups(['read:stats'])]
382.     private ?\DateTimeImmutable $statsEarliestArticlePublicationDate = null;
384.     #[ApiProperty(description: 'Statistics: latest article publication date')]
385.     #[Groups(['read:stats'])]
386.     private ?\DateTimeImmutable $statsLatestArticlePublicationDate = null;
388.     #[ApiProperty(description: 'Statistics: amount of views')]
389.     #[Groups(['read:stats'])]
390.     private int $statsAmountOfArticles = 0;
392.     #[ApiProperty(description: 'Statistics: amount of views')]
393.     #[Groups(['read:stats'])]
394.     private int $statsAmountOfIssues = 0;
396.     #[ApiProperty(description: 'Statistics: amount of views')]
397.     #[Groups(['read:stats'])]
398.     private int $statsAmountOfVolumes = 0;
400.     #[ApiProperty(description: 'Statistics: amount of views')]
401.     #[Groups(['read:stats'])]
402.     private int $statsAmountOfViews = 0;
404.     #[ApiProperty(description: 'Statistics: amount of downloads')]
405.     #[Groups(['read:stats'])]
406.     private int $statsAmountOfDownloads = 0;
408.     public function __construct(Admin $createdBy, ?array $languages)
409.     {
410.         $this->setUuid();
412.         $this->data = new JournalData($this);
413.         $this->view = new JournalView($this);
415.         $this->createdBy = $createdBy;
416.         $this->updatedBy = $createdBy;
418.         $this->translations = new ArrayCollection();
420.         $this->domains = new ArrayCollection();
421.         $this->indexationCollections = new ArrayCollection();
422.         $this->indicators = new ArrayCollection();
424.         $this->affiliations = new ArrayCollection();
425.         $this->publishers = new ArrayCollection();
426.         $this->partners = new ArrayCollection();
428.         $this->slides = new ArrayCollection();
429.         $this->editorialGroups = new ArrayCollection();
430.         $this->scientificCouncilMembers = new ArrayCollection();
431.         $this->sections = new ArrayCollection();
433.         $this->menuItems = new ArrayCollection();
434.         $this->submenuGroups = new ArrayCollection();
435.         $this->sidemenuGroups = new ArrayCollection();
436.         $this->banners = new ArrayCollection();
438.         $this->volumes = new ArrayCollection();
439.         $this->issues = new ArrayCollection();
440.         $this->articles = new ArrayCollection();
442.         $this->pages = new ArrayCollection();
443.         $this->news = new ArrayCollection();
445.         $this->collections = new ArrayCollection();
447.         $this->setLanguages($languages ?? Language::DEFAULT_JOURNAL);
449.         foreach (array_reverse(JournalDefaultPage::cases()) as $index => $idName) {
450.             new JournalPage(
451.                 parent: $this,
452.                 workingTitle: $idName->value,
453.                 idName: $idName->value,
454.                 ord: $index + 1,
455.                 stat: true
456.             );
457.         }
459.         $this->createdAt = new \DateTimeImmutable();
460.         $this->updatedAt = new \DateTimeImmutable();
461.         $this->smallFooters = new ArrayCollection();
462.     }
464.     public function getTitle(): string
465.     {
466.         return $this->data->getWorkingTitle();
467.     }
469.     public function setNativeTitleSortKey(string $nativeTitleSortKey): self
470.     {
471.         $this->nativeTitleSortKey = $nativeTitleSortKey;
473.         return $this;
474.     }
476.     public function getNativeTitleSortKey(): ?string
477.     {
478.         return $this->nativeTitleSortKey;
479.     }
481.     public function getData(): JournalData
482.     {
483.         return $this->data;
484.     }
486.     public function getView(): JournalView
487.     {
488.         return $this->view;
489.     }
491.     public function getCover(Language $lang): ?Media
492.     {
493.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
494.             return $this->readAvailableTranslation($lang, 'cover');
495.         }
497.         if ($cover = $this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
498.             return $cover;
499.         }
501.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
502.             ? $this->readAvailableTranslation($lang, 'cover')
503.             : null;
504.     }
506.     public function getCoverAlt(Language $lang): ?string
507.     {
508.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
509.             return $this->readAvailableTranslation($lang, 'coverAlt');
510.         }
512.         if ($this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
513.             return $this->getNewestIssue()?->readAvailableTranslation($lang, 'coverAlt');
514.         }
516.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
517.             ? $this->readAvailableTranslation($lang, 'coverAlt')
518.             : null;
519.     }
521.     public function getNewestNewIssue(): ?JournalIssue
522.     {
523.         return $this->newestNewIssue;
524.     }
526.     public function setNewestNewIssue(?JournalIssue $newestNewIssue): self
527.     {
528.         $this->newestNewIssue = $newestNewIssue;
530.         return $this;
531.     }
533.     public function getNewestIssue(): ?JournalIssue
534.     {
535.         foreach ($this->getIssues() as $issue) {
536.             if ($issue->getStat() && $issue->getIsNewestIssue()) {
537.                 return $issue;
538.             }
539.         }
541.         return null;
542.     }
544.     public function getSlug(): ?string
545.     {
546.         return $this->slug;
547.     }
549.     public function setSlug(?string $slug): self
550.     {
551.         $this->slug = $slug;
553.         return $this;
554.     }
556.     public function getImportSlug(): ?string
557.     {
558.         return $this->importSlug;
559.     }
561.     public function setImportSlug(?string $importSlug): self
562.     {
563.         $this->importSlug = $importSlug;
565.         return $this;
566.     }
568.     public function getImportSlugEn(): ?string
569.     {
570.         return $this->importSlugEn;
571.     }
573.     public function setImportSlugEn(?string $importSlugEn): self
574.     {
575.         $this->importSlugEn = $importSlugEn;
577.         return $this;
578.     }
580.     public function getCreatedBy(): Admin
581.     {
582.         return $this->createdBy;
583.     }
585.     public function getUpdatedBy(): Admin
586.     {
587.         return $this->updatedBy;
588.     }
590.     public function setUpdatedBy(Admin $updatedBy): self
591.     {
592.         $this->updatedBy = $updatedBy;
594.         return $this;
595.     }
597.     /**
598.      * @return Collection|JournalScientificCouncilMember[]
599.      */
600.     public function getScientificCouncilMembers(): Collection
601.     {
602.         return $this->scientificCouncilMembers;
603.     }
605.     public function addScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
606.     {
607.         if ($this->scientificCouncilMembers->contains($scientificCouncilMember)) {
608.             return $this;
609.         }
611.         $this->scientificCouncilMembers[] = $scientificCouncilMember;
613.         return $this;
614.     }
616.     public function removeScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
617.     {
618.         $this->scientificCouncilMembers->removeElement($scientificCouncilMember);
620.         return $this;
621.     }
623.     public function resetScientificCouncilMembers(): self
624.     {
625.         $this->scientificCouncilMembers = new ArrayCollection();
627.         return $this;
628.     }
630.     /**
631.      * @return Collection|JournalDomain[]
632.      */
633.     public function getDomains(): Collection
634.     {
635.         return $this->domains;
636.     }
638.     public function addDomain(JournalDomain $domain): self
639.     {
640.         if ($this->domains->contains($domain)) {
641.             return $this;
642.         }
644.         $this->domains[] = $domain;
646.         return $this;
647.     }
649.     public function removeDomain(JournalDomain $domain): self
650.     {
651.         $this->domains->removeElement($domain);
653.         return $this;
654.     }
656.     public function resetDomains(): self
657.     {
658.         $this->domains = new ArrayCollection();
660.         return $this;
661.     }
663.     /**
664.      * @return Collection|JournalIndexationCollection[]
665.      */
666.     public function getIndexationCollections(): Collection
667.     {
668.         return $this->indexationCollections;
669.     }
671.     public function addIndexationCollection(JournalIndexationCollection $indexationCollection): self
672.     {
673.         if ($this->indexationCollections->contains($indexationCollection)) {
674.             return $this;
675.         }
677.         $this->indexationCollections[] = $indexationCollection;
679.         return $this;
680.     }
682.     public function removeIndexationCollection(JournalIndexationCollection $indexationCollection): self
683.     {
684.         $this->indexationCollections->removeElement($indexationCollection);
686.         return $this;
687.     }
689.     public function resetIndexationCollections(): self
690.     {
691.         $this->indexationCollections = new ArrayCollection();
693.         return $this;
694.     }
696.     /**
697.      * @return Collection|JournalIndicator[]
698.      */
699.     public function getIndicators(): Collection
700.     {
701.         return $this->indicators;
702.     }
704.     public function addIndicator(JournalIndicator $indicator): self
705.     {
706.         if ($this->indicators->contains($indicator)) {
707.             return $this;
708.         }
710.         $this->indicators[] = $indicator;
712.         return $this;
713.     }
715.     public function removeIndicator(JournalIndicator $indicator): self
716.     {
717.         $this->indicators->removeElement($indicator);
719.         return $this;
720.     }
722.     public function resetIndicators(): self
723.     {
724.         $this->indicators = new ArrayCollection();
726.         return $this;
727.     }
729.     /**
730.      * @return Collection|JournalAffiliation[]
731.      */
732.     public function getAffiliations(): Collection
733.     {
734.         return $this->affiliations;
735.     }
737.     public function addAffiliation(JournalAffiliation $affiliation): self
738.     {
739.         if ($this->affiliations->contains($affiliation)) {
740.             return $this;
741.         }
743.         $this->affiliations[] = $affiliation;
745.         return $this;
746.     }
748.     public function removeAffiliation(JournalAffiliation $affiliation): self
749.     {
750.         $this->affiliations->removeElement($affiliation);
752.         return $this;
753.     }
755.     public function resetAffiliations(): self
756.     {
757.         $this->affiliations = new ArrayCollection();
759.         return $this;
760.     }
762.     /**
763.      * @return Collection|JournalPublisher[]
764.      */
765.     public function getPublishers(): Collection
766.     {
767.         return $this->publishers;
768.     }
770.     public function addPublisher(JournalPublisher $publisher): self
771.     {
772.         if ($this->publishers->contains($publisher)) {
773.             return $this;
774.         }
776.         $this->publishers[] = $publisher;
778.         return $this;
779.     }
781.     public function removePublisher(JournalPublisher $publisher): self
782.     {
783.         $this->publishers->removeElement($publisher);
785.         return $this;
786.     }
788.     public function resetPublishers(): self
789.     {
790.         $this->publishers = new ArrayCollection();
792.         return $this;
793.     }
795.     public function getVisiblePublishers(): Collection
796.     {
797.         return $this->publishers->filter(
798.             fn (JournalPublisher $publisher) =>
799.             $publisher->getStat() === true &&
800.                 $publisher->getPublisher()->getStat() === true
801.         );
802.     }
804.     /**
805.      * @return Collection|JournalPartner[]
806.      */
807.     public function getPartners(): Collection
808.     {
809.         return $this->partners;
810.     }
812.     public function addPartner(JournalPartner $partner): self
813.     {
814.         if ($this->partners->contains($partner)) {
815.             return $this;
816.         }
818.         $this->partners[] = $partner;
820.         return $this;
821.     }
823.     public function removePartner(JournalPartner $partner): self
824.     {
825.         $this->partners->removeElement($partner);
827.         return $this;
828.     }
830.     public function resetPartners(): self
831.     {
832.         $this->partners = new ArrayCollection();
834.         return $this;
835.     }
837.     /**
838.      * @return Collection|JournalSlide[]
839.      */
840.     public function getSlides(): Collection
841.     {
842.         return $this->slides;
843.     }
845.     public function addSlide(JournalSlide $slide): self
846.     {
847.         if ($this->slides->contains($slide)) {
848.             return $this;
849.         }
851.         $this->slides[] = $slide;
853.         return $this;
854.     }
856.     public function removeSlide(JournalSlide $slide): self
857.     {
858.         $this->slides->removeElement($slide);
860.         return $this;
861.     }
863.     public function resetSlides(): self
864.     {
865.         $this->slides = new ArrayCollection();
867.         return $this;
868.     }
870.     /**
871.      * @return Collection|JournalSection[]
872.      */
873.     public function getSections(): Collection
874.     {
875.         return $this->sections;
876.     }
878.     public function addSection(JournalSection $section): self
879.     {
880.         if ($this->sections->contains($section)) {
881.             return $this;
882.         }
884.         $this->sections[] = $section;
886.         return $this;
887.     }
889.     public function removeSection(JournalSection $section): self
890.     {
891.         $this->sections->removeElement($section);
893.         return $this;
894.     }
896.     public function resetSections(): self
897.     {
898.         $this->sections = new ArrayCollection();
900.         return $this;
901.     }
903.     /**
904.      * @return Collection|JournalMenuItem[]
905.      */
906.     public function getMenuItems(): Collection
907.     {
908.         return $this->menuItems;
909.     }
911.     public function addMenuItem(JournalMenuItem $menuItem): self
912.     {
913.         if ($this->menuItems->contains($menuItem)) {
914.             return $this;
915.         }
917.         $this->menuItems[] = $menuItem;
919.         return $this;
920.     }
922.     public function removeMenuItem(JournalMenuItem $menuItem): self
923.     {
924.         $this->menuItems->removeElement($menuItem);
926.         return $this;
927.     }
929.     public function resetMenuItems(): self
930.     {
931.         $this->menuItems = new ArrayCollection();
933.         return $this;
934.     }
936.     /**
937.      * @return Collection|JournalSubmenuGroup[]
938.      */
939.     public function getSubmenuGroups(): Collection
940.     {
941.         return $this->submenuGroups;
942.     }
944.     public function addSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
945.     {
946.         if ($this->submenuGroups->contains($submenuGroup)) {
947.             return $this;
948.         }
950.         $this->submenuGroups[] = $submenuGroup;
952.         return $this;
953.     }
955.     public function removeSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
956.     {
957.         $this->submenuGroups->removeElement($submenuGroup);
959.         return $this;
960.     }
962.     public function resetSubmenuGroups(): self
963.     {
964.         $this->submenuGroups = new ArrayCollection();
966.         return $this;
967.     }
969.     /**
970.      * @return Collection|JournalSidemenuGroup[]
971.      */
972.     public function getSidemenuGroups(): Collection
973.     {
974.         return $this->sidemenuGroups;
975.     }
977.     public function addSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
978.     {
979.         if ($this->sidemenuGroups->contains($sidemenuGroup)) {
980.             return $this;
981.         }
983.         $this->sidemenuGroups[] = $sidemenuGroup;
985.         return $this;
986.     }
988.     public function removeSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
989.     {
990.         $this->sidemenuGroups->removeElement($sidemenuGroup);
992.         return $this;
993.     }
995.     public function resetSidemenuGroups(): self
996.     {
997.         $this->sidemenuGroups = new ArrayCollection();
999.         return $this;
1000.     }
1002.     /**
1003.      * @return Collection|JournalBanner[]
1004.      */
1005.     public function getBanners(): Collection
1006.     {
1007.         return $this->banners;
1008.     }
1010.     public function addBanner(JournalBanner $banner): self
1011.     {
1012.         if ($this->banners->contains($banner)) {
1013.             return $this;
1014.         }
1016.         $this->banners[] = $banner;
1018.         return $this;
1019.     }
1021.     public function removeBanner(JournalBanner $banner): self
1022.     {
1023.         $this->banners->removeElement($banner);
1025.         return $this;
1026.     }
1028.     public function resetBanners(): self
1029.     {
1030.         $this->banners = new ArrayCollection();
1032.         return $this;
1033.     }
1035.     /**
1036.      * @return Collection|JournalVolume[]
1037.      */
1038.     public function getVolumes(): Collection
1039.     {
1040.         return $this->volumes;
1041.     }
1043.     public function addVolume(JournalVolume $volume): self
1044.     {
1045.         if ($this->volumes->contains($volume)) {
1046.             return $this;
1047.         }
1049.         $this->volumes[] = $volume;
1051.         return $this;
1052.     }
1054.     public function removeVolume(JournalVolume $volume): self
1055.     {
1056.         $this->volumes->removeElement($volume);
1058.         return $this;
1059.     }
1061.     public function resetVolumes(): self
1062.     {
1063.         $this->volumes = new ArrayCollection();
1065.         return $this;
1066.     }
1068.     /**
1069.      * @return Collection<int, JournalIssue>
1070.      */
1071.     public function getIssues(): Collection
1072.     {
1073.         return $this->issues;
1074.     }
1076.     /**
1077.      * @return Collection<int, JournalIssue>
1078.      */
1079.     public function getVisibleIssues(): Collection
1080.     {
1081.         return $this->issues->filter(fn (JournalIssue $issue) => $issue->getStat());
1082.     }
1084.     public function addIssue(JournalIssue $issue): self
1085.     {
1086.         if ($this->issues->contains($issue)) {
1087.             return $this;
1088.         }
1090.         $this->issues[] = $issue;
1092.         return $this;
1093.     }
1095.     public function removeIssue(JournalIssue $issue): self
1096.     {
1097.         $this->issues->removeElement($issue);
1099.         return $this;
1100.     }
1102.     public function resetIssues(): self
1103.     {
1104.         $this->issues = new ArrayCollection();
1106.         return $this;
1107.     }
1109.     public function getOldestIssue(): ?JournalIssue
1110.     {
1111.         $filtered = new ArrayCollection();
1113.         foreach ($this->getIssues() as $issue) {
1114.             if ($issue->getStat() && $issue->getPublishedAt()) {
1115.                 $filtered->add($issue);
1116.             }
1117.         }
1119.         if (count($filtered) === 0) {
1120.             return null;
1121.         }
1123.         $criteria = Criteria::create()->orderBy(['publishedAt' => Criteria::ASC]);
1125.         return $filtered
1126.             ->matching($criteria)
1127.             ->first();
1128.     }
1130.     /**
1131.      * @return Collection|JournalArticle[]
1132.      */
1133.     public function getArticles(): Collection
1134.     {
1135.         return $this->articles;
1136.     }
1138.     /**
1139.      * @return Collection<int, JournalArticle>
1140.      */
1141.     public function getArticlesVisible(): Collection
1142.     {
1143.         return $this->articles->filter(fn (JournalArticle $article) => $article->getStat());
1144.     }
1146.     public function addArticle(JournalArticle $article): self
1147.     {
1148.         if ($this->articles->contains($article)) {
1149.             return $this;
1150.         }
1152.         $this->articles[] = $article;
1154.         return $this;
1155.     }
1157.     public function removeArticle(JournalArticle $article): self
1158.     {
1159.         $this->articles->removeElement($article);
1161.         return $this;
1162.     }
1164.     public function resetArticles(): self
1165.     {
1166.         $this->articles = new ArrayCollection();
1168.         return $this;
1169.     }
1171.     /**
1172.      * @return Collection|JournalPage[]
1173.      */
1174.     public function getPages(): Collection
1175.     {
1176.         return $this->pages;
1177.     }
1179.     public function addPage(JournalPage $page): self
1180.     {
1181.         if ($this->pages->contains($page)) {
1182.             return $this;
1183.         }
1185.         $this->pages[] = $page;
1187.         return $this;
1188.     }
1190.     public function removePage(JournalPage $page): self
1191.     {
1192.         $this->pages->removeElement($page);
1194.         return $this;
1195.     }
1197.     public function resetPages(): self
1198.     {
1199.         $this->pages = new ArrayCollection();
1201.         return $this;
1202.     }
1204.     /**
1205.      * @return Collection|JournalNews[]
1206.      */
1207.     public function getNews(): Collection
1208.     {
1209.         return $this->news;
1210.     }
1212.     public function addNews(JournalNews $news): self
1213.     {
1214.         if ($this->news->contains($news)) {
1215.             return $this;
1216.         }
1218.         $this->news[] = $news;
1220.         return $this;
1221.     }
1223.     public function removeNews(JournalNews $news): self
1224.     {
1225.         $this->news->removeElement($news);
1227.         return $this;
1228.     }
1230.     public function resetNews(): self
1231.     {
1232.         $this->news = new ArrayCollection();
1234.         return $this;
1235.     }
1237.     /**
1238.      * @return Collection|JournalCollection[]
1239.      */
1240.     public function getCollections(): Collection
1241.     {
1242.         return $this->collections;
1243.     }
1245.     public function addCollection(JournalCollection $collection): self
1246.     {
1247.         if ($this->collections->contains($collection)) {
1248.             return $this;
1249.         }
1251.         $this->collections[] = $collection;
1253.         return $this;
1254.     }
1256.     public function removeCollection(JournalCollection $news): self
1257.     {
1258.         $this->news->removeElement($news);
1260.         return $this;
1261.     }
1263.     public function resetCollections(): self
1264.     {
1265.         $this->collections = new ArrayCollection();
1267.         return $this;
1268.     }
1270.     public function clone(Admin $createdBy = null): self
1271.     {
1272.         $clone = clone $this;
1274.         $clone->id = null;
1275.         $clone->setUuid();
1277.         $clone->ord = 0;
1278.         $clone->stat = false;
1279.         $clone->importId = null;
1281.         $clone->data = $this->data->clone($clone);
1282.         $clone->view = $this->view->clone($clone);
1284.         $nativeLanguage = $clone->getNativeLanguage();
1285.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
1286.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
1288.         ClassUtils::cloneCollection($this, $clone, 'translations');
1290.         $clone
1291.             ->resetDomains()
1292.             ->resetIndexationCollections()
1293.             ->resetIndicators()
1294.             ->resetAffiliations()
1295.             ->resetPublishers()
1296.             ->resetPartners()
1297.             ->resetSlides()
1298.             ->resetSections()
1299.             ->resetMenuItems()
1300.             ->resetSubmenuGroups()
1301.             ->resetBanners()
1302.             ->resetVolumes()
1303.             ->resetIssues()
1304.             ->resetArticles()
1305.             ->resetPages()
1306.             ->resetNews()
1307.             ->resetCollections()
1308.             ->resetEditorialGroups()
1309.             ->resetScientificCouncilMembers();
1311.         $clone->createdBy = $createdBy ?? $clone->createdBy;
1312.         $clone->updatedBy = $createdBy ?? $clone->updatedBy;
1314.         $clone->createdAt = new \DateTimeImmutable();
1315.         $clone->updatedAt = new \DateTimeImmutable();
1317.         return $clone;
1318.     }
1320.     public function isSortArticlesByOrd(): bool
1321.     {
1322.         return $this->sortArticlesByOrd;
1323.     }
1325.     public function setSortArticlesByOrd(bool $sortArticlesByOrd): self
1326.     {
1327.         $this->sortArticlesByOrd = $sortArticlesByOrd;
1329.         return $this;
1330.     }
1332.     /**
1333.      * @return Collection<int, JournalFooter>
1334.      */
1335.     public function getSmallFooters(): Collection
1336.     {
1337.         return $this->smallFooters;
1338.     }
1340.     public function addSmallFooter(JournalFooter $smallFooter): self
1341.     {
1342.         if (!$this->smallFooters->contains($smallFooter)) {
1343.             $this->smallFooters->add($smallFooter);
1344.             $smallFooter->setParent($this);
1345.         }
1347.         return $this;
1348.     }
1350.     public function removeSmallFooter(JournalFooter $smallFooter): self
1351.     {
1352.         if ($this->smallFooters->removeElement($smallFooter)) {
1353.             // set the owning side to null (unless already changed)
1354.             if ($smallFooter->getParent() === $this) {
1355.                 $smallFooter->setParent(null);
1356.             }
1357.         }
1359.         return $this;
1360.     }
1362.     public function getVisibleSmallFooters(): Collection
1363.     {
1364.         return $this->smallFooters->filter(fn (JournalFooter $smallFooter) => $smallFooter->getStat());
1365.     }
1367.     public function getStatsAmountOfArticles(): int
1368.     {
1369.         return $this->statsAmountOfArticles;
1370.     }
1372.     public function setStatsAmountOfArticles(int $statsAmountOfArticles): self
1373.     {
1374.         $this->statsAmountOfArticles = $statsAmountOfArticles;
1376.         return $this;
1377.     }
1379.     public function getStatsAmountOfIssues(): int
1380.     {
1381.         return $this->statsAmountOfIssues;
1382.     }
1384.     public function setStatsAmountOfIssues(int $statsAmountOfIssues): self
1385.     {
1386.         $this->statsAmountOfIssues = $statsAmountOfIssues;
1388.         return $this;
1389.     }
1391.     public function getStatsAmountOfVolumes(): int
1392.     {
1393.         return $this->statsAmountOfVolumes;
1394.     }
1396.     public function setStatsAmountOfVolumes(int $statsAmountOfVolumes): self
1397.     {
1398.         $this->statsAmountOfVolumes = $statsAmountOfVolumes;
1400.         return $this;
1401.     }
1403.     public function getStatsAmountOfViews(): int
1404.     {
1405.         return $this->statsAmountOfViews;
1406.     }
1408.     public function setStatsAmountOfViews(int $statsAmountOfViews): self
1409.     {
1410.         $this->statsAmountOfViews = $statsAmountOfViews;
1412.         return $this;
1413.     }
1415.     public function getStatsAmountOfDownloads(): int
1416.     {
1417.         return $this->statsAmountOfDownloads;
1418.     }
1420.     public function setStatsAmountOfDownloads(int $statsAmountOfDownloads): self
1421.     {
1422.         $this->statsAmountOfDownloads = $statsAmountOfDownloads;
1424.         return $this;
1425.     }
1427.     public function getStatsEarliestArticlePublicationDate(): ?\DateTimeImmutable
1428.     {
1429.         return $this->statsEarliestArticlePublicationDate;
1430.     }
1432.     public function setStatsEarliestArticlePublicationDate(?string $statsEarliestArticlePublicationDate): self
1433.     {
1434.         if (!$statsEarliestArticlePublicationDate) {
1435.             return $this;
1436.         }
1438.         $this->statsEarliestArticlePublicationDate = new \DateTimeImmutable($statsEarliestArticlePublicationDate);
1440.         return $this;
1441.     }
1443.     public function getStatsLatestArticlePublicationDate(): ?\DateTimeImmutable
1444.     {
1445.         return $this->statsLatestArticlePublicationDate;
1446.     }
1448.     public function setStatsLatestArticlePublicationDate(?string $statsLatestArticlePublicationDate): self
1449.     {
1450.         if (!$statsLatestArticlePublicationDate) {
1451.             return $this;
1452.         }
1454.         $this->statsLatestArticlePublicationDate = new \DateTimeImmutable($statsLatestArticlePublicationDate);
1456.         return $this;
1457.     }
1459.     #[Groups(['read:stats'])]
1460.     public function getStatsAffiliations(): ?string
1461.     {
1462.         $affiliations = [];
1464.         /** @var JournalAffiliation */
1465.         foreach ($this->affiliations as $entry) {
1466.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
1467.                 continue;
1468.             }
1470.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
1471.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
1472.         }
1474.         sort($affiliations);
1476.         return implode(', ',  $affiliations);
1477.     }
1479.     #[Groups(['read:stats'])]
1480.     public function getStatsAffiliationTypes(): ?string
1481.     {
1482.         $types = [];
1484.         /** @var JournalAffiliation */
1485.         foreach ($this->affiliations as $entry) {
1486.             if (!($type = $entry->getAffiliation()?->getType())) {
1487.                 continue;
1488.             }
1490.             if (isset($types[$type->getUuid()->toString()])) {
1491.                 continue;
1492.             }
1494.             $types[$type->getUuid()->toString()] = $type->getTitle();
1495.         }
1497.         sort($types);
1499.         return implode(', ',  $types);
1500.     }
1502.     #[Groups(['read:stats'])]
1503.     public function getStatsDomains(): ?string
1504.     {
1505.         $domains = [];
1507.         /** @var JournalDomain */
1508.         foreach ($this->domains as $entry) {
1509.             if (isset($domains[$entry->getDomain()->getUuid()->toString()])) {
1510.                 continue;
1511.             }
1513.             $domains[$entry->getDomain()->getUuid()->toString()] =
1514.                 $entry->getDomain()->readNativeLanguageTranslation('title');
1515.         }
1517.         sort($domains);
1519.         return implode(', ',  $domains);
1520.     }
1522.     #[Groups(['read:stats'])]
1523.     public function getStatsType(): ?string
1524.     {
1525.         return $this->data->getType()?->getTitle();
1526.     }
1528.     #[Groups(['read:stats'])]
1529.     public function getStatsState(): ?string
1530.     {
1531.         return $this->data->getState()?->getTitle();
1532.     }
1533. }