1. <?php
2. namespace App\Entity;
4. use Doctrine\ORM\Mapping as ORM,
5.     Doctrine\DBAL\Types\Types,
6.     Doctrine\Common\Collections\Collection,
7.     Doctrine\Common\Collections\ArrayCollection;
9. use Doctrine\ORM\Mapping\Index;
10. use Gedmo\Mapping\Annotation as Gedmo;
12. use Symfony\Component\Serializer\Annotation\Groups,
13.     Symfony\Component\Validator\Constraints as Assert;
15. use ApiPlatform\Metadata\ApiResource,
16.     ApiPlatform\Metadata\ApiProperty,
17.     ApiPlatform\Metadata\Get,
18.     ApiPlatform\Metadata\GetCollection,
19.     ApiPlatform\Metadata\Post,
20.     ApiPlatform\Metadata\Put,
21.     ApiPlatform\Metadata\Delete,
22.     ApiPlatform\Metadata\ApiFilter,
23.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
24.     ApiPlatform\Doctrine\Orm\Filter\DateFilter,
25.     ApiPlatform\Doctrine\Orm\Filter\ExistsFilter,
26.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter,
27.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
28.     ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
30. use App\Entity\Trait\IdTrait,
31.     App\Entity\Trait\UuidTrait,
32.     App\Entity\Trait\OrdStatTrait,
33.     App\Entity\Trait\TimestampableTrait,
34.     App\Entity\Trait\TranslatableTrait,
35.     App\Entity\Trait\Languages\LanguageableChildTrait,
36.     App\Entity\Trait\ArchivedTrait,
37.     App\Entity\Trait\ImportIdTrait,
38.     App\Entity\Interface\TranslatableInterface,
39.     App\Entity\Interface\OrdStatableInterface,
40.     App\Entity\Interface\LanguageableChildInterface,
41.     App\Entity\Interface\ArchivableInterface,
42.     App\Entity\Interface\CloneableInterface;
44. use App\Enum\JournalDateFormat,
45.     App\Enum\JournalArticleType,
46.     App\Enum\JournalLicence,
47.     App\Enum\JournalArticleFileType,
48.     App\Enum\AuthorProperty,
49.     App\Enum\JournalArticleAuthorRole,
50.     App\Doctrine\DBAL\Types\AuthorPropertiesType,
51.     App\Repository\JournalArticleRepository,
52.     App\Security\Voter\ArchivableVoter,
53.     App\Lib\Actions,
54.     App\DTO\CloneDTO,
55.     App\StateProcessor\CloneProcessor,
56.     App\Security\Voter\CloneVoter,
57.     App\Filter\IriFilter,
58.     App\Doctrine\DBAL\Types\LanguagesType;
60. use App\Util\ClassUtils,
61.     App\Enum\Language,
62.     App\Attribute\DenormalizationInject;
64. use App\Controller\Export\JournalArticle\JournalArticleCrossrefExporter,
65.     App\Controller\Export\JournalArticle\JournalArticleSimcheckCrossrefExporter,
66.     App\Controller\Export\JournalArticle\JournalArticleFundingCrossrefExporter,
67.     App\Controller\Export\JournalArticle\JournalArticleLicenceFulltextCrossrefExporter,
68.     App\Controller\Export\JournalArticle\JournalArticleReferencesCrossrefExporter,
69.     App\Controller\Export\JournalArticle\JournalArticleJATSExporter;
71. use App\Controller\Stats\JournalArticleStatsCSVGenerator;
72. use App\StateProvider\JournalArticleStatsProvider;
74. #[ApiResource(
75.     description: 'Journal articles',
76.     normalizationContext: ['groups' => [
77.         'read',
78.         'read:' . self::class,
79.         'read:' . self::class . 'Translation',
80.         'read:' . self::class . 'MetadataTranslation'
81.     ]],
82.     denormalizationContext: ['groups' => ['write']],
83.     security: 'is_granted("' . Journal::class . '")',
84.     order: ['ord' => 'desc'],
85.     operations: [
86.         new GetCollection(),
87.         new GetCollection(
88.             name: 'get_journal_article_stats',
89.             uriTemplate: '/journal_articles/stats',
90.             provider: JournalArticleStatsProvider::class,
91.             security: 'is_granted("ROLE_MODULE_STATS")',
92.             normalizationContext: ['groups' => ['read:stats']],
93.         ),
94.         new GetCollection(
95.             name: 'get_journal_article_stats_csv',
96.             uriTemplate: '/journal_articles/stats/csv',
97.             provider: JournalArticleStatsProvider::class,
98.             controller: JournalArticleStatsCSVGenerator::class,
99.             security: 'is_granted("ROLE_MODULE_STATS")',
100.         ),
101.         new Post(
102.             uriTemplate: '/journal_articles/clone',
103.             input: CloneDTO::class,
104.             processor: CloneProcessor::class,
105.             security: 'is_granted("' . Actions::CLONE .'")',
106.             securityMessage: CloneVoter::MESSAGE
107.         ),
108.         new Post(denormalizationContext: ['groups' => ['write',  'post']]),
109.         new Get(),
110.         new Get(
111.             name: 'get_journal_article_crossref',
112.             uriTemplate: '/journal_articles/{uuid}/export/crossref',
113.             controller: JournalArticleCrossrefExporter::class
114.         ),
115.         new Get(
116.             name: 'get_journal_article_jats',
117.             uriTemplate: '/journal_articles/{uuid}/export/jats',
118.             controller: JournalArticleJATSExporter::class
119.         ),
120.         new Get(
121.             name: 'get_journal_article_simcheck_crossref',
122.             uriTemplate: '/journal_articles/{uuid}/export/simcheck_crossref',
123.             controller: JournalArticleSimcheckCrossrefExporter::class
124.         ),
125.         new Get(
126.             name: 'get_journal_article_funding_crossref',
127.             uriTemplate: '/journal_articles/{uuid}/export/funding_crossref',
128.             controller: JournalArticleFundingCrossrefExporter::class
129.         ),
130.         new Get(
131.             name: 'get_journal_article_licence_fulltext_crossref',
132.             uriTemplate: '/journal_articles/{uuid}/export/licence_fulltext_crossref',
133.             controller: JournalArticleLicenceFulltextCrossrefExporter::class
134.         ),
135.         new Get(
136.             name: 'get_journal_article_references_crossref',
137.             uriTemplate: '/journal_articles/{uuid}/export/references_crossref',
138.             controller: JournalArticleReferencesCrossrefExporter::class
139.         ),
140.         new Put(),
141.         new Delete(
142.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
143.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
144.         ),
145.     ],
146.     extraProperties: ['standard_put' => false],
147. )]
148. #[ApiFilter(SearchFilter::class, properties: [
149.     'translations.title' => 'partial',
150.     'nativeTitle' => 'partial',
151.     'workingTitle' => 'partial',
152.     'uuid' => 'exact',
153. ])]
154. #[ApiFilter(ExistsFilter::class, properties: ['doi'])]
155. #[ApiFilter(IriFilter::class, properties: [
156.     'parent',
157.     'issue',
158.     'type',
159.     'section'
160. ])]
161. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
162. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
163. #[ApiFilter(RangeFilter::class, properties: ['statsAmountOfViews', 'statsAmountOfDownloads'])]
164. #[ApiFilter(OrderFilter::class, properties: [
165.     'nativeTitle',
166.     'doi',
167.     'pageFrom',
168.     'isOpen',
169.     'onlinePublishedAt',
170.     'updatedAt',
171.     'receivedAt',
172.     'acceptedAt',
173.     'nativeMetadataLanguage',
174.     'parent.nativeTitle',
175.     'issue.nativeTitle',
176.     'issue.volume.nativeTitle',
177.     'section.nativeTitle',
178.     'ord',
179.     'statsAmountOfViews',
180.     'statsAmountOfDownloads'
181. ])]
182. #[Index(fields: ["importId"], name: "import_id_idx")]
183. #[Index(fields: ["stat"], name: "stat_idx")]
184. #[ORM\Entity(repositoryClass: JournalArticleRepository::class)]
185. class JournalArticle implements
186.     TranslatableInterface,
187.     OrdStatableInterface,
188.     LanguageableChildInterface,
189.     ArchivableInterface,
190.     CloneableInterface
191. {
192.     use IdTrait,
193.         UuidTrait,
194.         OrdStatTrait,
195.         TimestampableTrait,
196.         TranslatableTrait,
197.         LanguageableChildTrait,
198.         ArchivedTrait,
199.         ImportIdTrait;
201.     const DEFAULT_FILES = [
202.         JournalArticleFileType::BIBLIOGRAPHY,
203.         JournalArticleFileType::ABSTRACT_TEXT,
204.         JournalArticleFileType::FULL_TEXT
205.     ];
207.     #[ApiProperty(description: 'Parent', writableLink: false)]
208.     #[Groups(['read', 'post'])]
209.     #[ORM\ManyToOne(targetEntity: Journal::class, inversedBy: 'articles')]
210.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
211.     private Journal $parent;
213.     #[ApiProperty(description: 'Native title')]
214.     #[Groups(['read', 'read:stats'])]
215.     #[ORM\Column(type: Types::TEXT, nullable: true)]
216.     private ?string $nativeTitle = null;
218.     #[ApiProperty(description: 'Native title raw')]
219.     #[Groups(['read'])]
220.     #[ORM\Column(type: Types::TEXT, nullable: true)]
221.     private ?string $nativeTitleRaw = null;
223.     #[ApiProperty(description: 'Working title')]
224.     #[Groups(['read', 'write'])]
225.     #[Assert\NotBlank]
226.     #[ORM\Column(type: Types::STRING, length: 511)]
227.     private string $workingTitle;
229.     #[ApiProperty(description: 'Licence', writableLink: false)]
230.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
231.     #[ORM\Column(
232.         type: Types::STRING,
233.         enumType: JournalLicence::class,
234.         length: 255,
235.         options: ['default' => JournalLicence::CC_BY]
236.     )]
237.     private JournalLicence $licence = JournalLicence::CC_BY;
239.     #[ApiProperty(description: 'Issue', writableLink: false, fetchEager: false)]
240.     #[Groups(['read', 'write'])]
241.     #[Assert\NotNull]
242.     #[Assert\Expression(
243.         expression: '!this || value.getParent() === this.getParent()',
244.         message: 'Cannot assign issue from the outside of current journal.'
245.     )]
246.     #[ORM\ManyToOne(targetEntity: JournalIssue::class, inversedBy: 'articles')]
247.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
248.     private JournalIssue $issue;
250.     #[ApiProperty(description: 'Funding number')]
251.     #[Groups(['read:' . self::class, 'write'])]
252.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
253.     private ?string $fundingNumber = null;
255.     #[ApiProperty(description: 'Type', writableLink: false)]
256.     #[Groups(['read', 'read:stats', 'write'])]
257.     #[ORM\Column(
258.         type: Types::STRING,
259.         enumType: JournalArticleType::class,
260.         length: 255,
261.         options: ['default' => JournalArticleType::ORIGINAL_RESEARCH_ARTICLE
262.     ])]
263.     private JournalArticleType $type = JournalArticleType::ORIGINAL_RESEARCH_ARTICLE;
265.     #[ApiProperty(description: 'Section', writableLink: false, fetchEager: false)]
266.     #[Groups(['read:' . self::class, 'write'])]
267.     #[ORM\ManyToOne(targetEntity: JournalSection::class)]
268.     #[ORM\JoinColumn(onDelete: 'set null')]
269.     private ?JournalSection $section = null;
271.     #[ApiProperty(description: 'DOI')]
272.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
273.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
274.     private ?string $doi = null;
276.     #[ApiProperty(description: 'Page from')]
277.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
278.     // #[Assert\Positive]
279.     #[ORM\Column(type: Types::STRING, nullable: true)] //, options: ['default' => 1])]
280.     private ?string $pageFrom = null;
282.     #[ApiProperty(description: 'Page to')]
283.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
284.     // #[Assert\Expression(
285.     //     expression: 'value >= this.getPageFrom()',
286.     //     message: 'Page to must be greater than page from.'
287.     // )]
288.     #[ORM\Column(type: Types::STRING, nullable: true)] //INTEGER, options: ['default' => 1])]
289.     private ?string $pageTo = null;
291.     #[ApiProperty(description: 'Citation type', writableLink: false)]
292.     #[Groups(['read:' . self::class, 'write'])]
293.     #[ORM\ManyToOne(targetEntity: CitationType::class)]
294.     #[ORM\JoinColumn(onDelete: 'set null')]
295.     private ?CitationType $citationType = null;
297.     #[ApiProperty(description: 'Citation')]
298.     #[Groups(['read:' . self::class, 'write'])]
299.     #[ORM\Column(type: Types::TEXT, nullable: true)]
300.     private ?string $citation = null;
302.     #[ApiProperty(description: 'Received at')]
303.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
304.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
305.     private ?\DateTimeImmutable $receivedAt = null;
307.     #[ApiProperty(description: 'Received at format', writableLink: false)]
308.     #[Groups(['read:' . self::class, 'write'])]
309.     #[ORM\Column(
310.         type: Types::STRING,
311.         enumType: JournalDateFormat::class,
312.         length: 255,
313.         options: ['default' => JournalDateFormat::COMPLETE]
314.     )]
315.     private JournalDateFormat $receivedAtFormat = JournalDateFormat::COMPLETE;
317.     #[ApiProperty(description: 'Accepted at')]
318.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
319.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
320.     private ?\DateTimeImmutable $acceptedAt = null;
322.     #[ApiProperty(description: 'Accepted at format', writableLink: false)]
323.     #[Groups(['read:' . self::class, 'write'])]
324.     #[ORM\Column(
325.         type: Types::STRING,
326.         enumType: JournalDateFormat::class,
327.         length: 255,
328.         options: ['default' => JournalDateFormat::COMPLETE]
329.     )]
330.     private JournalDateFormat $acceptedAtFormat = JournalDateFormat::COMPLETE;
332.     #[ApiProperty(description: 'Corrected at')]
333.     #[Groups(['read:' . self::class, 'write'])]
334.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
335.     private ?\DateTimeImmutable $correctedAt = null;
337.     #[ApiProperty(description: 'Corrected at format', writableLink: false)]
338.     #[Groups(['read:' . self::class, 'write'])]
339.     #[ORM\Column(
340.         type: Types::STRING,
341.         enumType: JournalDateFormat::class,
342.         length: 255,
343.         options: ['default' => JournalDateFormat::COMPLETE]
344.     )]
345.     private JournalDateFormat $correctedAtFormat = JournalDateFormat::COMPLETE;
347.     #[ApiProperty(description: 'Online published at')]
348.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
349.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
350.     private ?\DateTimeImmutable $onlinePublishedAt = null;
352.     #[ApiProperty(description: 'Online published at format', writableLink: false)]
353.     #[Groups(['read:' . self::class, 'write'])]
354.     #[ORM\Column(
355.         type: Types::STRING,
356.         enumType: JournalDateFormat::class,
357.         length: 255,
358.         options: ['default' => JournalDateFormat::COMPLETE]
359.     )]
360.     private JournalDateFormat $onlinePublishedAtFormat = JournalDateFormat::COMPLETE;
362.     #[ApiProperty(description: 'Is open')]
363.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
364.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => true])]
365.     private bool $isOpen = true;
367.     #[ApiProperty(description: 'Price')]
368.     #[Groups(['read:' . self::class])]
369.     #[Assert\PositiveOrZero]
370.     #[ORM\Column(type: Types::INTEGER, nullable: true)]
371.     private ?int $price = null;
373.     #[ApiProperty(description: 'Grace date')]
374.     #[Groups(['read:' . self::class, 'write'])]
375.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
376.     private ?\DateTimeImmutable $graceDate = null;
378.     #[ApiProperty(description: 'Meta link')]
379.     #[Groups(['read:' . self::class, 'write'])]
380.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
381.     private ?string $metaLink = null;
383.     /** @deprecated */
384.     #[ApiProperty(description: 'Language', writableLink: false)]
385.     #[Groups(['read:' . self::class, 'write'])]
386.     #[ORM\Column(
387.         type: Types::STRING,
388.         enumType: Language::class,
389.         length: 255,
390.         options: ['default' => Language::PL]
391.     )]
392.     private Language $language = Language::PL;
394.     #[ApiProperty(description: 'Visible author properties', writableLink: false)]
395.     #[Groups(['read:' . self::class, 'write'])]
396.     #[Assert\Choice(callback: [AuthorProperty::class, 'cases'], multiple: true)]
397.     #[Assert\Unique]
398.     #[Assert\Count(min: 1)]
399.     #[ORM\Column(type: AuthorPropertiesType::NAME)]
400.     private array $visibleAuthorProperties = [
401.         AuthorProperty::PREFIX,
402.         AuthorProperty::NAME,
403.         AuthorProperty::SURNAME,
404.         AuthorProperty::AFFILIATION
405.     ];
407.     #[ApiProperty(description: 'Publication languages', writableLink: false)]
408.     #[Groups(['read:' . self::class, 'write'])]
409.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
410.     #[Assert\Unique]
411.     #[Assert\Count(min: 1)]
412.     #[ORM\Column(type: LanguagesType::NAME)]
413.     private array $publicationLanguages = [Language::EN];
415.     #[ApiProperty(description: 'Metadata languages', writableLink: false)]
416.     #[Groups(['read:' . self::class, 'write'])]
417.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
418.     #[Assert\Unique]
419.     // #[Assert\Count(min: 1)]
420.     #[ORM\Column(type: LanguagesType::NAME)]
421.     private array $metadataLanguages = [Language::EN, Language::PL];
423.     #[ApiProperty(description: 'Native metadata language')]
424.     #[Groups(['read:' . self::class, 'read:stats'])]
425.     #[ORM\Column(
426.         type: Types::STRING,
427.         enumType: Language::class,
428.         length: 255,
429.         nullable: true,
430.     )]
431.     private ?Language $nativeMetadataLanguage = null;
433.     #[ApiProperty(description: 'Slug')]
434.     #[Groups(['read:' . self::class, 'write'])]
435.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitleRaw'])]
436.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
437.     private ?string $slug = null;
439.     #[ApiProperty(description: 'Statistics: amount of views')]
440.     #[Groups(['read:stats'])]
441.     #[ORM\Column(type: Types::INTEGER)]
442.     private int $statsAmountOfViews = 0;
444.     #[ApiProperty(description: 'Statistics: amount of downloads')]
445.     #[Groups(['read:stats'])]
446.     #[ORM\Column(type: Types::INTEGER)]
447.     private int $statsAmountOfDownloads = 0;
449.     #[ApiProperty(description: 'Metadata translations')]
450.     #[Groups(['read', 'write'])]
451.     #[Assert\Type(Collection::class)]
452.     #[Assert\Valid]
453.     #[DenormalizationInject(method: ['name' => 'getMetadataTranslation', 'key' => 'lang'])]
454.     #[ORM\OneToMany(
455.         targetEntity: JournalArticleMetadataTranslation::class,
456.         mappedBy: 'parent',
457.         cascade: ['persist', 'remove'],
458.         orphanRemoval: true,
459.         indexBy: 'lang'
460.     )]
461.     private Collection $metadataTranslations;
463.     #[ApiProperty(description: 'Classifications')]
464.     #[ORM\OneToMany(targetEntity: JournalArticleClassification::class, mappedBy: 'parent', cascade: ['persist'])]
465.     #[ORM\OrderBy(['ord' => 'desc'])]
466.     private Collection $classifications;
468.     #[ApiProperty(description: 'Research datas')]
469.     #[ORM\OneToMany(targetEntity: JournalArticleResearchData::class, mappedBy: 'parent', cascade: ['persist'])]
470.     #[ORM\OrderBy(['ord' => 'desc'])]
471.     private Collection $researchDatas;
473.     #[ApiProperty(description: 'Relationships')]
474.     #[ORM\OneToMany(targetEntity: JournalArticleRelationship::class, mappedBy: 'parent', cascade: ['persist'])]
475.     #[ORM\OrderBy(['ord' => 'desc'])]
476.     private Collection $relationships;
478.     #[ApiProperty(description: 'Content blocks')]
479.     #[ORM\OneToMany(targetEntity: JournalArticleContentBlock::class, mappedBy: 'parent', cascade: ['persist'])]
480.     #[ORM\OrderBy(['ord' => 'desc'])]
481.     private Collection $contentBlocks;
483.     #[ApiProperty(description: 'Additional blocks')]
484.     #[ORM\OneToMany(targetEntity: JournalArticleAdditionalBlock::class, mappedBy: 'parent')]
485.     #[ORM\OrderBy(['ord' => 'desc'])]
486.     private Collection $additionalBlocks;
488.     #[ApiProperty(description: 'Bibliography entries')]
489.     #[ORM\OneToMany(
490.         targetEntity: JournalArticleBibliographyEntry::class,
491.         mappedBy: 'parent',
492.         cascade: ['persist', 'remove'],
493.         orphanRemoval: true
494.     )]
495.     #[ORM\OrderBy(['ord' => 'desc'])]
496.     private Collection $bibliographyEntries;
498.     #[ApiProperty(description: 'Files')]
499.     #[ORM\OneToMany(targetEntity: JournalArticleFile::class, mappedBy: 'parent', cascade: ['persist'])]
500.     #[ORM\OrderBy(['ord' => 'desc'])]
501.     private Collection $files;
503.     #[ApiProperty(description: 'Authors')]
504.     #[Groups(['read:' . self::class])]
505.     #[ORM\OneToMany(targetEntity: JournalArticleAuthor::class, mappedBy: 'parent')]
506.     #[ORM\OrderBy(['ord' => 'desc'])]
507.     private Collection $authors;
509.     private ?array $redactors = null;
511.     #[ApiProperty(description: 'View entries')]
512.     #[ORM\OneToMany(targetEntity: JournalArticleViewEntry::class, mappedBy: 'parent', cascade: ['persist'])]
513.     #[ORM\OrderBy(['createdAt' => 'desc'])]
514.     private Collection $viewEntries;
516.     #[ApiProperty(description: 'Download entries')]
517.     #[ORM\OneToMany(targetEntity: JournalArticleDownloadEntry::class, mappedBy: 'parent', cascade: ['persist'])]
518.     #[ORM\OrderBy(['createdAt' => 'desc'])]
519.     private Collection $downloadEntries;
521.     #[ApiProperty(description: 'Slug title language', writableLink: false)]
522.     #[Groups(['read:' . self::class, 'write'])]
523.     #[Assert\Choice(callback: 'getMetadataLanguages', message: 'Można wybrać tylko jeden z języków tekstu.')]
524.     #[ORM\Column(
525.         type: Types::STRING,
526.         enumType: Language::class,
527.         length: 255,
528.         nullable: true,
529.     )]
530.     private ?Language $slugTitleLanguage = null;
532.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalArticleSlugHistory::class, cascade: ['persist'], orphanRemoval: true,)]
533.     private Collection $slugHistory;
535.     public function __construct(Journal $parent, JournalIssue $issue)
536.     {
537.         $this->setUuid();
539.         $this->parent = $parent;
540.         $this->issue = $issue;
542.         $this->translations = new ArrayCollection();
543.         $this->metadataTranslations = new ArrayCollection();
545.         $this->classifications = new ArrayCollection();
546.         $this->researchDatas = new ArrayCollection();
547.         $this->relationships = new ArrayCollection();
548.         $this->contentBlocks = new ArrayCollection();
549.         $this->additionalBlocks = new ArrayCollection();
550.         $this->bibliographyEntries = new ArrayCollection();
551.         $this->files = new ArrayCollection();
552.         $this->authors = new ArrayCollection();
554.         $this->viewEntries = new ArrayCollection();
555.         $this->downloadEntries = new ArrayCollection();
556.         $this->slugHistory = new ArrayCollection();
558.         foreach ($this->parent->getLanguages() as $lang) {
559.             new JournalArticleTranslation($this, $lang);
560.         }
562.         foreach ($this->metadataLanguages as $lang) {
563.             new JournalArticleMetadataTranslation($this, $lang);
564.         }
566.         foreach (self::DEFAULT_FILES as $type) {
567.             new JournalArticleFile($this, $type);
568.         }
570.         $this->isOpen = $issue->getIsOpen();
571.         $this->price = $issue->getPrice();
573.         $this->citationType = $issue->getSuggestedCitationType();
575.         $this->licence = $issue->getLicence();
577.         $this->createdAt = new \DateTimeImmutable();
578.         $this->updatedAt = new \DateTimeImmutable();
580.         $parent->addArticle($this);
581.     }
583.     public function getParent(): Journal
584.     {
585.         return $this->parent;
586.     }
588.     public function getNativeMetadataLanguage(): ?Language
589.     {
590.         return $this->nativeMetadataLanguage;
591.     }
593.     public function getNativeTitle(): ?string
594.     {
595.         return $this->nativeTitle;
596.     }
598.     public function setNativeTitle(?string $nativeTitle): self
599.     {
600.         $this->nativeTitle = $nativeTitle;
602.         return $this;
603.     }
605.     public function getNativeTitleRaw(): ?string
606.     {
607.         return $this->nativeTitleRaw;
608.     }
610.     public function setNativeTitleRaw(?string $nativeTitleRaw): self
611.     {
612.         $this->nativeTitleRaw = $nativeTitleRaw;
614.         $this->addCurrentSlugToHistory();
616.         return $this;
617.     }
619.     public function getWorkingTitle(): ?string
620.     {
621.         return $this->workingTitle;
622.     }
624.     public function setWorkingTitle(?string $workingTitle): self
625.     {
626.         $this->workingTitle = $workingTitle;
628.         return $this;
629.     }
631.     public function getLicence(): JournalLicence
632.     {
633.         return $this->licence;
634.     }
636.     public function setLicence(JournalLicence $licence): self
637.     {
638.         $this->licence = $licence;
640.         return $this;
641.     }
643.     public function getIssue(): JournalIssue
644.     {
645.         return $this->issue;
646.     }
648.     public function setIssue(JournalIssue $issue): self
649.     {
650.         $this->issue = $issue;
652.         return $this;
653.     }
655.     public function getFundingNumber(): ?string
656.     {
657.         return $this->fundingNumber;
658.     }
660.     public function setFundingNumber(?string $fundingNumber): self
661.     {
662.         $this->fundingNumber = $fundingNumber;
664.         return $this;
665.     }
667.     public function getType(): JournalArticleType
668.     {
669.         return $this->type;
670.     }
672.     public function setType(JournalArticleType $type): self
673.     {
674.         $this->type = $type;
676.         return $this;
677.     }
679.     public function getSection(): ?JournalSection
680.     {
681.         return $this->section;
682.     }
684.     public function setSection(?JournalSection $section): self
685.     {
686.         $this->section = $section;
688.         return $this;
689.     }
691.     public function getDoi(): ?string
692.     {
693.         return $this->doi;
694.     }
696.     public function setDoi(?string $doi): self
697.     {
698.         $this->doi = $doi;
700.         return $this;
701.     }
703.     public function getPageFrom(): ?string
704.     {
705.         return $this->pageFrom;
706.     }
708.     public function setPageFrom(?string $pageFrom): self
709.     {
710.         $this->pageFrom = $pageFrom;
712.         return $this;
713.     }
715.     public function getPageTo(): ?string
716.     {
717.         return $this->pageTo;
718.     }
720.     public function setPageTo(?string $pageTo): self
721.     {
722.         $this->pageTo = $pageTo;
724.         return $this;
725.     }
727.     public function getCitationType(): ?CitationType
728.     {
729.         return $this->citationType;
730.     }
732.     public function setCitationType(?CitationType $citationType): self
733.     {
734.         $this->citationType = $citationType;
736.         return $this;
737.     }
739.     public function getCitation(): ?string
740.     {
741.         return $this->citation;
742.     }
744.     public function setCitation(?string $citation): self
745.     {
746.         $this->citation = $citation;
748.         return $this;
749.     }
751.     public function getReceivedAt(): ?\DateTimeImmutable
752.     {
753.         return $this->receivedAt;
754.     }
756.     public function setReceivedAt(?\DateTimeImmutable $receivedAt): self
757.     {
758.         $this->receivedAt = $receivedAt;
760.         return $this;
761.     }
763.     public function getReceivedAtFormat(): JournalDateFormat
764.     {
765.         return $this->receivedAtFormat;
766.     }
768.     public function setReceivedAtFormat(JournalDateFormat $receivedAtFormat): self
769.     {
770.         $this->receivedAtFormat = $receivedAtFormat;
772.         return $this;
773.     }
775.     public function getAcceptedAt(): ?\DateTimeImmutable
776.     {
777.         return $this->acceptedAt;
778.     }
780.     public function setAcceptedAt(?\DateTimeImmutable $acceptedAt): self
781.     {
782.         $this->acceptedAt = $acceptedAt;
784.         return $this;
785.     }
787.     public function getAcceptedAtFormat(): JournalDateFormat
788.     {
789.         return $this->acceptedAtFormat;
790.     }
792.     public function setAcceptedAtFormat(JournalDateFormat $acceptedAtFormat): self
793.     {
794.         $this->acceptedAtFormat = $acceptedAtFormat;
796.         return $this;
797.     }
799.     public function getCorrectedAt(): ?\DateTimeImmutable
800.     {
801.         return $this->correctedAt;
802.     }
804.     public function setCorrectedAt(?\DateTimeImmutable $correctedAt): self
805.     {
806.         $this->correctedAt = $correctedAt;
808.         return $this;
809.     }
811.     public function getCorrectedAtFormat(): JournalDateFormat
812.     {
813.         return $this->correctedAtFormat;
814.     }
816.     public function setCorrectedAtFormat(JournalDateFormat $correctedAtFormat): self
817.     {
818.         $this->correctedAtFormat = $correctedAtFormat;
820.         return $this;
821.     }
823.     public function getOnlinePublishedAt(): ?\DateTimeImmutable
824.     {
825.         return $this->onlinePublishedAt;
826.     }
828.     public function setOnlinePublishedAt(?\DateTimeImmutable $onlinePublishedAt): self
829.     {
830.         if ($this->onlinePublishedAt === $onlinePublishedAt) {
831.             return $this;
832.         }
834.         $this->onlinePublishedAt = $onlinePublishedAt;
836.         if (! $onlinePublishedAt) {
837.             return $this;
838.         }
840.         $period = $this->parent->getData()->getOpenAccessGrantedAfterPeriod();
842.         if (! $period) {
843.             return $this;
844.         }
846.         $graceDate = new \DateTime("@{$this->onlinePublishedAt->getTimestamp()}");
847.         $graceDate->modify($period);
849.         $this->graceDate = new \DateTimeImmutable("@{$graceDate->getTimestamp()}");
851.         return $this;
852.     }
854.     public function getOnlinePublishedAtFormat(): JournalDateFormat
855.     {
856.         return $this->onlinePublishedAtFormat;
857.     }
859.     public function setOnlinePublishedAtFormat(JournalDateFormat $onlinePublishedAtFormat): self
860.     {
861.         $this->onlinePublishedAtFormat = $onlinePublishedAtFormat;
863.         return $this;
864.     }
866.     public function getAllDatesFormatted(): array
867.     {
868.         $properties = ['ReceivedAt', 'AcceptedAt', 'CorrectedAt', 'OnlinePublishedAt'];
869.         $dates = [];
871.         foreach ($properties as $property) {
872.             $date = $this->{'get' . $property}();
874.             $dates[$property] = null;
876.             if (! $date) {
877.                 continue;
878.             }
880.             $dates[$property] = match($this->{'get' . $property . 'Format'}()) {
881.                 JournalDateFormat::YEAR => $date->format('Y'),
882.                 JournalDateFormat::YEAR_AND_MONTH => $date->format('m.Y'),
883.                 JournalDateFormat::COMPLETE => $date->format('d.m.Y'),
884.                 default => null,
885.             };
886.         }
888.         return $dates;
889.     }
891.     public function getIsOpen(): bool
892.     {
893.         return $this->isOpen;
894.     }
896.     public function setIsOpen(bool $isOpen): self
897.     {
898.         $this->isOpen = $isOpen;
900.         return $this;
901.     }
903.     public function getPrice(): ?int
904.     {
905.         return $this->price;
906.     }
908.     #[Groups(['read:' . self::class, 'read:' . Journal::class])]
909.     public function getPriceReal(): ?float
910.     {
911.         return $this->price ? round($this->price / 1000, 2) : null;
912.     }
914.     public function setPrice(?int $price): self
915.     {
916.         $this->price = $price;
918.         return $this;
919.     }
921.     #[Groups(['write'])]
922.     public function setPriceReal(?float $priceReal): self
923.     {
924.         $this->price = (int) ($priceReal * 1000);
926.         return $this;
927.     }
929.     public function getGraceDate(): ?\DateTimeImmutable
930.     {
931.         return $this->graceDate;
932.     }
934.     public function setGraceDate(?\DateTimeImmutable $graceDate): self
935.     {
936.         $this->graceDate = $graceDate;
938.         return $this;
939.     }
941.     public function getMetaLink(): ?string
942.     {
943.         return $this->metaLink;
944.     }
946.     public function setMetaLink(?string $metaLink): self
947.     {
948.         $this->metaLink = $metaLink;
950.         return $this;
951.     }
953.     /** @deprecated */
954.     public function getLanguage(): Language
955.     {
956.         return $this->language;
957.     }
959.     /** @deprecated */
960.     public function setLanguage(Language $language): self
961.     {
962.         $this->language = $language;
964.         return $this;
965.     }
967.     public function getVisibleAuthorProperties(): array
968.     {
969.         return $this->visibleAuthorProperties;
970.     }
972.     public function setVisibleAuthorProperties(array $visibleAuthorProperties): self
973.     {
974.         $this->visibleAuthorProperties = $visibleAuthorProperties;
976.         return $this;
977.     }
979.     public function getPublicationLanguages(): array
980.     {
981.         return $this->publicationLanguages;
982.     }
984.     public function setPublicationLanguages(array $publicationLanguages): self
985.     {
986.         $this->publicationLanguages = $publicationLanguages;
988.         return $this;
989.     }
991.     public function getMetadataLanguages(): array
992.     {
993.         return $this->metadataLanguages;
994.     }
996.     public function setMetadataLanguages(array $metadataLanguages): self
997.     {
998.         $this->metadataLanguages = $metadataLanguages;
1000.         /** @var JournalArticleMetadataTranslation */
1001.         foreach ($this->metadataTranslations as $metadataTranslation) {
1002.             if (in_array($metadataTranslation->getLang(), $this->metadataLanguages)) {
1003.                 continue;
1004.             }
1006.             $this->deleteMetadataTranslation($metadataTranslation);
1007.         }
1009.         foreach ($this->metadataLanguages as $lang) {
1010.             if (! $lang instanceof Language || isset($this->metadataTranslations[$lang->value])) {
1011.                 continue;
1012.             }
1014.             $class = JournalArticleMetadataTranslation::class;
1015.             new $class($this, $lang);
1016.         }
1018.         if (count($metadataLanguages) < 1) {
1019.             $this->nativeMetadataLanguage = null;
1021.             return $this;
1022.         }
1024.         $this->nativeMetadataLanguage = $this->metadataLanguages[array_key_first($this->metadataLanguages)];
1026.         return $this;
1027.     }
1029.     public function getAvailableMetadataLanguages(string $property): array
1030.     {
1031.         $langs = [];
1033.         foreach($this->metadataLanguages as $lang) {
1034.             /** @var JournalArticleMetadataTranslation */
1035.             $metadataTranslation = $this->getMetadataTranslation($lang);
1037.             switch($property) {
1038.                 case 'abstract':
1039.                     if (! empty($metadataTranslation->getAbstract())) {
1040.                         $langs[] = $lang;
1041.                     }
1042.                     break;
1043.                 case 'keywords':
1044.                     if (! empty($metadataTranslation->getKeywords())) {
1045.                         $langs[] = $lang;
1046.                     }
1047.                     break;
1048.                 case 'title':
1049.                     if (! empty($metadataTranslation->getTitle())) {
1050.                         $langs[] = $lang;
1051.                     }
1052.                 default:
1053.                     break;
1054.             }
1055.         }
1057.         return $langs;
1058.     }
1060.     public function getSlug(): ?string
1061.     {
1062.         return $this->slug;
1063.     }
1065.     public function setSlug(?string $slug): self
1066.     {
1067.         $this->slug = $slug;
1069.         return $this;
1070.     }
1072.     public function getStatsAmountOfViews(): int
1073.     {
1074.         return $this->statsAmountOfViews;
1075.     }
1077.     public function hitStatsView(): int
1078.     {
1079.         return $this->statsAmountOfViews++;
1080.     }
1082.     /*
1083.     public function updateStatsView(int $amount): self
1084.     {
1085.         $this->statsAmountOfViews += $amount;
1087.         return $this;
1088.     }*/
1090.     public function getStatsAmountOfDownloads(): int
1091.     {
1092.         return $this->statsAmountOfDownloads;
1093.     }
1095.     public function hitStatsDownload(): int
1096.     {
1097.         return $this->statsAmountOfDownloads++;
1098.     }
1100.     /*
1101.     public function updateStatsDownload(int $amount): self
1102.     {
1103.         $this->statsAmountOfDownloads += $amount;
1105.         return $this;
1106.     }*/
1108.     /**
1109.      * @return Collection|JournalArticleMetadataTranslation[]
1110.      */
1111.     public function getMetadataTranslations(): Collection
1112.     {
1113.         return $this->metadataTranslations;
1114.     }
1116.     public function getMetadataTranslation(Language $lang): mixed
1117.     {
1118.         return $this->metadataTranslations[$lang->value] ?? null;
1119.     }
1121.     public function addMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1122.     {
1123.         if ($this->metadataTranslations->contains($metadataTranslation)) {
1124.             return $this;
1125.         }
1127.         $this->metadataTranslations[
1128.             $metadataTranslation->getLang()->value
1129.         ] = $metadataTranslation;
1131.         return $this;
1132.     }
1134.     public function deleteMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1135.     {
1136.         $this->metadataTranslations->removeElement($metadataTranslation);
1138.         return $this;
1139.     }
1141.     public function resetMetadataTranslations(): self
1142.     {
1143.         $this->metadataTranslations = new ArrayCollection();
1145.         return $this;
1146.     }
1148.     public function readMetadataTranslation(null|string|Language $lang, string $property): mixed
1149.     {
1150.         if (! $lang) {
1151.             return null;
1152.         }
1154.         $lang = is_string($lang)
1155.             ? Language::from($lang)
1156.             : $lang;
1158.         if (! isset($this->metadataTranslations[$lang->value])) {
1159.             return null;
1160.         }
1162.         if (! str_contains($property, '.')) {
1163.             return $this->metadataTranslations[$lang->value]->{'get' . ucfirst($property)}();
1164.         }
1166.         $path = explode('.', $property);
1167.         $current = array_shift($path);
1169.         return $this->readProperty(
1170.             object: $this->metadataTranslations[$lang->value]->{'get'. ucfirst($current)}(),
1171.             path: $path
1172.         );
1173.     }
1175.     public function readAvailableMetadataTranslation(
1176.         string|Language $lang,
1177.         string $property,
1178.         bool $isNotEmpty = true
1179.     ): mixed {
1180.         $lang = is_string($lang)
1181.             ? Language::from($lang)
1182.             : $lang;
1184.         if (! $this->isLanguageAvailable($lang, $this->metadataLanguages)) {
1185.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1186.         }
1188.         $value = $this->readMetadataTranslation($lang, $property);
1190.         if ($isNotEmpty && empty($value)) {
1191.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1192.         }
1194.         return $value;
1195.     }
1197.     private function isLanguageAvailable(Language $lang, ?array $languages): bool
1198.     {
1199.         return ! $languages || in_array($lang, $languages);
1200.     }
1202.     /**
1203.      * @return Collection|JournalArticleClassification[]
1204.      */
1205.     public function getClassifications(): Collection
1206.     {
1207.         return $this->classifications;
1208.     }
1210.     public function getVisibleClassifications(): Collection
1211.     {
1212.         return $this->getClassifications()->filter(
1213.             fn(JournalArticleClassification $classification) => $classification->getType()->getStat() === true
1214.         );
1215.     }
1217.     public function addClassification(JournalArticleClassification $classification): self
1218.     {
1219.         if ($this->classifications->contains($classification)) {
1220.             return $this;
1221.         }
1223.         $this->classifications[] = $classification;
1225.         return $this;
1226.     }
1228.     public function removeClassification(JournalArticleClassification $classification): self
1229.     {
1230.         $this->classifications->removeElement($classification);
1232.         return $this;
1233.     }
1235.     public function resetClassifications(): self
1236.     {
1237.         $this->classifications = new ArrayCollection();
1239.         return $this;
1240.     }
1242.     /**
1243.      * @return Collection|JournalArticleResearchData[]
1244.      */
1245.     public function getResearchDatas(): Collection
1246.     {
1247.         return $this->researchDatas;
1248.     }
1250.     public function addResearchData(JournalArticleResearchData $researchData): self
1251.     {
1252.         if ($this->researchDatas->contains($researchData)) {
1253.             return $this;
1254.         }
1256.         $this->researchDatas[] = $researchData;
1258.         return $this;
1259.     }
1261.     public function removeResearchData(JournalArticleResearchData $researchData): self
1262.     {
1263.         $this->researchDatas->removeElement($researchData);
1265.         return $this;
1266.     }
1268.     public function resetResearchDatas(): self
1269.     {
1270.         $this->researchDatas = new ArrayCollection();
1272.         return $this;
1273.     }
1275.     /**
1276.      * @return Collection|JournalArticleRelationship[]
1277.      */
1278.     public function getRelationships(): Collection
1279.     {
1280.         return $this->relationships;
1281.     }
1283.     public function addRelationship(JournalArticleRelationship $relationship): self
1284.     {
1285.         if ($this->relationships->contains($relationship)) {
1286.             return $this;
1287.         }
1289.         $this->relationships[] = $relationship;
1291.         return $this;
1292.     }
1294.     public function removeRelationship(JournalArticleRelationship $relationship): self
1295.     {
1296.         $this->relationships->removeElement($relationship);
1298.         return $this;
1299.     }
1301.     public function resetRelationships(): self
1302.     {
1303.         $this->relationships = new ArrayCollection();
1305.         return $this;
1306.     }
1308.     /**
1309.      * @return Collection|JournalArticleContentBlock[]
1310.      */
1311.     public function getContentBlocks(): Collection
1312.     {
1313.         return $this->contentBlocks;
1314.     }
1316.     public function getVisibleContentBlocks(): Collection
1317.     {
1318.         return $this->contentBlocks->filter(
1319.             fn (JournalArticleContentBlock $block) => $block->getStat() === true
1320.         );
1321.     }
1323.     public function addContentBlock(JournalArticleContentBlock $contentBlock): self
1324.     {
1325.         if ($this->contentBlocks->contains($contentBlock)) {
1326.             return $this;
1327.         }
1329.         $this->contentBlocks[] = $contentBlock;
1331.         return $this;
1332.     }
1334.     public function removeContentBlock(JournalArticleContentBlock $contentBlock): self
1335.     {
1336.         $this->contentBlocks->removeElement($contentBlock);
1338.         return $this;
1339.     }
1341.     public function resetContentBlocks(): self
1342.     {
1343.         $this->contentBlocks = new ArrayCollection();
1345.         return $this;
1346.     }
1348.     /**
1349.      * @return Collection|JournalArticleAddditionalBlock[]
1350.      */
1351.     public function getAdditionalBlocks(): Collection
1352.     {
1353.         return $this->additionalBlocks;
1354.     }
1356.     public function getVisibleAdditionalBlocks(): Collection
1357.     {
1358.         return $this->additionalBlocks->filter(
1359.             fn (JournalArticleAdditionalBlock $block) => $block->getStat() === true
1360.         );
1361.     }
1363.     public function addAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1364.     {
1365.         if ($this->additionalBlocks->contains($additionalBlock)) {
1366.             return $this;
1367.         }
1369.         $this->additionalBlocks[] = $additionalBlock;
1371.         return $this;
1372.     }
1374.     public function removeAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1375.     {
1376.         $this->additionalBlocks->removeElement($additionalBlock);
1378.         return $this;
1379.     }
1381.     public function resetAdditionalBlocks(): self
1382.     {
1383.         $this->additionalBlocks = new ArrayCollection();
1385.         return $this;
1386.     }
1388.     /**
1389.      * @return Collection|JournalArticleBibliographyEntry[]
1390.      */
1391.     public function getBibliographyEntries(): Collection
1392.     {
1393.         return $this->bibliographyEntries;
1394.     }
1396.     public function addBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1397.     {
1398.         if ($this->bibliographyEntries->contains($bibliographyEntry)) {
1399.             return $this;
1400.         }
1402.         $this->bibliographyEntries[] = $bibliographyEntry;
1404.         return $this;
1405.     }
1407.     public function removeBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1408.     {
1409.         $this->bibliographyEntries->removeElement($bibliographyEntry);
1411.         return $this;
1412.     }
1414.     public function resetBibliographyEntries(): self
1415.     {
1416.         $this->bibliographyEntries = new ArrayCollection();
1418.         return $this;
1419.     }
1421.     public function importBibliography(): self
1422.     {
1423.         $nativeLanguage = $this->getParentNativeLanguage();
1424.         $nativeTranslation = $this->getTranslation($nativeLanguage);
1426.         if (! $nativeTranslation?->getImportedBibliography()) {
1427.             return $this;
1428.         }
1430.         $otherLanguages = array_filter(
1431.             $this->getParentLanguages(),
1432.             fn(Language $lang) => $nativeLanguage !== $lang
1433.         );
1435.         $imported = [];
1437.         foreach([$nativeLanguage] + $otherLanguages as $lang) {
1438.             $imported[$lang->value] = $this->getImportedBibliographyEntries($lang);
1439.         }
1441.         $this->resetBibliographyEntries();
1443.         $ord = count($imported[$nativeLanguage->value]);
1445.         foreach($imported[$nativeLanguage->value] as $key => $title) {
1446.             preg_match('/10.\d{4,9}\/[-._;()\/:A-Z0-9]+$/i', $title, $doi);
1448.             $entry = new JournalArticleBibliographyEntry($this);
1449.             $entry
1450.                 ->setDoi($doi[0] ?? null)
1451.                 ->setOrd($ord--);
1453.             $translation = $entry->getTranslation($nativeLanguage);
1454.             $translation->setTitle($title);
1456.             $this->fillBibliographyEntryTranslations(
1457.                 entry: $entry,
1458.                 languages: $otherLanguages,
1459.                 imported: $imported,
1460.                 key: $key
1461.             );
1462.         }
1464.         return $this;
1465.     }
1467.     private function getImportedBibliographyEntries(Language $lang): array
1468.     {
1469.         $importedBibliography = $this->getTranslation($lang)?->getImportedBibliography() ?? '';
1471.         $bibliographyEntries = array_map(
1472.             fn(string $bibliograpyEntry) => trim($bibliograpyEntry),
1473.             preg_split('/\r\n|\r|\n|<br>|<br \/>|<br\/>/', $importedBibliography)
1474.         );
1476.         $bibliographyEntries = array_filter(
1477.             $bibliographyEntries,
1478.             fn(string $bibliograpyEntry) => ! empty($bibliograpyEntry)
1479.         );
1481.         return $bibliographyEntries;
1482.     }
1484.     private function fillBibliographyEntryTranslations(
1485.         JournalArticleBibliographyEntry $entry,
1486.         array $languages,
1487.         array $imported,
1488.         int $key
1489.     ): self {
1490.         foreach($languages as $language) {
1491.             $translation = $entry->getTranslation($language);
1492.             $translation->setTitle($imported[$language->value][$key] ?? null);
1493.         }
1495.         return $this;
1496.     }
1498.     /**
1499.      * @return Collection|JournalArticleFile[]
1500.      */
1501.     public function getFiles(): Collection
1502.     {
1503.         return $this->files;
1504.     }
1506.     public function addFile(JournalArticleFile $file): self
1507.     {
1508.         if ($this->files->contains($file)) {
1509.             return $this;
1510.         }
1512.         $this->files[] = $file;
1514.         return $this;
1515.     }
1517.     public function removeFile(JournalArticleFile $file): self
1518.     {
1519.         $this->files->removeElement($file);
1521.         return $this;
1522.     }
1524.     public function resetFiles(): self
1525.     {
1526.         $this->files = new ArrayCollection();
1528.         return $this;
1529.     }
1531.     #[Groups(['read:' . self::class])]
1532.     public function getHasFiles(): bool
1533.     {
1534.         foreach($this->files as $file) {
1535.             if (! $file->getHasFiles()) {
1536.                 continue;
1537.             }
1539.             return true;
1540.         }
1542.         return false;
1543.     }
1545.     public function getFullTextFile(): ?JournalArticleFile
1546.     {
1547.         foreach($this->files as $file) {
1548.             if (! $file->getStat() || $file->getType() !== JournalArticleFileType::FULL_TEXT) {
1549.                 continue;
1550.             }
1552.             return $file;
1553.         }
1555.         return null;
1556.     }
1558.     public function getFullTextTranslationFile(string|Language $lang): ?JournalArticleFileTranslationFile
1559.     {
1560.         $fullText = $this->getFullTextFile();
1562.         if (! $fullText) {
1563.             return null;
1564.         }
1566.         $lang = is_string($lang)
1567.             ? Language::from($lang)
1568.             : $lang;
1570.         $files = $fullText->readAvailableTranslation($lang, 'files');
1572.         return ($first = $files->first()) === false ? null : $first;
1573.     }
1575.     /** @return <int, JournalArticleFileTranslationFile> */
1576.     public function getAdditionalFiles(string|Language $lang): array
1577.     {
1578.         $lang = is_string($lang)
1579.             ? Language::from($lang)
1580.             : $lang;
1581.         $files = [];
1583.         foreach($this->files as $file) {
1584.             if (!$file->getStat() || $file->getType() === JournalArticleFileType::FULL_TEXT) {
1585.                 continue;
1586.             }
1588.             $files[] = $file;
1589.         }
1591.         $finalFiles = [];
1593.         /** @var JournalArticleFile $file */
1594.         foreach ($files as $file) {
1595.             /** @var JournalArticleFileTranslation $trans */
1596.             $files = $file->readAvailableTranslation($lang, 'files');
1597.             if (!$files) {
1598.                 continue;
1599.             }
1601.             foreach ($files as $finalFile) {
1602.                 if (!$finalFile->getMedia() || !$finalFile->getTitle()) {
1603.                     continue;
1604.                 }
1606.                 $finalFiles[] = $finalFile;
1607.             }
1608.         }
1610.         return $finalFiles;
1611.     }
1613.     public function getFileByType(JournalArticleFileType $type): ?JournalArticleFile
1614.     {
1615.         return $this->files->findFirst(
1616.             fn(int $key, JournalArticleFile $file) => $file->getType() === $type
1617.         );
1618.     }
1620.     /**
1621.      * @return Collection|JournalArticleAuthor[]
1622.      */
1623.     public function getAuthors(): Collection
1624.     {
1625.         return $this->authors;
1626.     }
1628.     public function setAuthors(array $authors): self
1629.     {
1630.         foreach ($authors as $author) {
1631.             $this->authors[] = $author;
1632.         }
1634.         return $this;
1635.     }
1637.     public function addAuthor(JournalArticleAuthor $author): self
1638.     {
1639.         if ($this->authors->contains($author)) {
1640.             return $this;
1641.         }
1643.         $this->authors[] = $author;
1645.         return $this;
1646.     }
1648.     public function removeAuthor(JournalArticleAuthor $author): self
1649.     {
1650.         $this->authors->removeElement($author);
1652.         return $this;
1653.     }
1655.     public function resetAuthors(): self
1656.     {
1657.         $this->authors = new ArrayCollection();
1659.         return $this;
1660.     }
1662.     public function getVisibleAuthors(string|Language $lang, ?Author $highlightAuthor = null): array
1663.     {
1664.         $lang = ! is_string($lang)
1665.             ? $lang
1666.             : Language::from($lang);
1668.         $authors = $this->getVisibleAuthorsByRole($lang, JournalArticleAuthorRole::AUTHOR);
1670.         if (null !== $highlightAuthor) {
1671.             $authors = [
1672.                 $highlightAuthor,
1673.                 ...array_filter(
1674.                     $authors,
1675.                     fn(JournalArticleAuthor $author) => $author->getAuthor()->getUuid() === $highlightAuthor->getUuid()
1676.                 )
1677.             ];
1678.         }
1680.         return $authors;
1681.     }
1683.     public function getVisibleAuthorsByRole(string|Language $lang, JournalArticleAuthorRole|string $type): array
1684.     {
1685.         $lang = ! is_string($lang)
1686.             ? $lang
1687.             : Language::from($lang);
1689.         $type = is_string($type)
1690.             ? JournalArticleAuthorRole::from($type)
1691.             : $type;
1693.         $isNameVisible = in_array(AuthorProperty::NAME, $this->visibleAuthorProperties);
1694.         $isSurnameVisible = in_array(AuthorProperty::SURNAME, $this->visibleAuthorProperties);
1696.         if (! $isNameVisible && ! $isSurnameVisible) {
1697.             return [];
1698.         }
1700.         return $this->getAuthors()->filter(
1701.             fn(JournalArticleAuthor $author) => $author->getRole() === $type
1702.         )->toArray();
1703.     }
1705.     public function getIssueRedactors(): array
1706.     {
1707.         if ($this->redactors) {
1708.             return $this->redactors;
1709.         }
1711.         $this->redactors = [];
1713.         foreach($this->issue?->getEditorialGroups() as $group) {
1714.             foreach($group->getMembers() as $member) {
1715.                 if (in_array($member, $this->redactors)) {
1716.                     continue;
1717.                 }
1719.                 $this->redactors[] = $member;
1720.             }
1721.         }
1723.         return $this->redactors;
1724.     }
1726.     // -----
1727.     // STATS
1728.     // -----
1730.     /**
1731.      * @return Collection|JournalArticleViewEntry[]
1732.      */
1733.     public function getViewEntries(): Collection
1734.     {
1735.         return $this->viewEntries;
1736.     }
1738.     public function addViewEntry(JournalArticleViewEntry $viewEntry): self
1739.     {
1740.         if ($this->viewEntries->contains($viewEntry)) {
1741.             return $this;
1742.         }
1744.         $this->viewEntries[] = $viewEntry;
1746.         return $this;
1747.     }
1749.     public function removeViewEntry(JournalArticleViewEntry $viewEntry): self
1750.     {
1751.         $this->viewEntries->removeElement($viewEntry);
1753.         return $this;
1754.     }
1756.     public function resetViewEntries(): self
1757.     {
1758.         $this->viewEntries = new ArrayCollection();
1760.         return $this;
1761.     }
1763.     /**
1764.      * @return Collection|JournalArticleDownloadEntry[]
1765.      */
1766.     public function getDownloadEntries(): Collection
1767.     {
1768.         return $this->downloadEntries;
1769.     }
1771.     public function addDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1772.     {
1773.         if ($this->downloadEntries->contains($downloadEntry)) {
1774.             return $this;
1775.         }
1777.         $this->downloadEntries[] = $downloadEntry;
1779.         return $this;
1780.     }
1782.     public function removeDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1783.     {
1784.         $this->downloadEntries->removeElement($downloadEntry);
1786.         return $this;
1787.     }
1789.     public function resetDownloadEntries(): self
1790.     {
1791.         $this->downloadEntries = new ArrayCollection();
1793.         return $this;
1794.     }
1796.     public function getSlugTitleLanguage(): ?Language
1797.     {
1798.         if (!$this->slugTitleLanguage) {
1799.             if (isset($this->getPublicationLanguages()[0]) && in_array($this->getPublicationLanguages()[0], $this->getMetadataLanguages())) {
1800.                 return $this->getPublicationLanguages()[0];
1801.             }
1803.             return $this->nativeMetadataLanguage;
1804.         }
1806.         return $this->slugTitleLanguage;
1807.     }
1809.     public function setSlugTitleLanguage(?Language $slugTitleLanguage): self
1810.     {
1811.         if ($this->slugTitleLanguage !== $slugTitleLanguage && $slugTitleLanguage !== null) {
1812.             $this->slugTitleLanguage = $slugTitleLanguage;
1814.             foreach ($this->getMetadataTranslations() as $metadataTranslation) {
1815.                 $metadataTranslation->setTitle($metadataTranslation->getTitle());
1816.             }
1817.         } else {
1818.             $this->slugTitleLanguage = $slugTitleLanguage;
1819.         }
1821.         return $this;
1822.     }
1824.     /**
1825.      * @return Collection<int, JournalArticleSlugHistory>
1826.      */
1827.     public function getSlugHistory(): Collection
1828.     {
1829.         return $this->slugHistory;
1830.     }
1832.     public function addCurrentSlugToHistory(): void
1833.     {
1834.         // check if already in history
1835.         foreach ($this->slugHistory as $entry) {
1836.             if ($entry->getSlug() === $this->slug) {
1837.                 return;
1838.             }
1839.         }
1841.         $entry = new JournalArticleSlugHistory($this, $this->slug);
1842.         $this->addSlugHistory($entry);
1843.     }
1845.     public function addSlugHistory(JournalArticleSlugHistory $slugHistory): self
1846.     {
1847.         if (!$this->slugHistory->contains($slugHistory)) {
1848.             $this->slugHistory->add($slugHistory);
1849.         }
1851.         return $this;
1852.     }
1854.     public function removeSlugHistory(JournalArticleSlugHistory $slugHistory): self
1855.     {
1856.         $this->slugHistory->removeElement($slugHistory);
1858.         return $this;
1859.     }
1861.     #[Groups(['read:stats'])]
1862.     public function getStatsAuthors(): ?string
1863.     {
1864.         $authors = [];
1866.         /** @var JournalArticleAuthor */
1867.         foreach($this->authors as $entry) {
1868.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1869.                 continue;
1870.             }
1872.             $author = $entry->getAuthor();
1874.             $authors[] = $author->getFullName();
1875.         }
1877.         return implode(', ', $authors);
1878.     }
1880.     #[Groups(['read:stats'])]
1881.     public function getStatsAuthorsAffiliations(): ?string
1882.     {
1883.         $affiliations = [];
1885.         /** @var JournalArticleAuthor */
1886.         foreach($this->authors as $entry) {
1887.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1888.                 continue;
1889.             }
1891.             $author = $entry->getAuthor();
1893.             /** @var Affiliation */
1894.             foreach($author->getAffiliations() as $affiliation) {
1895.                 if(isset($affiliations[$affiliation->getUuid()->toString()])) {
1896.                     continue;
1897.                 }
1899.                 $affiliations[$affiliation->getUuid()->toString()] = $affiliation->readNativeLanguageTranslation('title');
1900.             }
1901.         }
1903.         return implode(', ',  $affiliations);
1904.     }
1906.     #[Groups(['read:stats'])]
1907.     public function getStatsAuthorsCountries(): ?string
1908.     {
1909.         $countries = [];
1911.         /** @var JournalArticleAuthor */
1912.         foreach($this->authors as $entry) {
1913.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1914.                 continue;
1915.             }
1917.             $author = $entry->getAuthor();
1919.             /** @var Affiliation */
1920.             foreach($author->getAffiliations() as $affiliation) {
1921.                 if (! $affiliation->getCountry()) {
1922.                     continue;
1923.                 }
1925.                 if(isset($countries[$affiliation->getCountry()->value])) {
1926.                     continue;
1927.                 }
1929.                 $countries[$affiliation->getCountry()->value] = $affiliation->getCountry()->value;
1930.             }
1931.         }
1933.         return implode(', ',  $countries);
1934.     }
1936.     #[Groups(['read:stats'])]
1937.     public function getStatsTranslators(): ?string
1938.     {
1939.         $authors = [];
1941.         /** @var JournalArticleAuthor */
1942.         foreach($this->authors as $entry) {
1943.             if ($entry->getRole() !== JournalArticleAuthorRole::TRANSLATOR) {
1944.                 continue;
1945.             }
1947.             $author = $entry->getAuthor();
1949.             $authors[] = $author->getFullName();
1950.         }
1952.         return implode(', ', $authors);
1953.     }
1955.     #[Groups(['read:stats'])]
1956.     public function getStatsJournal(): string
1957.     {
1958.         return $this->parent->readNativeLanguageTranslation('title');
1959.     }
1961.     #[Groups(['read:stats'])]
1962.     public function getStatsJournalAffiliations(): string
1963.     {
1964.         $affiliations = [];
1966.         /** @var JournalAffiliation */
1967.         foreach($this->parent->getAffiliations() as $entry) {
1968.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
1969.                 continue;
1970.             }
1972.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
1973.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
1974.         }
1976.         return implode(', ',  $affiliations);
1977.     }
1979.     #[Groups(['read:stats'])]
1980.     public function getStatsIssue(): string
1981.     {
1982.         return $this->issue->readNativeLanguageTranslation('title');
1983.     }
1985.     #[Groups(['read:stats'])]
1986.     public function getStatsVolume(): string
1987.     {
1988.         return $this->issue->getVolume()->readNativeLanguageTranslation('title');
1989.     }
1991.     #[Groups(['read:stats'])]
1992.     public function getStatsIssueFundingDescription(): ?string
1993.     {
1994.         return $this->issue->readNativeLanguageTranslation('fundingDescription');
1995.     }
1997.     #[Groups(['read:stats'])]
1998.     public function getStatsVolumeFundingDescription(): ?string
1999.     {
2000.         return $this->issue->getVolume()->readNativeLanguageTranslation('fundingDescription');
2001.     }
2003.     #[Groups(['read:stats'])]
2004.     public function getStatsSection(): ?string
2005.     {
2006.         return $this->section?->readNativeLanguageTranslation('title');
2007.     }
2009.     #[Groups(['read:stats'])]
2010.     public function getStatsKeywords(): ?string
2011.     {
2012.         $keywords = [];
2014.         $entries = $this->readMetadataTranslation($this->nativeMetadataLanguage, 'keywords');
2016.         /** @var JournalArticleMetadataTranslationKeyword */
2017.         foreach($entries as $entry) {
2018.             $keywords[] = $entry->getTitle();
2019.         }
2021.         return implode(', ', $keywords);
2022.     }
2024.     public function clone(): self
2025.     {
2026.         $clone = clone $this;
2028.         $clone->id = null;
2029.         $clone->setUuid();
2031.         $clone->ord = 0;
2032.         $clone->stat = false;
2033.         $clone->importId = null;
2035.         ClassUtils::cloneCollection($this, $clone, 'translations');
2036.         $clone->synchronizeTranslations();
2038.         $nativeLanguage = $clone->parent->getNativeLanguage();
2039.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
2040.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
2042.         ClassUtils::cloneCollection($this, $clone, 'classifications');
2043.         ClassUtils::cloneCollection($this, $clone, 'researchDatas');
2044.         ClassUtils::cloneCollection($this, $clone, 'contentBlocks');
2046.         $clone->statsAmountOfViews = 0;
2047.         $clone->statsAmountOfDownloads = 0;
2049.         $clone
2050.             ->resetAdditionalBlocks()
2051.             ->resetBibliographyEntries()
2052.             ->resetFiles()
2053.             ->resetAuthors()
2054.             ->resetViewEntries()
2055.             ->resetDownloadEntries();
2057.         $clone->createdAt = new \DateTimeImmutable();
2058.         $clone->updatedAt = new \DateTimeImmutable();
2060.         return $clone;
2061.     }
2062. }