1. <?php
2. namespace App\Entity;
4. use App\StateProvider\JournalArticleAutocompleteProvider;
5. use Doctrine\ORM\Mapping as ORM,
6.     Doctrine\DBAL\Types\Types,
7.     Doctrine\Common\Collections\Collection,
8.     Doctrine\Common\Collections\ArrayCollection;
10. use Doctrine\ORM\Mapping\Index;
11. use Gedmo\Mapping\Annotation as Gedmo;
13. use Symfony\Component\Serializer\Annotation\Groups,
14.     Symfony\Component\Validator\Constraints as Assert;
16. use ApiPlatform\Metadata\ApiResource,
17.     ApiPlatform\Metadata\ApiProperty,
18.     ApiPlatform\Metadata\Get,
19.     ApiPlatform\Metadata\GetCollection,
20.     ApiPlatform\Metadata\Post,
21.     ApiPlatform\Metadata\Put,
22.     ApiPlatform\Metadata\Delete,
23.     ApiPlatform\Metadata\ApiFilter,
24.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
25.     ApiPlatform\Doctrine\Orm\Filter\DateFilter,
26.     ApiPlatform\Doctrine\Orm\Filter\ExistsFilter,
27.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter,
28.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
29.     ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
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\LanguageableChildTrait,
37.     App\Entity\Trait\ArchivedTrait,
38.     App\Entity\Trait\ImportIdTrait,
39.     App\Entity\Interface\TranslatableInterface,
40.     App\Entity\Interface\OrdStatableInterface,
41.     App\Entity\Interface\LanguageableChildInterface,
42.     App\Entity\Interface\ArchivableInterface,
43.     App\Entity\Interface\CloneableInterface;
45. use App\Enum\JournalDateFormat,
46.     App\Enum\JournalArticleType,
47.     App\Enum\JournalLicence,
48.     App\Enum\JournalArticleFileType,
49.     App\Enum\AuthorProperty,
50.     App\Enum\JournalArticleAuthorRole,
51.     App\Doctrine\DBAL\Types\AuthorPropertiesType,
52.     App\Repository\JournalArticleRepository,
53.     App\Security\Voter\ArchivableVoter,
54.     App\Lib\Actions,
55.     App\DTO\CloneDTO,
56.     App\StateProcessor\CloneProcessor,
57.     App\Security\Voter\CloneVoter,
58.     App\Filter\IriFilter,
59.     App\Doctrine\DBAL\Types\LanguagesType;
61. use App\Util\ClassUtils,
62.     App\Enum\Language,
63.     App\Attribute\DenormalizationInject;
65. use App\Controller\Export\JournalArticle\JournalArticleCrossrefExporter,
66.     App\Controller\Export\JournalArticle\JournalArticleSimcheckCrossrefExporter,
67.     App\Controller\Export\JournalArticle\JournalArticleFundingCrossrefExporter,
68.     App\Controller\Export\JournalArticle\JournalArticleLicenceFulltextCrossrefExporter,
69.     App\Controller\Export\JournalArticle\JournalArticleReferencesCrossrefExporter,
70.     App\Controller\Export\JournalArticle\JournalArticleJATSExporter;
72. use App\Controller\Stats\StatsJournalArticleXlsxGenerator;
73. use App\StateProvider\StatsJournalArticleProvider;
74. use Symfony\Component\Serializer\Annotation\MaxDepth;
76. #[ApiResource(
77.     description: 'Journal articles',
78.     normalizationContext: ['groups' => [
79.         'read',
80.         'read:' . self::class,
81.         'read:' . self::class . 'Translation',
82.         'read:' . self::class . 'MetadataTranslation'
83.     ]],
84.     denormalizationContext: ['groups' => ['write']],
85.     security: 'is_granted("' . Journal::class . '")',
86.     order: ['ord' => 'desc'],
87.     operations: [
88.         new GetCollection(paginationMaximumItemsPerPage: 500, normalizationContext: ['groups' => ['read:minimal']]),
89.         new GetCollection(
90.             uriTemplate: '/journal_articles/autocomplete',
91.             provider: JournalArticleAutocompleteProvider::class,
92.             normalizationContext: ['groups' => ['read:autocomplete']],
93.         ),
94.         new GetCollection(
95.             name: 'get_journal_article_stats',
96.             uriTemplate: '/journal_articles/stats',
97.             provider: StatsJournalArticleProvider::class,
98.             security: 'is_granted("ROLE_MODULE_STATS")',
99.             normalizationContext: ['groups' => ['read:stats']],
100.             paginationMaximumItemsPerPage: 500
101.         ),
102.         new GetCollection(
103.             name: 'get_journal_article_stats_xlsx',
104.             uriTemplate: '/journal_articles/stats/xlsx',
105.             provider: StatsJournalArticleProvider::class,
106.             controller: StatsJournalArticleXlsxGenerator::class,
107.             security: 'is_granted("ROLE_MODULE_STATS")',
108.         ),
109.         new Post(
110.             uriTemplate: '/journal_articles/clone',
111.             input: CloneDTO::class,
112.             processor: CloneProcessor::class,
113.             security: 'is_granted("' . Actions::CLONE .'")',
114.             securityMessage: CloneVoter::MESSAGE
115.         ),
116.         new Post(denormalizationContext: ['groups' => ['write',  'post']]),
117.         new Get(),
118.         new Get(
119.             name: 'get_journal_article_crossref',
120.             uriTemplate: '/journal_articles/{uuid}/export/crossref',
121.             controller: JournalArticleCrossrefExporter::class
122.         ),
123.         new Get(
124.             name: 'get_journal_article_jats',
125.             uriTemplate: '/journal_articles/{uuid}/export/jats',
126.             controller: JournalArticleJATSExporter::class
127.         ),
128.         new Get(
129.             name: 'get_journal_article_simcheck_crossref',
130.             uriTemplate: '/journal_articles/{uuid}/export/simcheck_crossref',
131.             controller: JournalArticleSimcheckCrossrefExporter::class
132.         ),
133.         new Get(
134.             name: 'get_journal_article_funding_crossref',
135.             uriTemplate: '/journal_articles/{uuid}/export/funding_crossref',
136.             controller: JournalArticleFundingCrossrefExporter::class
137.         ),
138.         new Get(
139.             name: 'get_journal_article_licence_fulltext_crossref',
140.             uriTemplate: '/journal_articles/{uuid}/export/licence_fulltext_crossref',
141.             controller: JournalArticleLicenceFulltextCrossrefExporter::class
142.         ),
143.         new Get(
144.             name: 'get_journal_article_references_crossref',
145.             uriTemplate: '/journal_articles/{uuid}/export/references_crossref',
146.             controller: JournalArticleReferencesCrossrefExporter::class
147.         ),
148.         new Put(),
149.         new Delete(
150.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
151.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
152.         ),
153.     ],
154.     extraProperties: ['standard_put' => false],
155. )]
156. #[ApiFilter(SearchFilter::class, properties: [
157.     'translations.title' => 'partial',
158.     'nativeTitle' => 'partial',
159.     'workingTitle' => 'partial',
160.     'uuid' => 'exact',
161. ])]
162. #[ApiFilter(ExistsFilter::class, properties: ['doi'])]
163. #[ApiFilter(IriFilter::class, properties: [
164.     'parent',
165.     'issue',
166.     'type',
167.     'section'
168. ])]
169. #[ApiFilter(DateFilter::class, properties: ['updatedAt'])]
170. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
171. #[ApiFilter(RangeFilter::class, properties: ['statsAmountOfViews', 'statsAmountOfDownloads'])]
172. #[ApiFilter(OrderFilter::class, properties: [
173.     'nativeTitle',
174.     'doi',
175.     'pageFrom',
176.     'isOpen',
177.     'onlinePublishedAt',
178.     'updatedAt',
179.     'receivedAt',
180.     'acceptedAt',
181.     'nativeMetadataLanguage',
182.     'parent.nativeTitle',
183.     'issue.nativeTitle',
184.     'issue.volume.nativeTitle',
185.     'section.nativeTitle',
186.     'ord',
187.     'statsAmountOfViews',
188.     'statsAmountOfDownloads'
189. ])]
190. #[Index(fields: ["importId"], name: "import_id_idx")]
191. #[Index(fields: ["stat"], name: "stat_idx")]
192. #[ORM\Entity(repositoryClass: JournalArticleRepository::class)]
193. class JournalArticle implements
194.     TranslatableInterface,
195.     OrdStatableInterface,
196.     LanguageableChildInterface,
197.     ArchivableInterface,
198.     CloneableInterface
199. {
200.     use IdTrait,
201.         UuidTrait,
202.         OrdStatTrait,
203.         TimestampableTrait,
204.         TranslatableTrait,
205.         LanguageableChildTrait,
206.         ArchivedTrait,
207.         ImportIdTrait;
209.     const DEFAULT_FILES = [
210.         JournalArticleFileType::BIBLIOGRAPHY,
211.         JournalArticleFileType::ABSTRACT_TEXT,
212.         JournalArticleFileType::FULL_TEXT
213.     ];
215.     #[ApiProperty(description: 'Parent', writableLink: false)]
216.     #[Groups(['read', 'post'])]
217.     #[ORM\ManyToOne(targetEntity: Journal::class, inversedBy: 'articles')]
218.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
219.     private Journal $parent;
221.     #[ApiProperty(description: 'Native title')]
222.     #[Groups(['read', 'read:stats', 'read:autocomplete'])]
223.     #[ORM\Column(type: Types::TEXT, nullable: true)]
224.     private ?string $nativeTitle = null;
226.     #[ApiProperty(description: 'Native title raw')]
227.     #[Groups(['read'])]
228.     #[ORM\Column(type: Types::TEXT, nullable: true)]
229.     private ?string $nativeTitleRaw = null;
231.     #[ApiProperty(description: 'Working title')]
232.     #[Groups(['read', 'read:minimal', 'write'])]
233.     #[Assert\NotBlank]
234.     #[ORM\Column(type: Types::STRING, length: 511)]
235.     private string $workingTitle;
237.     #[ApiProperty(description: 'Licence', writableLink: false)]
238.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
239.     #[ORM\Column(
240.         type: Types::STRING,
241.         enumType: JournalLicence::class,
242.         length: 255,
243.         options: ['default' => JournalLicence::CC_BY]
244.     )]
245.     private JournalLicence $licence = JournalLicence::CC_BY;
247.     #[ApiProperty(description: 'Issue', writableLink: false, fetchEager: false)]
248.     #[Groups(['read', 'write'])]
249.     #[Assert\NotNull]
250.     #[Assert\Expression(
251.         expression: '!this || value.getParent() === this.getParent()',
252.         message: 'Cannot assign issue from the outside of current journal.'
253.     )]
254.     #[ORM\ManyToOne(targetEntity: JournalIssue::class, inversedBy: 'articles')]
255.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
256.     private JournalIssue $issue;
258.     #[ApiProperty(description: 'Funding number')]
259.     #[Groups(['read:' . self::class, 'write'])]
260.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
261.     private ?string $fundingNumber = null;
263.     #[ApiProperty(description: 'Type', writableLink: false)]
264.     #[Groups(['read', 'read:minimal', 'read:stats', 'write'])]
265.     #[ORM\Column(
266.         type: Types::STRING,
267.         enumType: JournalArticleType::class,
268.         length: 255,
269.         options: ['default' => JournalArticleType::ORIGINAL_RESEARCH_ARTICLE
270.     ])]
271.     private JournalArticleType $type = JournalArticleType::ORIGINAL_RESEARCH_ARTICLE;
273.     #[ApiProperty(description: 'Section', writableLink: false, fetchEager: false)]
274.     #[Groups(['read:' . self::class, 'read:minimal', 'write'])]
275.     #[MaxDepth(1)]
276.     #[ORM\ManyToOne(targetEntity: JournalSection::class)]
277.     #[ORM\JoinColumn(onDelete: 'set null')]
278.     private ?JournalSection $section = null;
280.     #[ApiProperty(description: 'DOI')]
281.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
282.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
283.     private ?string $doi = null;
285.     #[ApiProperty(description: 'Page from')]
286.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
287.     // #[Assert\Positive]
288.     #[ORM\Column(type: Types::STRING, nullable: true)] //, options: ['default' => 1])]
289.     private ?string $pageFrom = null;
291.     #[ApiProperty(description: 'Page to')]
292.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
293.     // #[Assert\Expression(
294.     //     expression: 'value >= this.getPageFrom()',
295.     //     message: 'Page to must be greater than page from.'
296.     // )]
297.     #[ORM\Column(type: Types::STRING, nullable: true)] //INTEGER, options: ['default' => 1])]
298.     private ?string $pageTo = null;
300.     #[ApiProperty(description: 'Citation type', writableLink: false)]
301.     #[Groups(['read:' . self::class, 'write'])]
302.     #[ORM\ManyToOne(targetEntity: CitationType::class)]
303.     #[ORM\JoinColumn(onDelete: 'set null')]
304.     private ?CitationType $citationType = null;
306.     #[ApiProperty(description: 'Citation')]
307.     #[Groups(['read:' . self::class, 'write'])]
308.     #[ORM\Column(type: Types::TEXT, nullable: true)]
309.     private ?string $citation = null;
311.     #[ApiProperty(description: 'Received at')]
312.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
313.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
314.     private ?\DateTimeImmutable $receivedAt = null;
316.     #[ApiProperty(description: 'Received at format', writableLink: false)]
317.     #[Groups(['read:' . self::class, 'write'])]
318.     #[ORM\Column(
319.         type: Types::STRING,
320.         enumType: JournalDateFormat::class,
321.         length: 255,
322.         options: ['default' => JournalDateFormat::COMPLETE]
323.     )]
324.     private JournalDateFormat $receivedAtFormat = JournalDateFormat::COMPLETE;
326.     #[ApiProperty(description: 'Accepted at')]
327.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
328.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
329.     private ?\DateTimeImmutable $acceptedAt = null;
331.     #[ApiProperty(description: 'Accepted at format', writableLink: false)]
332.     #[Groups(['read:' . self::class, 'write'])]
333.     #[ORM\Column(
334.         type: Types::STRING,
335.         enumType: JournalDateFormat::class,
336.         length: 255,
337.         options: ['default' => JournalDateFormat::COMPLETE]
338.     )]
339.     private JournalDateFormat $acceptedAtFormat = JournalDateFormat::COMPLETE;
341.     #[ApiProperty(description: 'Corrected at')]
342.     #[Groups(['read:' . self::class, 'write'])]
343.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
344.     private ?\DateTimeImmutable $correctedAt = null;
346.     #[ApiProperty(description: 'Corrected at format', writableLink: false)]
347.     #[Groups(['read:' . self::class, 'write'])]
348.     #[ORM\Column(
349.         type: Types::STRING,
350.         enumType: JournalDateFormat::class,
351.         length: 255,
352.         options: ['default' => JournalDateFormat::COMPLETE]
353.     )]
354.     private JournalDateFormat $correctedAtFormat = JournalDateFormat::COMPLETE;
356.     #[ApiProperty(description: 'Online published at')]
357.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
358.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
359.     private ?\DateTimeImmutable $onlinePublishedAt = null;
361.     #[ApiProperty(description: 'Online published at format', writableLink: false)]
362.     #[Groups(['read:' . self::class, 'write'])]
363.     #[ORM\Column(
364.         type: Types::STRING,
365.         enumType: JournalDateFormat::class,
366.         length: 255,
367.         options: ['default' => JournalDateFormat::COMPLETE]
368.     )]
369.     private JournalDateFormat $onlinePublishedAtFormat = JournalDateFormat::COMPLETE;
371.     #[ApiProperty(description: 'Is open')]
372.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
373.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => true])]
374.     private bool $isOpen = true;
376.     #[ApiProperty(description: 'Price')]
377.     #[Groups(['read:' . self::class])]
378.     #[Assert\PositiveOrZero]
379.     #[ORM\Column(type: Types::INTEGER, nullable: true)]
380.     private ?int $price = null;
382.     #[ApiProperty(description: 'Grace date')]
383.     #[Groups(['read:' . self::class, 'write'])]
384.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
385.     private ?\DateTimeImmutable $graceDate = null;
387.     #[ApiProperty(description: 'Meta link')]
388.     #[Groups(['read:' . self::class, 'write'])]
389.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
390.     private ?string $metaLink = null;
392.     /** @deprecated */
393.     #[ApiProperty(description: 'Language', writableLink: false)]
394.     #[Groups(['read:' . self::class, 'write'])]
395.     #[ORM\Column(
396.         type: Types::STRING,
397.         enumType: Language::class,
398.         length: 255,
399.         options: ['default' => Language::PL]
400.     )]
401.     private Language $language = Language::PL;
403.     #[ApiProperty(description: 'Visible author properties', writableLink: false)]
404.     #[Groups(['read:' . self::class, 'write'])]
405.     #[Assert\Choice(callback: [AuthorProperty::class, 'cases'], multiple: true)]
406.     #[Assert\Unique]
407.     #[Assert\Count(min: 1)]
408.     #[ORM\Column(type: AuthorPropertiesType::NAME)]
409.     private array $visibleAuthorProperties = [
410.         AuthorProperty::PREFIX,
411.         AuthorProperty::NAME,
412.         AuthorProperty::SURNAME,
413.         AuthorProperty::AFFILIATION
414.     ];
416.     #[ApiProperty(description: 'Publication languages', writableLink: false)]
417.     #[Groups(['read:' . self::class, 'write'])]
418.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
419.     #[Assert\Unique]
420.     #[Assert\Count(min: 1)]
421.     #[ORM\Column(type: LanguagesType::NAME)]
422.     private array $publicationLanguages = [Language::EN];
424.     #[ApiProperty(description: 'Metadata languages', writableLink: false)]
425.     #[Groups(['read:' . self::class, 'write', 'read:minimal'])]
426.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
427.     #[Assert\Unique]
428.     // #[Assert\Count(min: 1)]
429.     #[ORM\Column(type: LanguagesType::NAME)]
430.     private array $metadataLanguages = [Language::EN, Language::PL];
432.     #[ApiProperty(description: 'Native metadata language')]
433.     #[Groups(['read:' . self::class, 'read:stats', 'read:minimal'])]
434.     #[ORM\Column(
435.         type: Types::STRING,
436.         enumType: Language::class,
437.         length: 255,
438.         nullable: true,
439.     )]
440.     private ?Language $nativeMetadataLanguage = null;
442.     #[ApiProperty(description: 'Slug')]
443.     #[Groups(['read:' . self::class, 'write', 'read:minimal'])]
444.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitleRaw'])]
445.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
446.     private ?string $slug = null;
448.     #[ApiProperty(description: 'Statistics: amount of views')]
449.     #[Groups(['read:stats'])]
450.     #[ORM\Column(type: Types::INTEGER)]
451.     private int $statsAmountOfViews = 0;
453.     #[ApiProperty(description: 'Statistics: amount of downloads')]
454.     #[Groups(['read:stats'])]
455.     #[ORM\Column(type: Types::INTEGER)]
456.     private int $statsAmountOfDownloads = 0;
458.     #[ApiProperty(description: 'Metadata translations')]
459.     #[Groups(['read', 'write', 'read:minimal'])]
460.     #[MaxDepth(2)]
461.     #[Assert\Type(Collection::class)]
462.     #[Assert\Valid]
463.     #[DenormalizationInject(method: ['name' => 'getMetadataTranslation', 'key' => 'lang'])]
464.     #[ORM\OneToMany(
465.         targetEntity: JournalArticleMetadataTranslation::class,
466.         mappedBy: 'parent',
467.         cascade: ['persist', 'remove'],
468.         orphanRemoval: true,
469.         indexBy: 'lang'
470.     )]
471.     private Collection $metadataTranslations;
473.     #[ApiProperty(description: 'Classifications')]
474.     #[ORM\OneToMany(targetEntity: JournalArticleClassification::class, mappedBy: 'parent', cascade: ['persist'])]
475.     #[ORM\OrderBy(['ord' => 'desc'])]
476.     private Collection $classifications;
478.     #[ApiProperty(description: 'Research datas')]
479.     #[ORM\OneToMany(targetEntity: JournalArticleResearchData::class, mappedBy: 'parent', cascade: ['persist'])]
480.     #[ORM\OrderBy(['ord' => 'desc'])]
481.     private Collection $researchDatas;
483.     #[ApiProperty(description: 'Relationships')]
484.     #[ORM\OneToMany(targetEntity: JournalArticleRelationship::class, mappedBy: 'parent', cascade: ['persist'])]
485.     #[ORM\OrderBy(['ord' => 'desc'])]
486.     private Collection $relationships;
488.     #[ApiProperty(description: 'Content blocks')]
489.     #[ORM\OneToMany(targetEntity: JournalArticleContentBlock::class, mappedBy: 'parent', cascade: ['persist'])]
490.     #[ORM\OrderBy(['ord' => 'desc'])]
491.     private Collection $contentBlocks;
493.     #[ApiProperty(description: 'Additional blocks')]
494.     #[ORM\OneToMany(targetEntity: JournalArticleAdditionalBlock::class, mappedBy: 'parent')]
495.     #[ORM\OrderBy(['ord' => 'desc'])]
496.     private Collection $additionalBlocks;
498.     #[ApiProperty(description: 'Bibliography entries')]
499.     #[ORM\OneToMany(
500.         targetEntity: JournalArticleBibliographyEntry::class,
501.         mappedBy: 'parent',
502.         cascade: ['persist', 'remove'],
503.         orphanRemoval: true
504.     )]
505.     #[ORM\OrderBy(['ord' => 'desc'])]
506.     private Collection $bibliographyEntries;
508.     #[ApiProperty(description: 'Files')]
509.     #[ORM\OneToMany(targetEntity: JournalArticleFile::class, mappedBy: 'parent', cascade: ['persist'])]
510.     #[ORM\OrderBy(['ord' => 'desc'])]
511.     private Collection $files;
513.     #[ApiProperty(description: 'Authors')]
514.     #[Groups(['read:' . self::class, 'read:minimal'])]
515.     #[MaxDepth(1)]
516.     #[ORM\OneToMany(targetEntity: JournalArticleAuthor::class, mappedBy: 'parent')]
517.     #[ORM\OrderBy(['ord' => 'desc'])]
518.     private Collection $authors;
520.     private ?array $redactors = null;
522.     #[ApiProperty(description: 'View entries')]
523.     #[ORM\OneToMany(targetEntity: JournalArticleViewEntry::class, mappedBy: 'parent', cascade: ['persist'])]
524.     #[ORM\OrderBy(['createdAt' => 'desc'])]
525.     private Collection $viewEntries;
527.     #[ApiProperty(description: 'Download entries')]
528.     #[ORM\OneToMany(targetEntity: JournalArticleDownloadEntry::class, mappedBy: 'parent', cascade: ['persist'])]
529.     #[ORM\OrderBy(['createdAt' => 'desc'])]
530.     private Collection $downloadEntries;
532.     #[ApiProperty(description: 'Slug title language', writableLink: false)]
533.     #[Groups(['read:' . self::class, 'read:minimal', 'write'])]
534.     #[Assert\Choice(callback: 'getMetadataLanguages', message: 'Można wybrać tylko jeden z języków tekstu.')]
535.     #[ORM\Column(
536.         type: Types::STRING,
537.         enumType: Language::class,
538.         length: 255,
539.         nullable: true,
540.     )]
541.     private ?Language $slugTitleLanguage = null;
543.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalArticleSlugHistory::class, cascade: ['persist'], orphanRemoval: true,)]
544.     private Collection $slugHistory;
546.     #[ApiProperty(description: 'Is crossmark button visible')]
547.     #[Groups(['read:' . self::class, 'write'])]
548.     #[ORM\Column(type: Types::BOOLEAN, nullable: true)]
549.     private ?bool $isCrossmarkButtonVisible = null;
551.     #[ORM\OneToMany(mappedBy: 'article', targetEntity: CartProduct::class)]
552.     private Collection $cartProducts;
554.     #[ApiProperty(description: 'Statistics: full text url')]
555.     #[Groups(['read:stats'])]
556.     private ?string $statsFullTextUrl = null;
558.     #[ApiProperty(description: 'Statistics: article url')]
559.     #[Groups(['read:stats'])]
560.     private ?string $statsArticleUrl = null;
562.     public function __construct(Journal $parent, JournalIssue $issue)
563.     {
564.         $this->setUuid();
566.         $this->parent = $parent;
567.         $this->issue = $issue;
569.         $this->translations = new ArrayCollection();
570.         $this->metadataTranslations = new ArrayCollection();
572.         $this->classifications = new ArrayCollection();
573.         $this->researchDatas = new ArrayCollection();
574.         $this->relationships = new ArrayCollection();
575.         $this->contentBlocks = new ArrayCollection();
576.         $this->additionalBlocks = new ArrayCollection();
577.         $this->bibliographyEntries = new ArrayCollection();
578.         $this->files = new ArrayCollection();
579.         $this->authors = new ArrayCollection();
581.         $this->viewEntries = new ArrayCollection();
582.         $this->downloadEntries = new ArrayCollection();
583.         $this->slugHistory = new ArrayCollection();
585.         foreach ($this->parent->getLanguages() as $lang) {
586.             new JournalArticleTranslation($this, $lang);
587.         }
589.         foreach ($this->metadataLanguages as $lang) {
590.             new JournalArticleMetadataTranslation($this, $lang);
591.         }
593.         foreach (self::DEFAULT_FILES as $type) {
594.             new JournalArticleFile($this, $type);
595.         }
597.         $this->isOpen = $issue->getIsOpen();
598.         $this->price = $parent->getData()->getArticlePrice() ?? $parent->getData()->getIssuePrice();
600.         $this->citationType = $issue->getSuggestedCitationType();
602.         $this->licence = $issue->getLicence();
603.         $this->isCrossmarkButtonVisible = $issue->getIsCrossmarkButtonVisible();
605.         $this->createdAt = new \DateTimeImmutable();
606.         $this->updatedAt = new \DateTimeImmutable();
608.         $parent->addArticle($this);
609.         $this->cartProducts = new ArrayCollection();
610.     }
612.     public function getParent(): Journal
613.     {
614.         return $this->parent;
615.     }
617.     public function getNativeMetadataLanguage(): ?Language
618.     {
619.         return $this->nativeMetadataLanguage;
620.     }
622.     public function getNativeTitle(): ?string
623.     {
624.         return $this->nativeTitle;
625.     }
627.     public function setNativeTitle(?string $nativeTitle): self
628.     {
629.         $this->nativeTitle = $nativeTitle;
631.         return $this;
632.     }
634.     public function getNativeTitleRaw(): ?string
635.     {
636.         return $this->nativeTitleRaw;
637.     }
639.     public function setNativeTitleRaw(?string $nativeTitleRaw): self
640.     {
641.         $this->nativeTitleRaw = $nativeTitleRaw;
643.         $this->addCurrentSlugToHistory();
645.         return $this;
646.     }
648.     public function getWorkingTitle(): ?string
649.     {
650.         return $this->workingTitle;
651.     }
653.     public function setWorkingTitle(?string $workingTitle): self
654.     {
655.         $this->workingTitle = $workingTitle;
657.         return $this;
658.     }
660.     public function getLicence(): JournalLicence
661.     {
662.         return $this->licence;
663.     }
665.     public function setLicence(JournalLicence $licence): self
666.     {
667.         $this->licence = $licence;
669.         return $this;
670.     }
672.     public function getIssue(): JournalIssue
673.     {
674.         return $this->issue;
675.     }
677.     public function setIssue(JournalIssue $issue): self
678.     {
679.         $this->issue = $issue;
681.         return $this;
682.     }
684.     public function getFundingNumber(): ?string
685.     {
686.         return $this->fundingNumber;
687.     }
689.     public function setFundingNumber(?string $fundingNumber): self
690.     {
691.         $this->fundingNumber = $fundingNumber;
693.         return $this;
694.     }
696.     public function getType(): JournalArticleType
697.     {
698.         return $this->type;
699.     }
701.     public function setType(JournalArticleType $type): self
702.     {
703.         $this->type = $type;
705.         return $this;
706.     }
708.     public function getSection(): ?JournalSection
709.     {
710.         return $this->section;
711.     }
713.     public function setSection(?JournalSection $section): self
714.     {
715.         $this->section = $section;
717.         return $this;
718.     }
720.     public function getDoi(): ?string
721.     {
722.         return $this->doi;
723.     }
725.     public function setDoi(?string $doi): self
726.     {
727.         $this->doi = $doi;
729.         return $this;
730.     }
732.     public function getPageFrom(): ?string
733.     {
734.         return $this->pageFrom;
735.     }
737.     public function setPageFrom(?string $pageFrom): self
738.     {
739.         $this->pageFrom = $pageFrom;
741.         return $this;
742.     }
744.     public function getPageTo(): ?string
745.     {
746.         return $this->pageTo;
747.     }
749.     public function setPageTo(?string $pageTo): self
750.     {
751.         $this->pageTo = $pageTo;
753.         return $this;
754.     }
756.     public function getCitationType(): ?CitationType
757.     {
758.         return $this->citationType;
759.     }
761.     public function setCitationType(?CitationType $citationType): self
762.     {
763.         $this->citationType = $citationType;
765.         return $this;
766.     }
768.     public function getCitation(): ?string
769.     {
770.         return $this->citation;
771.     }
773.     public function setCitation(?string $citation): self
774.     {
775.         $this->citation = $citation;
777.         return $this;
778.     }
780.     public function getReceivedAt(): ?\DateTimeImmutable
781.     {
782.         return $this->receivedAt;
783.     }
785.     public function setReceivedAt(?\DateTimeImmutable $receivedAt): self
786.     {
787.         $this->receivedAt = $receivedAt;
789.         return $this;
790.     }
792.     public function getReceivedAtFormat(): JournalDateFormat
793.     {
794.         return $this->receivedAtFormat;
795.     }
797.     public function setReceivedAtFormat(JournalDateFormat $receivedAtFormat): self
798.     {
799.         $this->receivedAtFormat = $receivedAtFormat;
801.         return $this;
802.     }
804.     public function getAcceptedAt(): ?\DateTimeImmutable
805.     {
806.         return $this->acceptedAt;
807.     }
809.     public function setAcceptedAt(?\DateTimeImmutable $acceptedAt): self
810.     {
811.         $this->acceptedAt = $acceptedAt;
813.         return $this;
814.     }
816.     public function getAcceptedAtFormat(): JournalDateFormat
817.     {
818.         return $this->acceptedAtFormat;
819.     }
821.     public function setAcceptedAtFormat(JournalDateFormat $acceptedAtFormat): self
822.     {
823.         $this->acceptedAtFormat = $acceptedAtFormat;
825.         return $this;
826.     }
828.     public function getCorrectedAt(): ?\DateTimeImmutable
829.     {
830.         return $this->correctedAt;
831.     }
833.     public function setCorrectedAt(?\DateTimeImmutable $correctedAt): self
834.     {
835.         $this->correctedAt = $correctedAt;
837.         return $this;
838.     }
840.     public function getCorrectedAtFormat(): JournalDateFormat
841.     {
842.         return $this->correctedAtFormat;
843.     }
845.     public function setCorrectedAtFormat(JournalDateFormat $correctedAtFormat): self
846.     {
847.         $this->correctedAtFormat = $correctedAtFormat;
849.         return $this;
850.     }
852.     public function getOnlinePublishedAt(): ?\DateTimeImmutable
853.     {
854.         return $this->onlinePublishedAt;
855.     }
857.     public function setOnlinePublishedAt(?\DateTimeImmutable $onlinePublishedAt): self
858.     {
859.         if ($this->onlinePublishedAt === $onlinePublishedAt) {
860.             return $this;
861.         }
863.         $this->onlinePublishedAt = $onlinePublishedAt;
865.         if (! $onlinePublishedAt) {
866.             return $this;
867.         }
869.         $period = $this->parent->getData()->getOpenAccessGrantedAfterPeriod();
871.         if (! $period) {
872.             return $this;
873.         }
875.         $graceDate = new \DateTime("@{$this->onlinePublishedAt->getTimestamp()}");
876.         $graceDate->modify($period);
878.         $this->graceDate = new \DateTimeImmutable("@{$graceDate->getTimestamp()}");
880.         return $this;
881.     }
883.     public function getOnlinePublishedAtFormat(): JournalDateFormat
884.     {
885.         return $this->onlinePublishedAtFormat;
886.     }
888.     public function setOnlinePublishedAtFormat(JournalDateFormat $onlinePublishedAtFormat): self
889.     {
890.         $this->onlinePublishedAtFormat = $onlinePublishedAtFormat;
892.         return $this;
893.     }
895.     public function getAllDatesFormatted(): array
896.     {
897.         $properties = ['ReceivedAt', 'AcceptedAt', 'CorrectedAt', 'OnlinePublishedAt'];
898.         $dates = [];
900.         foreach ($properties as $property) {
901.             $date = $this->{'get' . $property}();
903.             $dates[$property] = null;
905.             if (! $date) {
906.                 continue;
907.             }
909.             $dates[$property] = match($this->{'get' . $property . 'Format'}()) {
910.                 JournalDateFormat::YEAR => $date->format('Y'),
911.                 JournalDateFormat::YEAR_AND_MONTH => $date->format('m.Y'),
912.                 JournalDateFormat::COMPLETE => $date->format('d.m.Y'),
913.                 default => null,
914.             };
915.         }
917.         return $dates;
918.     }
920.     public function getIsOpen(): bool
921.     {
922.         return $this->isOpen;
923.     }
925.     public function setIsOpen(bool $isOpen): self
926.     {
927.         $this->isOpen = $isOpen;
929.         return $this;
930.     }
932.     public function getPrice(): ?int
933.     {
934.         return $this->price;
935.     }
937.     #[Groups(['read:' . self::class, 'read:' . Journal::class])]
938.     public function getPriceReal(): ?float
939.     {
940.         return $this->price ? round($this->price / 1000, 2) : null;
941.     }
943.     public function setPrice(?int $price): self
944.     {
945.         $this->price = $price;
947.         return $this;
948.     }
950.     #[Groups(['write'])]
951.     public function setPriceReal(?float $priceReal): self
952.     {
953.         $this->price = (int) ($priceReal * 1000);
955.         return $this;
956.     }
958.     public function getGraceDate(): ?\DateTimeImmutable
959.     {
960.         return $this->graceDate;
961.     }
963.     public function setGraceDate(?\DateTimeImmutable $graceDate): self
964.     {
965.         $this->graceDate = $graceDate;
967.         return $this;
968.     }
970.     public function getMetaLink(): ?string
971.     {
972.         return $this->metaLink;
973.     }
975.     public function setMetaLink(?string $metaLink): self
976.     {
977.         $this->metaLink = $metaLink;
979.         return $this;
980.     }
982.     /** @deprecated */
983.     public function getLanguage(): Language
984.     {
985.         return $this->language;
986.     }
988.     /** @deprecated */
989.     public function setLanguage(Language $language): self
990.     {
991.         $this->language = $language;
993.         return $this;
994.     }
996.     public function getVisibleAuthorProperties(): array
997.     {
998.         return $this->visibleAuthorProperties;
999.     }
1001.     public function setVisibleAuthorProperties(array $visibleAuthorProperties): self
1002.     {
1003.         $this->visibleAuthorProperties = $visibleAuthorProperties;
1005.         return $this;
1006.     }
1008.     public function getPublicationLanguages(): array
1009.     {
1010.         return $this->publicationLanguages;
1011.     }
1013.     public function setPublicationLanguages(array $publicationLanguages): self
1014.     {
1015.         $this->publicationLanguages = $publicationLanguages;
1017.         return $this;
1018.     }
1020.     public function getMetadataLanguages(): array
1021.     {
1022.         return $this->metadataLanguages;
1023.     }
1025.     public function setMetadataLanguages(array $metadataLanguages): self
1026.     {
1027.         $this->metadataLanguages = $metadataLanguages;
1029.         /** @var JournalArticleMetadataTranslation */
1030.         foreach ($this->metadataTranslations as $metadataTranslation) {
1031.             if (in_array($metadataTranslation->getLang(), $this->metadataLanguages)) {
1032.                 continue;
1033.             }
1035.             $this->deleteMetadataTranslation($metadataTranslation);
1036.         }
1038.         foreach ($this->metadataLanguages as $lang) {
1039.             if (! $lang instanceof Language || isset($this->metadataTranslations[$lang->value])) {
1040.                 continue;
1041.             }
1043.             $class = JournalArticleMetadataTranslation::class;
1044.             new $class($this, $lang);
1045.         }
1047.         if (count($metadataLanguages) < 1) {
1048.             $this->nativeMetadataLanguage = null;
1050.             return $this;
1051.         }
1053.         $this->nativeMetadataLanguage = $this->metadataLanguages[array_key_first($this->metadataLanguages)];
1055.         return $this;
1056.     }
1058.     public function getAvailableMetadataLanguages(string $property): array
1059.     {
1060.         $langs = [];
1062.         foreach($this->metadataLanguages as $lang) {
1063.             /** @var JournalArticleMetadataTranslation */
1064.             $metadataTranslation = $this->getMetadataTranslation($lang);
1066.             switch($property) {
1067.                 case 'abstract':
1068.                     if (! empty($metadataTranslation->getAbstract())) {
1069.                         $langs[] = $lang;
1070.                     }
1071.                     break;
1072.                 case 'keywords':
1073.                     if (! empty($metadataTranslation->getKeywords())) {
1074.                         $langs[] = $lang;
1075.                     }
1076.                     break;
1077.                 case 'title':
1078.                     if (! empty($metadataTranslation->getTitle())) {
1079.                         $langs[] = $lang;
1080.                     }
1081.                 default:
1082.                     break;
1083.             }
1084.         }
1086.         return $langs;
1087.     }
1089.     public function getSlug(): ?string
1090.     {
1091.         return $this->slug;
1092.     }
1094.     public function setSlug(?string $slug): self
1095.     {
1096.         $this->slug = $slug;
1098.         return $this;
1099.     }
1101.     public function getStatsAmountOfViews(): int
1102.     {
1103.         return $this->statsAmountOfViews;
1104.     }
1106.     public function hitStatsView(): int
1107.     {
1108.         return $this->statsAmountOfViews++;
1109.     }
1111.     /*
1112.     public function updateStatsView(int $amount): self
1113.     {
1114.         $this->statsAmountOfViews += $amount;
1116.         return $this;
1117.     }*/
1119.     public function getStatsAmountOfDownloads(): int
1120.     {
1121.         return $this->statsAmountOfDownloads;
1122.     }
1124.     public function hitStatsDownload(): int
1125.     {
1126.         return $this->statsAmountOfDownloads++;
1127.     }
1129.     /*
1130.     public function updateStatsDownload(int $amount): self
1131.     {
1132.         $this->statsAmountOfDownloads += $amount;
1134.         return $this;
1135.     }*/
1137.     /**
1138.      * @return Collection|JournalArticleMetadataTranslation[]
1139.      */
1140.     public function getMetadataTranslations(): Collection
1141.     {
1142.         return $this->metadataTranslations;
1143.     }
1145.     public function getMetadataTranslation(Language $lang): mixed
1146.     {
1147.         return $this->metadataTranslations[$lang->value] ?? null;
1148.     }
1150.     public function addMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1151.     {
1152.         if ($this->metadataTranslations->contains($metadataTranslation)) {
1153.             return $this;
1154.         }
1156.         $this->metadataTranslations[
1157.             $metadataTranslation->getLang()->value
1158.         ] = $metadataTranslation;
1160.         return $this;
1161.     }
1163.     public function deleteMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1164.     {
1165.         $this->metadataTranslations->removeElement($metadataTranslation);
1167.         return $this;
1168.     }
1170.     public function resetMetadataTranslations(): self
1171.     {
1172.         $this->metadataTranslations = new ArrayCollection();
1174.         return $this;
1175.     }
1177.     public function readMetadataTranslation(null|string|Language $lang, string $property): mixed
1178.     {
1179.         if (! $lang) {
1180.             return null;
1181.         }
1183.         $lang = is_string($lang)
1184.             ? Language::from($lang)
1185.             : $lang;
1187.         if (! isset($this->metadataTranslations[$lang->value])) {
1188.             return null;
1189.         }
1191.         if (! str_contains($property, '.')) {
1192.             return $this->metadataTranslations[$lang->value]->{'get' . ucfirst($property)}();
1193.         }
1195.         $path = explode('.', $property);
1196.         $current = array_shift($path);
1198.         return $this->readProperty(
1199.             object: $this->metadataTranslations[$lang->value]->{'get'. ucfirst($current)}(),
1200.             path: $path
1201.         );
1202.     }
1204.     public function readAvailableMetadataTranslation(
1205.         string|Language $lang,
1206.         string $property,
1207.         bool $isNotEmpty = true
1208.     ): mixed {
1209.         $lang = is_string($lang)
1210.             ? Language::from($lang)
1211.             : $lang;
1213.         if (! $this->isLanguageAvailable($lang, $this->metadataLanguages)) {
1214.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1215.         }
1217.         $value = $this->readMetadataTranslation($lang, $property);
1219.         if ($isNotEmpty && empty($value)) {
1220.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1221.         }
1223.         return $value;
1224.     }
1226.     private function isLanguageAvailable(Language $lang, ?array $languages): bool
1227.     {
1228.         return ! $languages || in_array($lang, $languages);
1229.     }
1231.     /**
1232.      * @return Collection|JournalArticleClassification[]
1233.      */
1234.     public function getClassifications(): Collection
1235.     {
1236.         return $this->classifications;
1237.     }
1239.     public function getVisibleClassifications(): Collection
1240.     {
1241.         return $this->getClassifications()->filter(
1242.             fn(JournalArticleClassification $classification) => $classification->getType()->getStat() === true
1243.         );
1244.     }
1246.     public function addClassification(JournalArticleClassification $classification): self
1247.     {
1248.         if ($this->classifications->contains($classification)) {
1249.             return $this;
1250.         }
1252.         $this->classifications[] = $classification;
1254.         return $this;
1255.     }
1257.     public function removeClassification(JournalArticleClassification $classification): self
1258.     {
1259.         $this->classifications->removeElement($classification);
1261.         return $this;
1262.     }
1264.     public function resetClassifications(): self
1265.     {
1266.         $this->classifications = new ArrayCollection();
1268.         return $this;
1269.     }
1271.     /**
1272.      * @return Collection|JournalArticleResearchData[]
1273.      */
1274.     public function getResearchDatas(): Collection
1275.     {
1276.         return $this->researchDatas;
1277.     }
1279.     public function addResearchData(JournalArticleResearchData $researchData): self
1280.     {
1281.         if ($this->researchDatas->contains($researchData)) {
1282.             return $this;
1283.         }
1285.         $this->researchDatas[] = $researchData;
1287.         return $this;
1288.     }
1290.     public function removeResearchData(JournalArticleResearchData $researchData): self
1291.     {
1292.         $this->researchDatas->removeElement($researchData);
1294.         return $this;
1295.     }
1297.     public function resetResearchDatas(): self
1298.     {
1299.         $this->researchDatas = new ArrayCollection();
1301.         return $this;
1302.     }
1304.     /**
1305.      * @return Collection|JournalArticleRelationship[]
1306.      */
1307.     public function getRelationships(): Collection
1308.     {
1309.         return $this->relationships;
1310.     }
1312.     /**
1313.      * @return JournalArticleRelationship[]
1314.      */
1315.     public function getRelationshipsVisible(): array
1316.     {
1317.         $relations = [];
1319.         foreach ($this->getRelationships() as $relationship) {
1320.             if (!$relationship->getTargetArticle()?->getStat()) {
1321.                 continue;
1322.             }
1324.             $relations[] = $relationship;
1325.         }
1327.         return $relations;
1328.     }
1330.     public function addRelationship(JournalArticleRelationship $relationship): self
1331.     {
1332.         if ($this->relationships->contains($relationship)) {
1333.             return $this;
1334.         }
1336.         $this->relationships[] = $relationship;
1338.         return $this;
1339.     }
1341.     public function removeRelationship(JournalArticleRelationship $relationship): self
1342.     {
1343.         $this->relationships->removeElement($relationship);
1345.         return $this;
1346.     }
1348.     public function resetRelationships(): self
1349.     {
1350.         $this->relationships = new ArrayCollection();
1352.         return $this;
1353.     }
1355.     /**
1356.      * @return Collection|JournalArticleContentBlock[]
1357.      */
1358.     public function getContentBlocks(): Collection
1359.     {
1360.         return $this->contentBlocks;
1361.     }
1363.     public function getVisibleContentBlocks(): Collection
1364.     {
1365.         return $this->contentBlocks->filter(
1366.             fn (JournalArticleContentBlock $block) => $block->getStat() === true
1367.         );
1368.     }
1370.     public function addContentBlock(JournalArticleContentBlock $contentBlock): self
1371.     {
1372.         if ($this->contentBlocks->contains($contentBlock)) {
1373.             return $this;
1374.         }
1376.         $this->contentBlocks[] = $contentBlock;
1378.         return $this;
1379.     }
1381.     public function removeContentBlock(JournalArticleContentBlock $contentBlock): self
1382.     {
1383.         $this->contentBlocks->removeElement($contentBlock);
1385.         return $this;
1386.     }
1388.     public function resetContentBlocks(): self
1389.     {
1390.         $this->contentBlocks = new ArrayCollection();
1392.         return $this;
1393.     }
1395.     /**
1396.      * @return Collection|JournalArticleAddditionalBlock[]
1397.      */
1398.     public function getAdditionalBlocks(): Collection
1399.     {
1400.         return $this->additionalBlocks;
1401.     }
1403.     public function getVisibleAdditionalBlocks(): Collection
1404.     {
1405.         return $this->additionalBlocks->filter(
1406.             fn (JournalArticleAdditionalBlock $block) => $block->getStat() === true
1407.         );
1408.     }
1410.     public function addAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1411.     {
1412.         if ($this->additionalBlocks->contains($additionalBlock)) {
1413.             return $this;
1414.         }
1416.         $this->additionalBlocks[] = $additionalBlock;
1418.         return $this;
1419.     }
1421.     public function removeAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1422.     {
1423.         $this->additionalBlocks->removeElement($additionalBlock);
1425.         return $this;
1426.     }
1428.     public function resetAdditionalBlocks(): self
1429.     {
1430.         $this->additionalBlocks = new ArrayCollection();
1432.         return $this;
1433.     }
1435.     /**
1436.      * @return Collection|JournalArticleBibliographyEntry[]
1437.      */
1438.     public function getBibliographyEntries(): Collection
1439.     {
1440.         return $this->bibliographyEntries;
1441.     }
1443.     public function addBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1444.     {
1445.         if ($this->bibliographyEntries->contains($bibliographyEntry)) {
1446.             return $this;
1447.         }
1449.         $this->bibliographyEntries[] = $bibliographyEntry;
1451.         return $this;
1452.     }
1454.     public function removeBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1455.     {
1456.         $this->bibliographyEntries->removeElement($bibliographyEntry);
1458.         return $this;
1459.     }
1461.     public function resetBibliographyEntries(): self
1462.     {
1463.         $this->bibliographyEntries = new ArrayCollection();
1465.         return $this;
1466.     }
1468.     public function importBibliography(): self
1469.     {
1470.         $nativeLanguage = $this->getParentNativeLanguage();
1471.         $nativeTranslation = $this->getTranslation($nativeLanguage);
1473.         if (! $nativeTranslation?->getImportedBibliography()) {
1474.             return $this;
1475.         }
1477.         $otherLanguages = array_filter(
1478.             $this->getParentLanguages(),
1479.             fn(Language $lang) => $nativeLanguage !== $lang
1480.         );
1482.         $imported = [];
1484.         foreach([$nativeLanguage] + $otherLanguages as $lang) {
1485.             $imported[$lang->value] = $this->getImportedBibliographyEntries($lang);
1486.         }
1488.         $this->resetBibliographyEntries();
1490.         $ord = count($imported[$nativeLanguage->value]);
1492.         foreach($imported[$nativeLanguage->value] as $key => $title) {
1493.             preg_match('/10.\d{4,9}\/[-._;()\/:A-Z0-9]+$/i', $title, $doi);
1495.             $entry = new JournalArticleBibliographyEntry($this);
1496.             $entry
1497.                 ->setDoi($doi[0] ?? null)
1498.                 ->setOrd($ord--);
1500.             $translation = $entry->getTranslation($nativeLanguage);
1501.             $translation->setTitle($title);
1503.             $this->fillBibliographyEntryTranslations(
1504.                 entry: $entry,
1505.                 languages: $otherLanguages,
1506.                 imported: $imported,
1507.                 key: $key
1508.             );
1509.         }
1511.         return $this;
1512.     }
1514.     private function getImportedBibliographyEntries(Language $lang): array
1515.     {
1516.         $importedBibliography = $this->getTranslation($lang)?->getImportedBibliography() ?? '';
1518.         $bibliographyEntries = array_map(
1519.             fn(string $bibliograpyEntry) => trim($bibliograpyEntry),
1520.             preg_split('/\r\n|\r|\n|<br>|<br \/>|<br\/>/', $importedBibliography)
1521.         );
1523.         $bibliographyEntries = array_filter(
1524.             $bibliographyEntries,
1525.             fn(string $bibliograpyEntry) => ! empty($bibliograpyEntry)
1526.         );
1528.         return $bibliographyEntries;
1529.     }
1531.     private function fillBibliographyEntryTranslations(
1532.         JournalArticleBibliographyEntry $entry,
1533.         array $languages,
1534.         array $imported,
1535.         int $key
1536.     ): self {
1537.         foreach($languages as $language) {
1538.             $translation = $entry->getTranslation($language);
1539.             $translation->setTitle($imported[$language->value][$key] ?? null);
1540.         }
1542.         return $this;
1543.     }
1545.     /**
1546.      * @return Collection|JournalArticleFile[]
1547.      */
1548.     public function getFiles(): Collection
1549.     {
1550.         return $this->files;
1551.     }
1553.     public function addFile(JournalArticleFile $file): self
1554.     {
1555.         if ($this->files->contains($file)) {
1556.             return $this;
1557.         }
1559.         $this->files[] = $file;
1561.         return $this;
1562.     }
1564.     public function removeFile(JournalArticleFile $file): self
1565.     {
1566.         $this->files->removeElement($file);
1568.         return $this;
1569.     }
1571.     public function resetFiles(): self
1572.     {
1573.         $this->files = new ArrayCollection();
1575.         return $this;
1576.     }
1578.     #[Groups(['read:' . self::class, 'read:minimal'])]
1579.     public function getHasFiles(): bool
1580.     {
1581.         foreach($this->files as $file) {
1582.             if (! $file->getHasFiles()) {
1583.                 continue;
1584.             }
1586.             return true;
1587.         }
1589.         return false;
1590.     }
1592.     public function getFullTextFile(): ?JournalArticleFile
1593.     {
1594.         foreach($this->files as $file) {
1595.             if (! $file->getStat() || $file->getType() !== JournalArticleFileType::FULL_TEXT) {
1596.                 continue;
1597.             }
1599.             return $file;
1600.         }
1602.         return null;
1603.     }
1605.     public function getFullTextTranslationFile(string|Language $lang): ?JournalArticleFileTranslationFile
1606.     {
1607.         $fullText = $this->getFullTextFile();
1609.         if (! $fullText) {
1610.             return null;
1611.         }
1613.         $lang = is_string($lang)
1614.             ? Language::from($lang)
1615.             : $lang;
1617.         $files = $fullText->readAvailableTranslation($lang, 'files');
1619.         if (! $files) {
1620.             return null;
1621.         }
1623.         return ($first = $files->first()) === false ? null : $first;
1624.     }
1626.     public function getFullTextExtensions(): array
1627.     {
1628.         $fullText = $this->getFullTextFile();
1630.         if (! $fullText) {
1631.             return [];
1632.         }
1634.         $extensions = [];
1636.         /** @var JournalArticleFileTranslation $translation */
1637.         foreach ($fullText->getTranslations() as $translation) {
1638.             /** @var JournalArticleFileTranslationFile $file */
1639.             foreach ($translation->getVisibleFiles() as $file) {
1640.                 if ($file->getMedia()?->getExtension()) {
1641.                     $extensions[] = $file->getMedia()->getExtension();
1642.                 }
1643.             }
1644.         }
1646.         return array_unique($extensions);
1647.     }
1649.     /** @return <int, JournalArticleFileTranslationFile> */
1650.     public function getAdditionalFiles(string|Language $lang): array
1651.     {
1652.         $lang = is_string($lang)
1653.             ? Language::from($lang)
1654.             : $lang;
1655.         $files = [];
1657.         foreach($this->files as $file) {
1658.             if (!$file->getStat() || $file->getType() === JournalArticleFileType::FULL_TEXT) {
1659.                 continue;
1660.             }
1662.             $files[] = $file;
1663.         }
1665.         $finalFiles = [];
1667.         /** @var JournalArticleFile $file */
1668.         foreach ($files as $file) {
1669.             /** @var JournalArticleFileTranslation $trans */
1670.             $files = $file->readAvailableTranslation($lang, 'files');
1671.             if (!$files) {
1672.                 continue;
1673.             }
1675.             foreach ($files as $finalFile) {
1676.                 if (!$finalFile->getMedia() || !$finalFile->getTitle()) {
1677.                     continue;
1678.                 }
1680.                 $finalFiles[] = $finalFile;
1681.             }
1682.         }
1684.         return $finalFiles;
1685.     }
1687.     public function getFileByType(JournalArticleFileType $type): ?JournalArticleFile
1688.     {
1689.         return $this->files->findFirst(
1690.             fn(int $key, JournalArticleFile $file) => $file->getType() === $type
1691.         );
1692.     }
1694.     /**
1695.      * @return Collection|JournalArticleAuthor[]
1696.      */
1697.     public function getAuthors(): Collection
1698.     {
1699.         return $this->authors;
1700.     }
1702.     public function setAuthors(array $authors): self
1703.     {
1704.         foreach ($authors as $author) {
1705.             $this->authors[] = $author;
1706.         }
1708.         return $this;
1709.     }
1711.     public function addAuthor(JournalArticleAuthor $author): self
1712.     {
1713.         if ($this->authors->contains($author)) {
1714.             return $this;
1715.         }
1717.         $this->authors[] = $author;
1719.         return $this;
1720.     }
1722.     public function removeAuthor(JournalArticleAuthor $author): self
1723.     {
1724.         $this->authors->removeElement($author);
1726.         return $this;
1727.     }
1729.     public function resetAuthors(): self
1730.     {
1731.         $this->authors = new ArrayCollection();
1733.         return $this;
1734.     }
1736.     public function getVisibleAuthors(string|Language $lang, ?Author $highlightAuthor = null): array
1737.     {
1738.         $lang = ! is_string($lang)
1739.             ? $lang
1740.             : Language::from($lang);
1742.         $authors = $this->getVisibleAuthorsByRole($lang, JournalArticleAuthorRole::AUTHOR);
1744.         if (null !== $highlightAuthor) {
1745.             $authors = [
1746.                 $highlightAuthor,
1747.                 ...array_filter(
1748.                     $authors,
1749.                     fn(JournalArticleAuthor $author) => $author->getAuthor()->getUuid() === $highlightAuthor->getUuid()
1750.                 )
1751.             ];
1752.         }
1754.         return $authors;
1755.     }
1757.     public function getVisibleAuthorsByRole(string|Language $lang, JournalArticleAuthorRole|string $type): array
1758.     {
1759.         $lang = ! is_string($lang)
1760.             ? $lang
1761.             : Language::from($lang);
1763.         $type = is_string($type)
1764.             ? JournalArticleAuthorRole::from($type)
1765.             : $type;
1767.         $isNameVisible = in_array(AuthorProperty::NAME, $this->visibleAuthorProperties);
1768.         $isSurnameVisible = in_array(AuthorProperty::SURNAME, $this->visibleAuthorProperties);
1770.         if (! $isNameVisible && ! $isSurnameVisible) {
1771.             return [];
1772.         }
1774.         return $this->getAuthors()->filter(
1775.             fn(JournalArticleAuthor $author) => $author->getRole() === $type
1776.         )->toArray();
1777.     }
1779.     public function getIssueRedactors(): array
1780.     {
1781.         if ($this->redactors) {
1782.             return $this->redactors;
1783.         }
1785.         $this->redactors = [];
1787.         foreach($this->issue?->getEditorialGroups() as $group) {
1788.             foreach($group->getMembers() as $member) {
1789.                 if (in_array($member, $this->redactors)) {
1790.                     continue;
1791.                 }
1793.                 $this->redactors[] = $member;
1794.             }
1795.         }
1797.         return $this->redactors;
1798.     }
1800.     // -----
1801.     // STATS
1802.     // -----
1804.     /**
1805.      * @return Collection|JournalArticleViewEntry[]
1806.      */
1807.     public function getViewEntries(): Collection
1808.     {
1809.         return $this->viewEntries;
1810.     }
1812.     public function addViewEntry(JournalArticleViewEntry $viewEntry): self
1813.     {
1814.         if ($this->viewEntries->contains($viewEntry)) {
1815.             return $this;
1816.         }
1818.         $this->viewEntries[] = $viewEntry;
1820.         return $this;
1821.     }
1823.     public function removeViewEntry(JournalArticleViewEntry $viewEntry): self
1824.     {
1825.         $this->viewEntries->removeElement($viewEntry);
1827.         return $this;
1828.     }
1830.     public function resetViewEntries(): self
1831.     {
1832.         $this->viewEntries = new ArrayCollection();
1834.         return $this;
1835.     }
1837.     /**
1838.      * @return Collection|JournalArticleDownloadEntry[]
1839.      */
1840.     public function getDownloadEntries(): Collection
1841.     {
1842.         return $this->downloadEntries;
1843.     }
1845.     public function addDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1846.     {
1847.         if ($this->downloadEntries->contains($downloadEntry)) {
1848.             return $this;
1849.         }
1851.         $this->downloadEntries[] = $downloadEntry;
1853.         return $this;
1854.     }
1856.     public function removeDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1857.     {
1858.         $this->downloadEntries->removeElement($downloadEntry);
1860.         return $this;
1861.     }
1863.     public function resetDownloadEntries(): self
1864.     {
1865.         $this->downloadEntries = new ArrayCollection();
1867.         return $this;
1868.     }
1870.     public function getSlugTitleLanguage(): ?Language
1871.     {
1872.         if (!$this->slugTitleLanguage) {
1873.             if (isset($this->getPublicationLanguages()[0]) && in_array($this->getPublicationLanguages()[0], $this->getMetadataLanguages())) {
1874.                 return $this->getPublicationLanguages()[0];
1875.             }
1877.             return $this->nativeMetadataLanguage;
1878.         }
1880.         return $this->slugTitleLanguage;
1881.     }
1883.     public function setSlugTitleLanguage(?Language $slugTitleLanguage): self
1884.     {
1885.         if ($this->slugTitleLanguage !== $slugTitleLanguage && $slugTitleLanguage !== null) {
1886.             $this->slugTitleLanguage = $slugTitleLanguage;
1888.             foreach ($this->getMetadataTranslations() as $metadataTranslation) {
1889.                 $metadataTranslation->setTitle($metadataTranslation->getTitle());
1890.             }
1891.         } else {
1892.             $this->slugTitleLanguage = $slugTitleLanguage;
1893.         }
1895.         return $this;
1896.     }
1898.     /**
1899.      * @return Collection<int, JournalArticleSlugHistory>
1900.      */
1901.     public function getSlugHistory(): Collection
1902.     {
1903.         return $this->slugHistory;
1904.     }
1906.     public function addCurrentSlugToHistory(): void
1907.     {
1908.         // check if already in history
1909.         foreach ($this->slugHistory as $entry) {
1910.             if ($entry->getSlug() === $this->slug) {
1911.                 return;
1912.             }
1913.         }
1915.         $entry = new JournalArticleSlugHistory($this, $this->slug);
1916.         $this->addSlugHistory($entry);
1917.     }
1919.     public function addSlugHistory(JournalArticleSlugHistory $slugHistory): self
1920.     {
1921.         if (!$this->slugHistory->contains($slugHistory)) {
1922.             $this->slugHistory->add($slugHistory);
1923.         }
1925.         return $this;
1926.     }
1928.     public function removeSlugHistory(JournalArticleSlugHistory $slugHistory): self
1929.     {
1930.         $this->slugHistory->removeElement($slugHistory);
1932.         return $this;
1933.     }
1935.     public function getIsCrossmarkButtonVisible(): ?bool
1936.     {
1937.         if ($this->isCrossmarkButtonVisible === null) {
1938.             return $this->getIssue()->getIsCrossmarkButtonVisible();
1939.         }
1941.         return $this->isCrossmarkButtonVisible;
1942.     }
1944.     public function setIsCrossmarkButtonVisible(?bool $isCrossmarkButtonVisible): self
1945.     {
1946.         $this->isCrossmarkButtonVisible = $isCrossmarkButtonVisible;
1948.         return $this;
1949.     }
1951.     #[Groups(['read:stats'])]
1952.     public function getStatsAuthors(): ?string
1953.     {
1954.         $authors = [];
1956.         /** @var JournalArticleAuthor */
1957.         foreach($this->authors as $entry) {
1958.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1959.                 continue;
1960.             }
1962.             $author = $entry->getAuthor();
1964.             $authors[] = $author->getFullName();
1965.         }
1967.         sort($authors);
1969.         return implode(', ', $authors);
1970.     }
1972.     #[Groups(['read:stats'])]
1973.     public function getStatsAuthorsAffiliations(): ?string
1974.     {
1975.         $affiliations = [];
1977.         /** @var JournalArticleAuthor */
1978.         foreach($this->authors as $entry) {
1979.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1980.                 continue;
1981.             }
1983.             $author = $entry->getAuthor();
1985.             /** @var Affiliation */
1986.             foreach($author->getAffiliations() as $affiliation) {
1987.                 if(isset($affiliations[$affiliation->getUuid()->toString()])) {
1988.                     continue;
1989.                 }
1991.                 $affiliations[$affiliation->getUuid()->toString()] = $affiliation->readNativeLanguageTranslation('title');
1992.             }
1993.         }
1995.         sort($affiliations);
1997.         return implode(', ',  $affiliations);
1998.     }
2000.     #[Groups(['read:stats'])]
2001.     public function getStatsAuthorsCountries(): ?string
2002.     {
2003.         $countries = [];
2005.         /** @var JournalArticleAuthor */
2006.         foreach($this->authors as $entry) {
2007.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
2008.                 continue;
2009.             }
2011.             $author = $entry->getAuthor();
2013.             /** @var Affiliation */
2014.             foreach($author->getAffiliations() as $affiliation) {
2015.                 if (! $affiliation->getCountry()) {
2016.                     continue;
2017.                 }
2019.                 if(isset($countries[$affiliation->getCountry()->value])) {
2020.                     continue;
2021.                 }
2023.                 $countries[$affiliation->getCountry()->value] = $affiliation->getCountry()->value;
2024.             }
2025.         }
2027.         sort($countries);
2029.         return implode(', ',  $countries);
2030.     }
2032.     #[Groups(['read:stats'])]
2033.     public function getStatsTranslators(): ?string
2034.     {
2035.         $authors = [];
2037.         /** @var JournalArticleAuthor */
2038.         foreach($this->authors as $entry) {
2039.             if ($entry->getRole() !== JournalArticleAuthorRole::TRANSLATOR) {
2040.                 continue;
2041.             }
2043.             $author = $entry->getAuthor();
2045.             $authors[] = $author->getFullName();
2046.         }
2048.         sort($authors);
2050.         return implode(', ', $authors);
2051.     }
2053.     #[Groups(['read:stats'])]
2054.     public function getStatsJournal(): string
2055.     {
2056.         return $this->parent->readNativeLanguageTranslation('title');
2057.     }
2059.     #[Groups(['read:stats'])]
2060.     public function getStatsJournalAffiliations(): string
2061.     {
2062.         $affiliations = [];
2064.         /** @var JournalAffiliation */
2065.         foreach($this->parent->getAffiliations() as $entry) {
2066.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
2067.                 continue;
2068.             }
2070.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
2071.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
2072.         }
2074.         sort($affiliations);
2076.         return implode(', ',  $affiliations);
2077.     }
2079.     #[Groups(['read:stats'])]
2080.     public function getStatsIssue(): string
2081.     {
2082.         return $this->issue->readNativeLanguageTranslation('title');
2083.     }
2085.     #[Groups(['read:stats'])]
2086.     public function getStatsVolume(): string
2087.     {
2088.         return $this->issue->getVolume()->readNativeLanguageTranslation('title');
2089.     }
2091.     #[Groups(['read:stats'])]
2092.     public function getStatsIssueFundingDescription(): ?string
2093.     {
2094.         return $this->issue->readNativeLanguageTranslation('fundingDescription');
2095.     }
2097.     #[Groups(['read:stats'])]
2098.     public function getStatsVolumeFundingDescription(): ?string
2099.     {
2100.         return $this->issue->getVolume()->readNativeLanguageTranslation('fundingDescription');
2101.     }
2103.     #[Groups(['read:stats'])]
2104.     public function getStatsSection(): ?string
2105.     {
2106.         return $this->section?->readNativeLanguageTranslation('title');
2107.     }
2109.     #[Groups(['read:stats'])]
2110.     public function getStatsKeywords(): ?string
2111.     {
2112.         $keywords = [];
2114.         $entries = $this->readMetadataTranslation($this->nativeMetadataLanguage, 'keywords');
2116.         /** @var JournalArticleMetadataTranslationKeyword */
2117.         foreach($entries as $entry) {
2118.             $keywords[] = $entry->getTitle();
2119.         }
2121.         sort($keywords);
2123.         return implode(', ', $keywords);
2124.     }
2126.     public function getStatsFullTextUrl(): ?string
2127.     {
2128.         return $this->statsFullTextUrl;
2129.     }
2131.     public function setStatsFullTextUrl(?string $statsFullTextUrl): self
2132.     {
2133.         $this->statsFullTextUrl = $statsFullTextUrl;
2135.         return $this;
2136.     }
2138.     public function getStatsArticleUrl(): ?string
2139.     {
2140.         return $this->statsArticleUrl;
2141.     }
2143.     public function setStatsArticleUrl(?string $statsArticleUrl): self
2144.     {
2145.         $this->statsArticleUrl = $statsArticleUrl;
2147.         return $this;
2148.     }
2150.     public function isForSale(): bool
2151.     {
2152.         if ($this->getIsOpen()) {
2153.             return false;
2154.         }
2156.         if (!$this->getPriceReal()) {
2157.             return false;
2158.         }
2160.         return true;
2161.     }
2163.     #[Groups(['read:' . self::class])]
2164.     public function getJournalSlug(): ?string
2165.     {
2166.         return $this->parent->getSlug();
2167.     }
2169.     #[Groups(['read:' . self::class])]
2170.     public function getParentLanguages(): array
2171.     {
2172.         return $this->getLanguageableParent()->getLanguages();
2173.     }
2175.     public function clone(): self
2176.     {
2177.         $clone = clone $this;
2179.         $clone->id = null;
2180.         $clone->setUuid();
2182.         $clone->ord = 0;
2183.         $clone->stat = false;
2184.         $clone->importId = null;
2186.         ClassUtils::cloneCollection($this, $clone, 'translations');
2187.         $clone->synchronizeTranslations();
2189.         $nativeLanguage = $clone->parent->getNativeLanguage();
2190.         $nativeTranslation = $clone->getTranslation($nativeLanguage);
2191.         $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
2193.         ClassUtils::cloneCollection($this, $clone, 'classifications');
2194.         ClassUtils::cloneCollection($this, $clone, 'researchDatas');
2195.         ClassUtils::cloneCollection($this, $clone, 'contentBlocks');
2196.         ClassUtils::cloneCollection($this, $clone, 'files');
2198.         $clone->statsAmountOfViews = 0;
2199.         $clone->statsAmountOfDownloads = 0;
2201.         $clone
2202.             ->resetAdditionalBlocks()
2203.             ->resetBibliographyEntries()
2204.             ->resetAuthors()
2205.             ->resetViewEntries()
2206.             ->resetDownloadEntries();
2208.         $clone->createdAt = new \DateTimeImmutable();
2209.         $clone->updatedAt = new \DateTimeImmutable();
2211.         return $clone;
2212.     }
2214.     /**
2215.      * @return Collection<int, CartProduct>
2216.      */
2217.     public function getCartProducts(): Collection
2218.     {
2219.         return $this->cartProducts;
2220.     }
2222.     public function addCartProduct(CartProduct $cartProduct): self
2223.     {
2224.         if (!$this->cartProducts->contains($cartProduct)) {
2225.             $this->cartProducts->add($cartProduct);
2226.             $cartProduct->setArticle($this);
2227.         }
2229.         return $this;
2230.     }
2232.     public function removeCartProduct(CartProduct $cartProduct): self
2233.     {
2234.         if ($this->cartProducts->removeElement($cartProduct)) {
2235.             // set the owning side to null (unless already changed)
2236.             if ($cartProduct->getArticle() === $this) {
2237.                 $cartProduct->setArticle(null);
2238.             }
2239.         }
2241.         return $this;
2242.     }
2243. }