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;
66. use App\Controller\Export\Journal\JournalMainDataExporter;
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 Get(
137.             name: 'get_journal_main_data',
138.             uriTemplate: '/journals/{uuid}/export/main_data',
139.             controller: JournalMainDataExporter::class
140.         ),
141.         new Put(),
142.         new Delete(
143.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
144.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
145.         ),
146.     ],
147.     extraProperties: ['standard_put' => false],
148. )]
149. #[ApiFilter(SearchFilter::class, properties: [
150.     'translations.title' => 'partial',
151.     'nativeTitle' => 'partial',
152.     'nativeLanguage' => 'partial',
153.     'data.workingTitle' => 'partial',
154.     'data.issn' => 'exact',
155.     'data.eIssn' => 'exact',
156.     'data.state' => 'exact',
157.     'data.type' => 'exact',
158.     'domains.domain.nativeTitle' => 'partial',
159.     'affiliations.affiliation.nativeTitle' => 'partial',
160.     'affiliations.affiliation.type.title' => 'partial'
161. ])]
162. #[ApiFilter(RangeFilter::class, properties: ['data.meinScore'])]
163. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
164. #[ApiFilter(IriFilter::class, properties: [
165.     'nativeLanguage',
166.     'domains.domain',
167.     'affiliations.affiliation',
168.     'data.periodicity',
169.     'data.type',
170.     'data.licence',
171.     'data.state'
172. ])]
173. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
174. #[ApiFilter(OrderFilter::class, properties: [
175.     'nativeTitle',
176.     'nativeLanguage',
177.     'data.type',
178.     'data.state',
179.     'affiliations.affiliation.nativeTitle',
180.     'affiliations.affiliation.type.title',
181.     'domains.domain.nativeTitle',
182.     'data.workingTitle',
183.     'data.periodicity',
184.     'updatedAt',
185.     'stat',
186.     'ord'
187. ])]
188. #[ApiFilter(OrderByUnmapped::class, properties: [
189.     'statsEarliestArticlePublicationDate',
190.     'statsLatestArticlePublicationDate',
191.     'statsAmountOfArticles',
192.     'statsAmountOfArticles',
193.     'statsAmountOfIssues',
194.     'statsAmountOfVolumes',
195.     'statsAmountOfViews',
196.     'statsAmountOfDownloads'
197. ])]
198. #[ApiFilter(RangeUnmapped::class, properties: [
199.     'statsAmountOfVolumes',
200.     'statsAmountOfIssues',
201.     'statsAmountOfArticles',
202.     'statsAmountOfViews',
203.     'statsAmountOfDownloads'
204. ])]
205. #[ApiFilter(DateUnmapped::class, properties: ['statsEarliestArticlePublicationDate','statsLatestArticlePublicationDate'])]
206. #[Index(fields: ["nativeLanguage"], name: "native_language_idx")]
207. #[Index(fields: ["stat"], name: "stat_idx")]
208. #[ORM\Entity(repositoryClass: JournalRepository::class)]
209. class Journal implements
210.     TranslatableInterface,
211.     OrdStatableInterface,
212.     LanguageableInterface,
213.     EditorialGroupableInterface,
214.     ArchivableInterface,
215.     OwnerableInterface,
216.     CloneableInterface
217. {
218.     use IdTrait,
219.         UuidTrait,
220.         OrdStatTrait,
221.         TimestampableTrait,
222.         TranslatableTrait,
223.         JournalLanguagesTrait,
224.         ArchivedTrait,
225.         EditorialGroupableTrait,
226.         ImportIdTrait;
228.     #[ApiProperty(description: 'Native title sort key')]
229.     #[Groups(['read:' . self::class, 'read:stats'])]
230.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
231.     private ?string $nativeTitleSortKey = null;
233.     #[ApiProperty(description: 'Data subresource', writable: true)]
234.     #[Groups(['read:' . self::class, 'read:list', 'write'])]
235.     #[Assert\Valid]
236.     #[DenormalizationInject(method: ['name' => 'getData'])]
237.     #[ORM\OneToOne(targetEntity: JournalData::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
238.     private JournalData $data;
240.     #[ApiProperty(description: 'View subresource', writable: true)]
241.     #[Groups(['read:' . self::class, 'write'])]
242.     #[Assert\Valid]
243.     #[DenormalizationInject(method: ['name' => 'getView'])]
244.     #[ORM\OneToOne(targetEntity: JournalView::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
245.     private JournalView $view;
247.     #[ApiProperty(description: 'Newest new issue', writable: true)]
248.     #[ORM\OneToOne(targetEntity: JournalIssue::class)]
249.     #[ORM\JoinColumn(onDelete: 'set null', nullable: true)]
250.     private ?JournalIssue $newestNewIssue = null;
252.     #[ApiProperty(description: 'Slug')]
253.     #[Groups(['read:' . self::class, 'write'])]
254.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitle'])]
255.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
256.     private ?string $slug = null;
258.     #[ApiProperty(description: 'Slug')]
259.     #[Groups(['read:' . self::class, 'write'])]
260.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
261.     private ?string $importSlug = null;
263.     #[ApiProperty(description: 'Slug')]
264.     #[Groups(['read:' . self::class, 'write'])]
265.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
266.     private ?string $importSlugEn = null;
268.     #[ApiProperty(description: 'Created by')]
269.     #[Groups(['read:' . self::class])]
270.     #[ORM\ManyToOne(targetEntity: Admin::class, inversedBy: 'journals')]
271.     #[ORM\JoinColumn(onDelete: 'set null')]
272.     private Admin $createdBy;
274.     #[ApiProperty(description: 'Updated by')]
275.     #[Groups(['read:' . self::class])]
276.     #[ORM\ManyToOne(targetEntity: Admin::class)]
277.     #[ORM\JoinColumn(onDelete: 'set null')]
278.     private Admin $updatedBy;
280.     #[ApiProperty(description: 'Scientific council members', writableLink: false)]
281.     #[ORM\OneToMany(targetEntity: JournalScientificCouncilMember::class, mappedBy: 'parent', cascade: ['persist'])]
282.     #[ORM\OrderBy(['ord' => 'desc'])]
283.     private Collection $scientificCouncilMembers;
285.     #[ApiProperty(description: 'Domains', fetchEager: false)]
286.     #[Groups(['read', 'read:list'])]
287.     #[ORM\OneToMany(targetEntity: JournalDomain::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
288.     #[ORM\OrderBy(['ord' => 'desc'])]
289.     private Collection $domains;
291.     #[ApiProperty(description: 'Indexation collections')]
292.     #[ORM\OneToMany(targetEntity: JournalIndexationCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
293.     #[ORM\OrderBy(['ord' => 'desc'])]
294.     private Collection $indexationCollections;
296.     #[ApiProperty(description: 'Indicators')]
297.     #[ORM\OneToMany(targetEntity: JournalIndicator::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
298.     #[ORM\OrderBy(['ord' => 'desc'])]
299.     private Collection $indicators;
301.     #[ApiProperty(description: 'Affiliations', fetchEager: false)]
302.     #[Groups(['read', 'read:list'])]
303.     #[ORM\OneToMany(targetEntity: JournalAffiliation::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
304.     #[ORM\OrderBy(['ord' => 'desc'])]
305.     private Collection $affiliations;
307.     #[ApiProperty(description: 'Publishers')]
308.     #[ORM\OneToMany(targetEntity: JournalPublisher::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
309.     #[ORM\OrderBy(['ord' => 'desc'])]
310.     private Collection $publishers;
312.     #[ApiProperty(description: 'Partners')]
313.     #[ORM\OneToMany(targetEntity: JournalPartner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
314.     #[ORM\OrderBy(['ord' => 'desc'])]
315.     private Collection $partners;
317.     #[ApiProperty(description: 'Slides')]
318.     #[ORM\OneToMany(targetEntity: JournalSlide::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
319.     #[ORM\OrderBy(['ord' => 'desc'])]
320.     private Collection $slides;
322.     #[ApiProperty(description: 'Sections')]
323.     #[ORM\OneToMany(targetEntity: JournalSection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
324.     #[ORM\OrderBy(['ord' => 'desc'])]
325.     private Collection $sections;
327.     #[ApiProperty(description: 'Menu items')]
328.     #[ORM\OneToMany(targetEntity: JournalMenuItem::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
329.     #[ORM\OrderBy(['ord' => 'desc'])]
330.     private Collection $menuItems;
332.     #[ApiProperty(description: 'Submenu groups')]
333.     #[ORM\OneToMany(targetEntity: JournalSubmenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
334.     #[ORM\OrderBy(['ord' => 'desc'])]
335.     private Collection $submenuGroups;
337.     #[ApiProperty(description: 'Sidemenu groups')]
338.     #[ORM\OneToMany(targetEntity: JournalSidemenuGroup::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
339.     #[ORM\OrderBy(['ord' => 'desc'])]
340.     private Collection $sidemenuGroups;
342.     #[ApiProperty(description: 'Banners')]
343.     #[ORM\OneToMany(targetEntity: JournalBanner::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
344.     #[ORM\OrderBy(['ord' => 'desc'])]
345.     private Collection $banners;
347.     #[ApiProperty(description: 'Volumes')]
348.     #[ORM\OneToMany(targetEntity: JournalVolume::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
349.     #[ORM\OrderBy(['ord' => 'desc'])]
350.     private Collection $volumes;
352.     #[ApiProperty(description: 'Issues')]
353.     #[ORM\OneToMany(targetEntity: JournalIssue::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
354.     #[ORM\OrderBy(['ord' => 'desc'])]
355.     private Collection $issues;
357.     #[ApiProperty(description: 'Articles')]
358.     #[ORM\OneToMany(targetEntity: JournalArticle::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
359.     #[ORM\OrderBy(['ord' => 'desc'])]
360.     private Collection $articles;
362.     #[ApiProperty(description: 'Pages')]
363.     #[ORM\OneToMany(targetEntity: JournalPage::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
364.     #[ORM\OrderBy(['ord' => 'desc'])]
365.     private Collection $pages;
367.     #[ApiProperty(description: 'News')]
368.     #[ORM\OneToMany(targetEntity: JournalNews::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
369.     #[ORM\OrderBy(['ord' => 'desc'])]
370.     private Collection $news;
372.     #[ApiProperty(description: 'Collections')]
373.     #[ORM\OneToMany(targetEntity: JournalCollection::class, mappedBy: 'parent', cascade: ['persist', 'remove'])]
374.     #[ORM\OrderBy(['ord' => 'desc'])]
375.     private Collection $collections;
377.     #[ApiProperty(description: 'Sort article by ord')]
378.     #[Groups(['read:' . self::class, 'write'])]
379.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => false])]
380.     private bool $sortArticlesByOrd = false;
382.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalFooter::class, orphanRemoval: true)]
383.     private Collection $smallFooters;
385.     #[ApiProperty(description: 'Statistics: earliest article publication date')]
386.     #[Groups(['read:stats'])]
387.     private ?\DateTimeImmutable $statsEarliestArticlePublicationDate = null;
389.     #[ApiProperty(description: 'Statistics: latest article publication date')]
390.     #[Groups(['read:stats'])]
391.     private ?\DateTimeImmutable $statsLatestArticlePublicationDate = null;
393.     #[ApiProperty(description: 'Statistics: amount of views')]
394.     #[Groups(['read:stats'])]
395.     private int $statsAmountOfArticles = 0;
397.     #[ApiProperty(description: 'Statistics: amount of views')]
398.     #[Groups(['read:stats'])]
399.     private int $statsAmountOfIssues = 0;
401.     #[ApiProperty(description: 'Statistics: amount of views')]
402.     #[Groups(['read:stats'])]
403.     private int $statsAmountOfVolumes = 0;
405.     #[ApiProperty(description: 'Statistics: amount of views')]
406.     #[Groups(['read:stats'])]
407.     private int $statsAmountOfViews = 0;
409.     #[ApiProperty(description: 'Statistics: amount of downloads')]
410.     #[Groups(['read:stats'])]
411.     private int $statsAmountOfDownloads = 0;
413.     public function __construct(Admin $createdBy, ?array $languages)
414.     {
415.         $this->setUuid();
417.         $this->data = new JournalData($this);
418.         $this->view = new JournalView($this);
420.         $this->createdBy = $createdBy;
421.         $this->updatedBy = $createdBy;
423.         $this->translations = new ArrayCollection();
425.         $this->domains = new ArrayCollection();
426.         $this->indexationCollections = new ArrayCollection();
427.         $this->indicators = new ArrayCollection();
429.         $this->affiliations = new ArrayCollection();
430.         $this->publishers = new ArrayCollection();
431.         $this->partners = new ArrayCollection();
433.         $this->slides = new ArrayCollection();
434.         $this->editorialGroups = new ArrayCollection();
435.         $this->scientificCouncilMembers = new ArrayCollection();
436.         $this->sections = new ArrayCollection();
438.         $this->menuItems = new ArrayCollection();
439.         $this->submenuGroups = new ArrayCollection();
440.         $this->sidemenuGroups = new ArrayCollection();
441.         $this->banners = new ArrayCollection();
443.         $this->volumes = new ArrayCollection();
444.         $this->issues = new ArrayCollection();
445.         $this->articles = new ArrayCollection();
447.         $this->pages = new ArrayCollection();
448.         $this->news = new ArrayCollection();
450.         $this->collections = new ArrayCollection();
452.         $this->setLanguages($languages ?? Language::DEFAULT_JOURNAL);
454.         foreach (array_reverse(JournalDefaultPage::cases()) as $index => $idName) {
455.             new JournalPage(
456.                 parent: $this,
457.                 workingTitle: $idName->value,
458.                 idName: $idName->value,
459.                 ord: $index + 1,
460.                 stat: true
461.             );
462.         }
464.         $this->createdAt = new \DateTimeImmutable();
465.         $this->updatedAt = new \DateTimeImmutable();
466.         $this->smallFooters = new ArrayCollection();
467.     }
469.     public function getTitle(): string
470.     {
471.         return $this->data->getWorkingTitle();
472.     }
474.     public function setNativeTitleSortKey(string $nativeTitleSortKey): self
475.     {
476.         $this->nativeTitleSortKey = $nativeTitleSortKey;
478.         return $this;
479.     }
481.     public function getNativeTitleSortKey(): ?string
482.     {
483.         return $this->nativeTitleSortKey;
484.     }
486.     public function getData(): JournalData
487.     {
488.         return $this->data;
489.     }
491.     public function getView(): JournalView
492.     {
493.         return $this->view;
494.     }
496.     public function getCover(Language $lang): ?Media
497.     {
498.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
499.             return $this->readAvailableTranslation($lang, 'cover');
500.         }
502.         if ($cover = $this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
503.             return $cover;
504.         }
506.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
507.             ? $this->readAvailableTranslation($lang, 'cover')
508.             : null;
509.     }
511.     public function getCoverAlt(Language $lang): ?string
512.     {
513.         if ($this->view->getCoverType() === JournalCoverType::CHOSEN) {
514.             return $this->readAvailableTranslation($lang, 'coverAlt');
515.         }
517.         if ($this->getNewestIssue()?->readAvailableTranslation($lang, 'cover')) {
518.             return $this->getNewestIssue()?->readAvailableTranslation($lang, 'coverAlt');
519.         }
521.         return $this->view->getCoverType() === JournalCoverType::CURRENT_ISSUE_OR_CHOSEN
522.             ? $this->readAvailableTranslation($lang, 'coverAlt')
523.             : null;
524.     }
526.     public function getNewestNewIssue(): ?JournalIssue
527.     {
528.         return $this->newestNewIssue;
529.     }
531.     public function setNewestNewIssue(?JournalIssue $newestNewIssue): self
532.     {
533.         $this->newestNewIssue = $newestNewIssue;
535.         return $this;
536.     }
538.     public function getNewestIssue(): ?JournalIssue
539.     {
540.         foreach ($this->getIssues() as $issue) {
541.             if ($issue->getStat() && $issue->getIsNewestIssue()) {
542.                 return $issue;
543.             }
544.         }
546.         return null;
547.     }
549.     public function getSlug(): ?string
550.     {
551.         return $this->slug;
552.     }
554.     public function setSlug(?string $slug): self
555.     {
556.         $this->slug = $slug;
558.         return $this;
559.     }
561.     public function getImportSlug(): ?string
562.     {
563.         return $this->importSlug;
564.     }
566.     public function setImportSlug(?string $importSlug): self
567.     {
568.         $this->importSlug = $importSlug;
570.         return $this;
571.     }
573.     public function getImportSlugEn(): ?string
574.     {
575.         return $this->importSlugEn;
576.     }
578.     public function setImportSlugEn(?string $importSlugEn): self
579.     {
580.         $this->importSlugEn = $importSlugEn;
582.         return $this;
583.     }
585.     public function getCreatedBy(): Admin
586.     {
587.         return $this->createdBy;
588.     }
590.     public function getUpdatedBy(): Admin
591.     {
592.         return $this->updatedBy;
593.     }
595.     public function setUpdatedBy(Admin $updatedBy): self
596.     {
597.         $this->updatedBy = $updatedBy;
599.         return $this;
600.     }
602.     /**
603.      * @return Collection|JournalScientificCouncilMember[]
604.      */
605.     public function getScientificCouncilMembers(): Collection
606.     {
607.         return $this->scientificCouncilMembers;
608.     }
610.     public function addScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
611.     {
612.         if ($this->scientificCouncilMembers->contains($scientificCouncilMember)) {
613.             return $this;
614.         }
616.         $this->scientificCouncilMembers[] = $scientificCouncilMember;
618.         return $this;
619.     }
621.     public function removeScientificCouncilMember(JournalScientificCouncilMember $scientificCouncilMember): self
622.     {
623.         $this->scientificCouncilMembers->removeElement($scientificCouncilMember);
625.         return $this;
626.     }
628.     public function resetScientificCouncilMembers(): self
629.     {
630.         $this->scientificCouncilMembers = new ArrayCollection();
632.         return $this;
633.     }
635.     /**
636.      * @return Collection|JournalDomain[]
637.      */
638.     public function getDomains(): Collection
639.     {
640.         return $this->domains;
641.     }
643.     public function addDomain(JournalDomain $domain): self
644.     {
645.         if ($this->domains->contains($domain)) {
646.             return $this;
647.         }
649.         $this->domains[] = $domain;
651.         return $this;
652.     }
654.     public function removeDomain(JournalDomain $domain): self
655.     {
656.         $this->domains->removeElement($domain);
658.         return $this;
659.     }
661.     public function resetDomains(): self
662.     {
663.         $this->domains = new ArrayCollection();
665.         return $this;
666.     }
668.     /**
669.      * @return Collection|JournalIndexationCollection[]
670.      */
671.     public function getIndexationCollections(): Collection
672.     {
673.         return $this->indexationCollections;
674.     }
676.     public function addIndexationCollection(JournalIndexationCollection $indexationCollection): self
677.     {
678.         if ($this->indexationCollections->contains($indexationCollection)) {
679.             return $this;
680.         }
682.         $this->indexationCollections[] = $indexationCollection;
684.         return $this;
685.     }
687.     public function removeIndexationCollection(JournalIndexationCollection $indexationCollection): self
688.     {
689.         $this->indexationCollections->removeElement($indexationCollection);
691.         return $this;
692.     }
694.     public function resetIndexationCollections(): self
695.     {
696.         $this->indexationCollections = new ArrayCollection();
698.         return $this;
699.     }
701.     /**
702.      * @return Collection|JournalIndicator[]
703.      */
704.     public function getIndicators(): Collection
705.     {
706.         return $this->indicators;
707.     }
709.     public function addIndicator(JournalIndicator $indicator): self
710.     {
711.         if ($this->indicators->contains($indicator)) {
712.             return $this;
713.         }
715.         $this->indicators[] = $indicator;
717.         return $this;
718.     }
720.     public function removeIndicator(JournalIndicator $indicator): self
721.     {
722.         $this->indicators->removeElement($indicator);
724.         return $this;
725.     }
727.     public function resetIndicators(): self
728.     {
729.         $this->indicators = new ArrayCollection();
731.         return $this;
732.     }
734.     /**
735.      * @return Collection|JournalAffiliation[]
736.      */
737.     public function getAffiliations(): Collection
738.     {
739.         return $this->affiliations;
740.     }
742.     public function addAffiliation(JournalAffiliation $affiliation): self
743.     {
744.         if ($this->affiliations->contains($affiliation)) {
745.             return $this;
746.         }
748.         $this->affiliations[] = $affiliation;
750.         return $this;
751.     }
753.     public function removeAffiliation(JournalAffiliation $affiliation): self
754.     {
755.         $this->affiliations->removeElement($affiliation);
757.         return $this;
758.     }
760.     public function resetAffiliations(): self
761.     {
762.         $this->affiliations = new ArrayCollection();
764.         return $this;
765.     }
767.     /**
768.      * @return Collection|JournalPublisher[]
769.      */
770.     public function getPublishers(): Collection
771.     {
772.         return $this->publishers;
773.     }
775.     public function addPublisher(JournalPublisher $publisher): self
776.     {
777.         if ($this->publishers->contains($publisher)) {
778.             return $this;
779.         }
781.         $this->publishers[] = $publisher;
783.         return $this;
784.     }
786.     public function removePublisher(JournalPublisher $publisher): self
787.     {
788.         $this->publishers->removeElement($publisher);
790.         return $this;
791.     }
793.     public function resetPublishers(): self
794.     {
795.         $this->publishers = new ArrayCollection();
797.         return $this;
798.     }
800.     public function getVisiblePublishers(): Collection
801.     {
802.         return $this->publishers->filter(
803.             fn (JournalPublisher $publisher) =>
804.             $publisher->getStat() === true &&
805.                 $publisher->getPublisher()->getStat() === true
806.         );
807.     }
809.     /**
810.      * @return Collection|JournalPartner[]
811.      */
812.     public function getPartners(): Collection
813.     {
814.         return $this->partners;
815.     }
817.     public function addPartner(JournalPartner $partner): self
818.     {
819.         if ($this->partners->contains($partner)) {
820.             return $this;
821.         }
823.         $this->partners[] = $partner;
825.         return $this;
826.     }
828.     public function removePartner(JournalPartner $partner): self
829.     {
830.         $this->partners->removeElement($partner);
832.         return $this;
833.     }
835.     public function resetPartners(): self
836.     {
837.         $this->partners = new ArrayCollection();
839.         return $this;
840.     }
842.     /**
843.      * @return Collection|JournalSlide[]
844.      */
845.     public function getSlides(): Collection
846.     {
847.         return $this->slides;
848.     }
850.     public function addSlide(JournalSlide $slide): self
851.     {
852.         if ($this->slides->contains($slide)) {
853.             return $this;
854.         }
856.         $this->slides[] = $slide;
858.         return $this;
859.     }
861.     public function removeSlide(JournalSlide $slide): self
862.     {
863.         $this->slides->removeElement($slide);
865.         return $this;
866.     }
868.     public function resetSlides(): self
869.     {
870.         $this->slides = new ArrayCollection();
872.         return $this;
873.     }
875.     /**
876.      * @return Collection|JournalSection[]
877.      */
878.     public function getSections(): Collection
879.     {
880.         return $this->sections;
881.     }
883.     public function addSection(JournalSection $section): self
884.     {
885.         if ($this->sections->contains($section)) {
886.             return $this;
887.         }
889.         $this->sections[] = $section;
891.         return $this;
892.     }
894.     public function removeSection(JournalSection $section): self
895.     {
896.         $this->sections->removeElement($section);
898.         return $this;
899.     }
901.     public function resetSections(): self
902.     {
903.         $this->sections = new ArrayCollection();
905.         return $this;
906.     }
908.     /**
909.      * @return Collection|JournalMenuItem[]
910.      */
911.     public function getMenuItems(): Collection
912.     {
913.         return $this->menuItems;
914.     }
916.     public function addMenuItem(JournalMenuItem $menuItem): self
917.     {
918.         if ($this->menuItems->contains($menuItem)) {
919.             return $this;
920.         }
922.         $this->menuItems[] = $menuItem;
924.         return $this;
925.     }
927.     public function removeMenuItem(JournalMenuItem $menuItem): self
928.     {
929.         $this->menuItems->removeElement($menuItem);
931.         return $this;
932.     }
934.     public function resetMenuItems(): self
935.     {
936.         $this->menuItems = new ArrayCollection();
938.         return $this;
939.     }
941.     /**
942.      * @return Collection|JournalSubmenuGroup[]
943.      */
944.     public function getSubmenuGroups(): Collection
945.     {
946.         return $this->submenuGroups;
947.     }
949.     public function addSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
950.     {
951.         if ($this->submenuGroups->contains($submenuGroup)) {
952.             return $this;
953.         }
955.         $this->submenuGroups[] = $submenuGroup;
957.         return $this;
958.     }
960.     public function removeSubmenuGroup(JournalSubmenuGroup $submenuGroup): self
961.     {
962.         $this->submenuGroups->removeElement($submenuGroup);
964.         return $this;
965.     }
967.     public function resetSubmenuGroups(): self
968.     {
969.         $this->submenuGroups = new ArrayCollection();
971.         return $this;
972.     }
974.     /**
975.      * @return Collection|JournalSidemenuGroup[]
976.      */
977.     public function getSidemenuGroups(): Collection
978.     {
979.         return $this->sidemenuGroups;
980.     }
982.     public function addSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
983.     {
984.         if ($this->sidemenuGroups->contains($sidemenuGroup)) {
985.             return $this;
986.         }
988.         $this->sidemenuGroups[] = $sidemenuGroup;
990.         return $this;
991.     }
993.     public function removeSidemenuGroup(JournalSidemenuGroup $sidemenuGroup): self
994.     {
995.         $this->sidemenuGroups->removeElement($sidemenuGroup);
997.         return $this;
998.     }
1000.     public function resetSidemenuGroups(): self
1001.     {
1002.         $this->sidemenuGroups = new ArrayCollection();
1004.         return $this;
1005.     }
1007.     /**
1008.      * @return Collection|JournalBanner[]
1009.      */
1010.     public function getBanners(): Collection
1011.     {
1012.         return $this->banners;
1013.     }
1015.     public function addBanner(JournalBanner $banner): self
1016.     {
1017.         if ($this->banners->contains($banner)) {
1018.             return $this;
1019.         }
1021.         $this->banners[] = $banner;
1023.         return $this;
1024.     }
1026.     public function removeBanner(JournalBanner $banner): self
1027.     {
1028.         $this->banners->removeElement($banner);
1030.         return $this;
1031.     }
1033.     public function resetBanners(): self
1034.     {
1035.         $this->banners = new ArrayCollection();
1037.         return $this;
1038.     }
1040.     /**
1041.      * @return Collection|JournalVolume[]
1042.      */
1043.     public function getVolumes(): Collection
1044.     {
1045.         return $this->volumes;
1046.     }
1048.     public function addVolume(JournalVolume $volume): self
1049.     {
1050.         if ($this->volumes->contains($volume)) {
1051.             return $this;
1052.         }
1054.         $this->volumes[] = $volume;
1056.         return $this;
1057.     }
1059.     public function removeVolume(JournalVolume $volume): self
1060.     {
1061.         $this->volumes->removeElement($volume);
1063.         return $this;
1064.     }
1066.     public function resetVolumes(): self
1067.     {
1068.         $this->volumes = new ArrayCollection();
1070.         return $this;
1071.     }
1073.     /**
1074.      * @return Collection<int, JournalIssue>
1075.      */
1076.     public function getIssues(): Collection
1077.     {
1078.         return $this->issues;
1079.     }
1081.     /**
1082.      * @return Collection<int, JournalIssue>
1083.      */
1084.     public function getVisibleIssues(): Collection
1085.     {
1086.         return $this->issues->filter(fn (JournalIssue $issue) => $issue->getStat());
1087.     }
1089.     public function addIssue(JournalIssue $issue): self
1090.     {
1091.         if ($this->issues->contains($issue)) {
1092.             return $this;
1093.         }
1095.         $this->issues[] = $issue;
1097.         return $this;
1098.     }
1100.     public function removeIssue(JournalIssue $issue): self
1101.     {
1102.         $this->issues->removeElement($issue);
1104.         return $this;
1105.     }
1107.     public function resetIssues(): self
1108.     {
1109.         $this->issues = new ArrayCollection();
1111.         return $this;
1112.     }
1114.     public function getOldestIssue(): ?JournalIssue
1115.     {
1116.         $filtered = new ArrayCollection();
1118.         foreach ($this->getIssues() as $issue) {
1119.             if ($issue->getStat() && $issue->getPublishedAt()) {
1120.                 $filtered->add($issue);
1121.             }
1122.         }
1124.         if (count($filtered) === 0) {
1125.             return null;
1126.         }
1128.         $criteria = Criteria::create()->orderBy(['publishedAt' => Criteria::ASC]);
1130.         return $filtered
1131.             ->matching($criteria)
1132.             ->first();
1133.     }
1135.     /**
1136.      * @return Collection|JournalArticle[]
1137.      */
1138.     public function getArticles(): Collection
1139.     {
1140.         return $this->articles;
1141.     }
1143.     /**
1144.      * @return Collection<int, JournalArticle>
1145.      */
1146.     public function getArticlesVisible(): Collection
1147.     {
1148.         return $this->articles->filter(fn (JournalArticle $article) => $article->getStat());
1149.     }
1151.     public function addArticle(JournalArticle $article): self
1152.     {
1153.         if ($this->articles->contains($article)) {
1154.             return $this;
1155.         }
1157.         $this->articles[] = $article;
1159.         return $this;
1160.     }
1162.     public function removeArticle(JournalArticle $article): self
1163.     {
1164.         $this->articles->removeElement($article);
1166.         return $this;
1167.     }
1169.     public function resetArticles(): self
1170.     {
1171.         $this->articles = new ArrayCollection();
1173.         return $this;
1174.     }
1176.     /**
1177.      * @return Collection|JournalPage[]
1178.      */
1179.     public function getPages(): Collection
1180.     {
1181.         return $this->pages;
1182.     }
1184.     public function addPage(JournalPage $page): self
1185.     {
1186.         if ($this->pages->contains($page)) {
1187.             return $this;
1188.         }
1190.         $this->pages[] = $page;
1192.         return $this;
1193.     }
1195.     public function removePage(JournalPage $page): self
1196.     {
1197.         $this->pages->removeElement($page);
1199.         return $this;
1200.     }
1202.     public function resetPages(): self
1203.     {
1204.         $this->pages = new ArrayCollection();
1206.         return $this;
1207.     }
1209.     /**
1210.      * @return Collection|JournalNews[]
1211.      */
1212.     public function getNews(): Collection
1213.     {
1214.         return $this->news;
1215.     }
1217.     public function addNews(JournalNews $news): self
1218.     {
1219.         if ($this->news->contains($news)) {
1220.             return $this;
1221.         }
1223.         $this->news[] = $news;
1225.         return $this;
1226.     }
1228.     public function removeNews(JournalNews $news): self
1229.     {
1230.         $this->news->removeElement($news);
1232.         return $this;
1233.     }
1235.     public function resetNews(): self
1236.     {
1237.         $this->news = new ArrayCollection();
1239.         return $this;
1240.     }
1242.     /**
1243.      * @return Collection|JournalCollection[]
1244.      */
1245.     public function getCollections(): Collection
1246.     {
1247.         return $this->collections;
1248.     }
1250.     public function addCollection(JournalCollection $collection): self
1251.     {
1252.         if ($this->collections->contains($collection)) {
1253.             return $this;
1254.         }
1256.         $this->collections[] = $collection;
1258.         return $this;
1259.     }
1261.     public function removeCollection(JournalCollection $news): self
1262.     {
1263.         $this->news->removeElement($news);
1265.         return $this;
1266.     }
1268.     public function resetCollections(): self
1269.     {
1270.         $this->collections = new ArrayCollection();
1272.         return $this;
1273.     }
1275.     public function clone(Admin $createdBy = null): self
1276.     {
1277.         $clone = clone $this;
1279.         $clone->id = null;
1280.         $clone->setUuid();
1282.         $clone->ord = 0;
1283.         $clone->stat = false;
1284.         $clone->importId = null;
1286.         $clone->data = $this->data->clone($clone);
1287.         $clone->view = $this->view->clone($clone);
1289.         $nativeLanguage = $clone->getNativeLanguage();
1290.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
1291.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
1293.         ClassUtils::cloneCollection($this, $clone, 'translations');
1295.         $clone
1296.             ->resetDomains()
1297.             ->resetIndexationCollections()
1298.             ->resetIndicators()
1299.             ->resetAffiliations()
1300.             ->resetPublishers()
1301.             ->resetPartners()
1302.             ->resetSlides()
1303.             ->resetSections()
1304.             ->resetMenuItems()
1305.             ->resetSubmenuGroups()
1306.             ->resetBanners()
1307.             ->resetVolumes()
1308.             ->resetIssues()
1309.             ->resetArticles()
1310.             ->resetPages()
1311.             ->resetNews()
1312.             ->resetCollections()
1313.             ->resetEditorialGroups()
1314.             ->resetScientificCouncilMembers();
1316.         $clone->createdBy = $createdBy ?? $clone->createdBy;
1317.         $clone->updatedBy = $createdBy ?? $clone->updatedBy;
1319.         $clone->createdAt = new \DateTimeImmutable();
1320.         $clone->updatedAt = new \DateTimeImmutable();
1322.         return $clone;
1323.     }
1325.     public function isSortArticlesByOrd(): bool
1326.     {
1327.         return $this->sortArticlesByOrd;
1328.     }
1330.     public function setSortArticlesByOrd(bool $sortArticlesByOrd): self
1331.     {
1332.         $this->sortArticlesByOrd = $sortArticlesByOrd;
1334.         return $this;
1335.     }
1337.     /**
1338.      * @return Collection<int, JournalFooter>
1339.      */
1340.     public function getSmallFooters(): Collection
1341.     {
1342.         return $this->smallFooters;
1343.     }
1345.     public function addSmallFooter(JournalFooter $smallFooter): self
1346.     {
1347.         if (!$this->smallFooters->contains($smallFooter)) {
1348.             $this->smallFooters->add($smallFooter);
1349.             $smallFooter->setParent($this);
1350.         }
1352.         return $this;
1353.     }
1355.     public function removeSmallFooter(JournalFooter $smallFooter): self
1356.     {
1357.         if ($this->smallFooters->removeElement($smallFooter)) {
1358.             // set the owning side to null (unless already changed)
1359.             if ($smallFooter->getParent() === $this) {
1360.                 $smallFooter->setParent(null);
1361.             }
1362.         }
1364.         return $this;
1365.     }
1367.     public function getVisibleSmallFooters(): Collection
1368.     {
1369.         return $this->smallFooters->filter(fn (JournalFooter $smallFooter) => $smallFooter->getStat());
1370.     }
1372.     public function getStatsAmountOfArticles(): int
1373.     {
1374.         return $this->statsAmountOfArticles;
1375.     }
1377.     public function setStatsAmountOfArticles(int $statsAmountOfArticles): self
1378.     {
1379.         $this->statsAmountOfArticles = $statsAmountOfArticles;
1381.         return $this;
1382.     }
1384.     public function getStatsAmountOfIssues(): int
1385.     {
1386.         return $this->statsAmountOfIssues;
1387.     }
1389.     public function setStatsAmountOfIssues(int $statsAmountOfIssues): self
1390.     {
1391.         $this->statsAmountOfIssues = $statsAmountOfIssues;
1393.         return $this;
1394.     }
1396.     public function getStatsAmountOfVolumes(): int
1397.     {
1398.         return $this->statsAmountOfVolumes;
1399.     }
1401.     public function setStatsAmountOfVolumes(int $statsAmountOfVolumes): self
1402.     {
1403.         $this->statsAmountOfVolumes = $statsAmountOfVolumes;
1405.         return $this;
1406.     }
1408.     public function getStatsAmountOfViews(): int
1409.     {
1410.         return $this->statsAmountOfViews;
1411.     }
1413.     public function setStatsAmountOfViews(int $statsAmountOfViews): self
1414.     {
1415.         $this->statsAmountOfViews = $statsAmountOfViews;
1417.         return $this;
1418.     }
1420.     public function getStatsAmountOfDownloads(): int
1421.     {
1422.         return $this->statsAmountOfDownloads;
1423.     }
1425.     public function setStatsAmountOfDownloads(int $statsAmountOfDownloads): self
1426.     {
1427.         $this->statsAmountOfDownloads = $statsAmountOfDownloads;
1429.         return $this;
1430.     }
1432.     public function getStatsEarliestArticlePublicationDate(): ?\DateTimeImmutable
1433.     {
1434.         return $this->statsEarliestArticlePublicationDate;
1435.     }
1437.     public function setStatsEarliestArticlePublicationDate(?string $statsEarliestArticlePublicationDate): self
1438.     {
1439.         if (!$statsEarliestArticlePublicationDate) {
1440.             return $this;
1441.         }
1443.         $this->statsEarliestArticlePublicationDate = new \DateTimeImmutable($statsEarliestArticlePublicationDate);
1445.         return $this;
1446.     }
1448.     public function getStatsLatestArticlePublicationDate(): ?\DateTimeImmutable
1449.     {
1450.         return $this->statsLatestArticlePublicationDate;
1451.     }
1453.     public function setStatsLatestArticlePublicationDate(?string $statsLatestArticlePublicationDate): self
1454.     {
1455.         if (!$statsLatestArticlePublicationDate) {
1456.             return $this;
1457.         }
1459.         $this->statsLatestArticlePublicationDate = new \DateTimeImmutable($statsLatestArticlePublicationDate);
1461.         return $this;
1462.     }
1464.     #[Groups(['read:stats'])]
1465.     public function getStatsAffiliations(): ?string
1466.     {
1467.         $affiliations = [];
1469.         /** @var JournalAffiliation */
1470.         foreach ($this->affiliations as $entry) {
1471.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
1472.                 continue;
1473.             }
1475.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
1476.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
1477.         }
1479.         sort($affiliations);
1481.         return implode(', ',  $affiliations);
1482.     }
1484.     #[Groups(['read:stats'])]
1485.     public function getStatsAffiliationTypes(): ?string
1486.     {
1487.         $types = [];
1489.         /** @var JournalAffiliation */
1490.         foreach ($this->affiliations as $entry) {
1491.             if (!($type = $entry->getAffiliation()?->getType())) {
1492.                 continue;
1493.             }
1495.             if (isset($types[$type->getUuid()->toString()])) {
1496.                 continue;
1497.             }
1499.             $types[$type->getUuid()->toString()] = $type->getTitle();
1500.         }
1502.         sort($types);
1504.         return implode(', ',  $types);
1505.     }
1507.     #[Groups(['read:stats'])]
1508.     public function getStatsDomains(): ?string
1509.     {
1510.         $domains = [];
1512.         /** @var JournalDomain */
1513.         foreach ($this->domains as $entry) {
1514.             if (isset($domains[$entry->getDomain()->getUuid()->toString()])) {
1515.                 continue;
1516.             }
1518.             $domains[$entry->getDomain()->getUuid()->toString()] =
1519.                 $entry->getDomain()->readNativeLanguageTranslation('title');
1520.         }
1522.         sort($domains);
1524.         return implode(', ',  $domains);
1525.     }
1527.     #[Groups(['read:stats'])]
1528.     public function getStatsType(): ?string
1529.     {
1530.         return $this->data->getType()?->getTitle();
1531.     }
1533.     #[Groups(['read:stats'])]
1534.     public function getStatsState(): ?string
1535.     {
1536.         return $this->data->getState()?->getTitle();
1537.     }
1538. }