1. <?php
3. namespace App\Entity;
5. use App\StateProvider\JournalArticleAutocompleteProvider;
6. use Doctrine\ORM\Mapping as ORM,
7.     Doctrine\DBAL\Types\Types,
8.     Doctrine\Common\Collections\Collection,
9.     Doctrine\Common\Collections\ArrayCollection;
11. use Doctrine\ORM\Mapping\Index;
12. use Gedmo\Mapping\Annotation as Gedmo;
14. use Symfony\Component\Serializer\Annotation\Groups,
15.     Symfony\Component\Validator\Constraints as Assert;
17. use ApiPlatform\Metadata\ApiResource,
18.     ApiPlatform\Metadata\ApiProperty,
19.     ApiPlatform\Metadata\Get,
20.     ApiPlatform\Metadata\GetCollection,
21.     ApiPlatform\Metadata\Post,
22.     ApiPlatform\Metadata\Put,
23.     ApiPlatform\Metadata\Delete,
24.     ApiPlatform\Metadata\ApiFilter,
25.     ApiPlatform\Doctrine\Orm\Filter\SearchFilter,
26.     ApiPlatform\Doctrine\Orm\Filter\DateFilter,
27.     ApiPlatform\Doctrine\Orm\Filter\ExistsFilter,
28.     ApiPlatform\Doctrine\Orm\Filter\OrderFilter,
29.     ApiPlatform\Doctrine\Orm\Filter\BooleanFilter,
30.     ApiPlatform\Doctrine\Orm\Filter\RangeFilter;
32. use App\Entity\Trait\IdTrait,
33.     App\Entity\Trait\UuidTrait,
34.     App\Entity\Trait\OrdStatTrait,
35.     App\Entity\Trait\TimestampableTrait,
36.     App\Entity\Trait\TranslatableTrait,
37.     App\Entity\Trait\Languages\LanguageableChildTrait,
38.     App\Entity\Trait\ArchivedTrait,
39.     App\Entity\Trait\ImportIdTrait,
40.     App\Entity\Interface\TranslatableInterface,
41.     App\Entity\Interface\OrdStatableInterface,
42.     App\Entity\Interface\LanguageableChildInterface,
43.     App\Entity\Interface\ArchivableInterface,
44.     App\Entity\Interface\CloneableInterface;
46. use App\Enum\JournalDateFormat,
47.     App\Enum\JournalArticleType,
48.     App\Enum\JournalLicence,
49.     App\Enum\JournalArticleFileType,
50.     App\Enum\AuthorProperty,
51.     App\Enum\JournalArticleAuthorRole,
52.     App\Doctrine\DBAL\Types\AuthorPropertiesType,
53.     App\Repository\JournalArticleRepository,
54.     App\Security\Voter\ArchivableVoter,
55.     App\Lib\Actions,
56.     App\DTO\CloneDTO,
57.     App\StateProcessor\CloneProcessor,
58.     App\Security\Voter\CloneVoter,
59.     App\Filter\IriFilter,
60.     App\Doctrine\DBAL\Types\LanguagesType;
62. use App\Util\ClassUtils,
63.     App\Enum\Language,
64.     App\Attribute\DenormalizationInject;
66. use App\Controller\Export\JournalArticle\JournalArticleCrossrefExporter,
67.     App\Controller\Export\JournalArticle\JournalArticleSimcheckCrossrefExporter,
68.     App\Controller\Export\JournalArticle\JournalArticleFundingCrossrefExporter,
69.     App\Controller\Export\JournalArticle\JournalArticleLicenceFulltextCrossrefExporter,
70.     App\Controller\Export\JournalArticle\JournalArticleReferencesCrossrefExporter,
71.     App\Controller\Export\JournalArticle\JournalArticleJATSExporter;
73. use App\Controller\Stats\StatsJournalArticleXlsxGenerator;
74. use App\Filter\OrderByUnmapped;
75. use App\StateProvider\StatsJournalArticleProvider;
76. use Symfony\Component\Serializer\Annotation\MaxDepth;
78. #[ApiResource(
79.     description: 'Journal articles',
80.     normalizationContext: ['groups' => [
81.         'read',
82.         'read:' . self::class,
83.         'read:' . self::class . 'Translation',
84.         'read:' . self::class . 'MetadataTranslation'
85.     ]],
86.     denormalizationContext: ['groups' => ['write']],
87.     security: 'is_granted("' . Journal::class . '")',
88.     order: ['ord' => 'desc'],
89.     operations: [
90.         new GetCollection(paginationMaximumItemsPerPage: 500, normalizationContext: ['groups' => ['read:minimal']]),
91.         new GetCollection(
92.             uriTemplate: '/journal_articles/autocomplete',
93.             provider: JournalArticleAutocompleteProvider::class,
94.             normalizationContext: ['groups' => ['read:autocomplete']],
95.         ),
96.         new GetCollection(
97.             name: 'get_journal_article_stats',
98.             uriTemplate: '/journal_articles/stats',
99.             provider: StatsJournalArticleProvider::class,
100.             security: 'is_granted("ROLE_MODULE_STATS")',
101.             normalizationContext: ['groups' => ['read:stats']],
102.             paginationMaximumItemsPerPage: 500
103.         ),
104.         new GetCollection(
105.             name: 'get_journal_article_stats_xlsx',
106.             uriTemplate: '/journal_articles/stats/xlsx',
107.             provider: StatsJournalArticleProvider::class,
108.             controller: StatsJournalArticleXlsxGenerator::class,
109.             security: 'is_granted("ROLE_MODULE_STATS")',
110.         ),
111.         new Post(
112.             uriTemplate: '/journal_articles/clone',
113.             input: CloneDTO::class,
114.             processor: CloneProcessor::class,
115.             security: 'is_granted("' . Actions::CLONE . '")',
116.             securityMessage: CloneVoter::MESSAGE
117.         ),
118.         new Post(denormalizationContext: ['groups' => ['write',  'post']]),
119.         new Get(),
120.         new Get(
121.             name: 'get_journal_article_crossref',
122.             uriTemplate: '/journal_articles/{uuid}/export/crossref',
123.             controller: JournalArticleCrossrefExporter::class
124.         ),
125.         new Get(
126.             name: 'get_journal_article_jats',
127.             uriTemplate: '/journal_articles/{uuid}/export/jats',
128.             controller: JournalArticleJATSExporter::class
129.         ),
130.         new Get(
131.             name: 'get_journal_article_simcheck_crossref',
132.             uriTemplate: '/journal_articles/{uuid}/export/simcheck_crossref',
133.             controller: JournalArticleSimcheckCrossrefExporter::class
134.         ),
135.         new Get(
136.             name: 'get_journal_article_funding_crossref',
137.             uriTemplate: '/journal_articles/{uuid}/export/funding_crossref',
138.             controller: JournalArticleFundingCrossrefExporter::class
139.         ),
140.         new Get(
141.             name: 'get_journal_article_licence_fulltext_crossref',
142.             uriTemplate: '/journal_articles/{uuid}/export/licence_fulltext_crossref',
143.             controller: JournalArticleLicenceFulltextCrossrefExporter::class
144.         ),
145.         new Get(
146.             name: 'get_journal_article_references_crossref',
147.             uriTemplate: '/journal_articles/{uuid}/export/references_crossref',
148.             controller: JournalArticleReferencesCrossrefExporter::class
149.         ),
150.         new Put(),
151.         new Delete(
152.             securityPostDenormalize: 'is_granted("' . Actions::DELETE . '", object)',
153.             securityPostDenormalizeMessage: ArchivableVoter::MESSAGE
154.         ),
155.     ],
156.     extraProperties: ['standard_put' => false],
157. )]
158. #[ApiFilter(SearchFilter::class, properties: [
159.     'translations.title' => 'partial',
160.     'nativeTitle' => 'partial',
161.     'workingTitle' => 'partial',
162.     'uuid' => 'exact',
163.     'doi' => 'partial',
164.     'parent.affiliations.affiliation.nativeTitle' => 'partial',
165.     'parent.nativeTitle' => 'partial',
166.     'issue.volume.translations.title' => 'partial',
167.     'issue.translations.title' => 'partial',
168.     'section.translations.title' => 'partial',
169.     'licence' => 'exact',
170.     'nativeMetadataLanguage' => 'exact',
171.     // 'authors.author.affiliations.nativeTitle' => 'partial', //not used see api/src/StateProvider/StatsJournalArticleProvider.php
172.     'authors.author.affiliations.country' => 'partial',
173.     'translations.metaKeywords' => 'partial'
174. ])]
175. #[ApiFilter(ExistsFilter::class, properties: ['doi'])]
176. #[ApiFilter(IriFilter::class, properties: [
177.     'parent',
178.     'issue',
179.     'type',
180.     'section'
181. ])]
182. #[ApiFilter(OrderByUnmapped::class, properties: ['statsIssue'])]
183. #[ApiFilter(DateFilter::class, properties: ['updatedAt', 'onlinePublishedAt', 'acceptedAt', 'receivedAt'])]
184. #[ApiFilter(BooleanFilter::class, properties: ['isArchived', 'stat'])]
185. #[ApiFilter(RangeFilter::class, properties: ['statsAmountOfViews', 'statsAmountOfDownloads'])]
186. #[ApiFilter(OrderFilter::class, properties: [
187.     'nativeTitle',
188.     'doi',
189.     'pageFrom',
190.     'isOpen',
191.     'onlinePublishedAt',
192.     'updatedAt',
193.     'receivedAt',
194.     'acceptedAt',
195.     'nativeMetadataLanguage',
196.     'parent.nativeTitle',
197.     // 'issue.nativeTitle',?? nie ma takiego pola
198.     // 'issue.volume.nativeTitle', ?? nie ma takiego pola
199.     // 'section.nativeTitle', ?? nie ma
200.     'ord',
201.     'statsAmountOfViews',
202.     'statsAmountOfDownloads'
203. ])]
204. #[Index(fields: ["importId"], name: "import_id_idx")]
205. #[Index(fields: ["stat"], name: "stat_idx")]
206. #[ORM\Entity(repositoryClass: JournalArticleRepository::class)]
207. class JournalArticle implements
208.     TranslatableInterface,
209.     OrdStatableInterface,
210.     LanguageableChildInterface,
211.     ArchivableInterface,
212.     CloneableInterface
213. {
214.     use IdTrait,
215.         UuidTrait,
216.         OrdStatTrait,
217.         TimestampableTrait,
218.         TranslatableTrait,
219.         LanguageableChildTrait,
220.         ArchivedTrait,
221.         ImportIdTrait;
223.     const DEFAULT_FILES = [
224.         JournalArticleFileType::BIBLIOGRAPHY,
225.         JournalArticleFileType::ABSTRACT_TEXT,
226.         JournalArticleFileType::FULL_TEXT
227.     ];
229.     #[ApiProperty(description: 'Parent', writableLink: false)]
230.     #[Groups(['read', 'post'])]
231.     #[ORM\ManyToOne(targetEntity: Journal::class, inversedBy: 'articles')]
232.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
233.     private Journal $parent;
235.     #[ApiProperty(description: 'Native title')]
236.     #[Groups(['read', 'read:stats', 'read:autocomplete'])]
237.     #[ORM\Column(type: Types::TEXT, nullable: true)]
238.     private ?string $nativeTitle = null;
240.     #[ApiProperty(description: 'Native title raw')]
241.     #[Groups(['read'])]
242.     #[ORM\Column(type: Types::TEXT, nullable: true)]
243.     private ?string $nativeTitleRaw = null;
245.     #[ApiProperty(description: 'Working title')]
246.     #[Groups(['read', 'read:minimal', 'write'])]
247.     #[Assert\NotBlank]
248.     #[ORM\Column(type: Types::STRING, length: 511)]
249.     private string $workingTitle;
251.     #[ApiProperty(description: 'Licence', writableLink: false)]
252.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
253.     #[ORM\Column(
254.         type: Types::STRING,
255.         enumType: JournalLicence::class,
256.         length: 255,
257.         options: ['default' => JournalLicence::CC_BY]
258.     )]
259.     private JournalLicence $licence = JournalLicence::CC_BY;
261.     #[ApiProperty(description: 'Issue', writableLink: false, fetchEager: false)]
262.     #[Groups(['read', 'write'])]
263.     #[Assert\NotNull]
264.     #[Assert\Expression(
265.         expression: '!this || value.getParent() === this.getParent()',
266.         message: 'Cannot assign issue from the outside of current journal.'
267.     )]
268.     #[ORM\ManyToOne(targetEntity: JournalIssue::class, inversedBy: 'articles')]
269.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
270.     private JournalIssue $issue;
272.     #[ApiProperty(description: 'Funding number')]
273.     #[Groups(['read:' . self::class, 'write'])]
274.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
275.     private ?string $fundingNumber = null;
277.     #[ApiProperty(description: 'Type', writableLink: false)]
278.     #[Groups(['read', 'read:minimal', 'read:stats', 'write'])]
279.     #[ORM\Column(
280.         type: Types::STRING,
281.         enumType: JournalArticleType::class,
282.         length: 255,
283.         options: [
284.             'default' => JournalArticleType::ORIGINAL_RESEARCH_ARTICLE
285.         ]
286.     )]
287.     private JournalArticleType $type = JournalArticleType::ORIGINAL_RESEARCH_ARTICLE;
289.     #[ApiProperty(description: 'Section', writableLink: false, fetchEager: false)]
290.     #[Groups(['read:' . self::class, 'read:minimal', 'write'])]
291.     #[MaxDepth(1)]
292.     #[ORM\ManyToOne(targetEntity: JournalSection::class)]
293.     #[ORM\JoinColumn(onDelete: 'set null')]
294.     private ?JournalSection $section = null;
296.     #[ApiProperty(description: 'DOI')]
297.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
298.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
299.     private ?string $doi = null;
301.     #[ApiProperty(description: 'Page from')]
302.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
303.     // #[Assert\Positive]
304.     #[ORM\Column(type: Types::STRING, nullable: true)] //, options: ['default' => 1])]
305.     private ?string $pageFrom = null;
307.     #[ApiProperty(description: 'Page to')]
308.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
309.     // #[Assert\Expression(
310.     //     expression: 'value >= this.getPageFrom()',
311.     //     message: 'Page to must be greater than page from.'
312.     // )]
313.     #[ORM\Column(type: Types::STRING, nullable: true)] //INTEGER, options: ['default' => 1])]
314.     private ?string $pageTo = null;
316.     #[ApiProperty(description: 'Citation type', writableLink: false)]
317.     #[Groups(['read:' . self::class, 'write'])]
318.     #[ORM\ManyToOne(targetEntity: CitationType::class)]
319.     #[ORM\JoinColumn(onDelete: 'set null')]
320.     private ?CitationType $citationType = null;
322.     #[ApiProperty(description: 'Citation')]
323.     #[Groups(['read:' . self::class, 'write'])]
324.     #[ORM\Column(type: Types::TEXT, nullable: true)]
325.     private ?string $citation = null;
327.     #[ApiProperty(description: 'Received at')]
328.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
329.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
330.     private ?\DateTimeImmutable $receivedAt = null;
332.     #[ApiProperty(description: 'Received at format', writableLink: false)]
333.     #[Groups(['read:' . self::class, 'write'])]
334.     #[ORM\Column(
335.         type: Types::STRING,
336.         enumType: JournalDateFormat::class,
337.         length: 255,
338.         options: ['default' => JournalDateFormat::COMPLETE]
339.     )]
340.     private JournalDateFormat $receivedAtFormat = JournalDateFormat::COMPLETE;
342.     #[ApiProperty(description: 'Accepted at')]
343.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
344.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
345.     private ?\DateTimeImmutable $acceptedAt = null;
347.     #[ApiProperty(description: 'Accepted at format', writableLink: false)]
348.     #[Groups(['read:' . self::class, 'write'])]
349.     #[ORM\Column(
350.         type: Types::STRING,
351.         enumType: JournalDateFormat::class,
352.         length: 255,
353.         options: ['default' => JournalDateFormat::COMPLETE]
354.     )]
355.     private JournalDateFormat $acceptedAtFormat = JournalDateFormat::COMPLETE;
357.     #[ApiProperty(description: 'Corrected at')]
358.     #[Groups(['read:' . self::class, 'write'])]
359.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
360.     private ?\DateTimeImmutable $correctedAt = null;
362.     #[ApiProperty(description: 'Corrected at format', writableLink: false)]
363.     #[Groups(['read:' . self::class, 'write'])]
364.     #[ORM\Column(
365.         type: Types::STRING,
366.         enumType: JournalDateFormat::class,
367.         length: 255,
368.         options: ['default' => JournalDateFormat::COMPLETE]
369.     )]
370.     private JournalDateFormat $correctedAtFormat = JournalDateFormat::COMPLETE;
372.     #[ApiProperty(description: 'Online published at')]
373.     #[Groups(['read:' . self::class, 'read:stats', 'write'])]
374.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
375.     private ?\DateTimeImmutable $onlinePublishedAt = null;
377.     #[ApiProperty(description: 'Online published at format', writableLink: false)]
378.     #[Groups(['read:' . self::class, 'write'])]
379.     #[ORM\Column(
380.         type: Types::STRING,
381.         enumType: JournalDateFormat::class,
382.         length: 255,
383.         options: ['default' => JournalDateFormat::COMPLETE]
384.     )]
385.     private JournalDateFormat $onlinePublishedAtFormat = JournalDateFormat::COMPLETE;
387.     #[ApiProperty(description: 'Is open')]
388.     #[Groups(['read:' . self::class, 'read:minimal', 'read:stats', 'write'])]
389.     #[ORM\Column(type: Types::BOOLEAN, options: ['default' => true])]
390.     private bool $isOpen = true;
392.     #[ApiProperty(description: 'Price')]
393.     #[Groups(['read:' . self::class])]
394.     #[Assert\PositiveOrZero]
395.     #[ORM\Column(type: Types::INTEGER, nullable: true)]
396.     private ?int $price = null;
398.     #[ApiProperty(description: 'Grace date')]
399.     #[Groups(['read:' . self::class, 'write'])]
400.     #[ORM\Column(type: Types::DATE_IMMUTABLE, nullable: true)]
401.     private ?\DateTimeImmutable $graceDate = null;
403.     #[ApiProperty(description: 'Meta link')]
404.     #[Groups(['read:' . self::class, 'write'])]
405.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
406.     private ?string $metaLink = null;
408.     /** @deprecated */
409.     #[ApiProperty(description: 'Language', writableLink: false)]
410.     #[Groups(['read:' . self::class, 'write'])]
411.     #[ORM\Column(
412.         type: Types::STRING,
413.         enumType: Language::class,
414.         length: 255,
415.         options: ['default' => Language::PL]
416.     )]
417.     private Language $language = Language::PL;
419.     #[ApiProperty(description: 'Visible author properties', writableLink: false)]
420.     #[Groups(['read:' . self::class, 'write'])]
421.     #[Assert\Choice(callback: [AuthorProperty::class, 'cases'], multiple: true)]
422.     #[Assert\Unique]
423.     #[Assert\Count(min: 1)]
424.     #[ORM\Column(type: AuthorPropertiesType::NAME)]
425.     private array $visibleAuthorProperties = [
426.         AuthorProperty::PREFIX,
427.         AuthorProperty::NAME,
428.         AuthorProperty::SURNAME,
429.         AuthorProperty::AFFILIATION
430.     ];
432.     #[ApiProperty(description: 'Publication languages', writableLink: false)]
433.     #[Groups(['read:' . self::class, 'write'])]
434.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
435.     #[Assert\Unique]
436.     #[Assert\Count(min: 1)]
437.     #[ORM\Column(type: LanguagesType::NAME)]
438.     private array $publicationLanguages = [Language::EN];
440.     #[ApiProperty(description: 'Metadata languages', writableLink: false)]
441.     #[Groups(['read:' . self::class, 'write', 'read:minimal'])]
442.     #[Assert\Choice(callback: [Language::class, 'cases'], multiple: true)]
443.     #[Assert\Unique]
444.     // #[Assert\Count(min: 1)]
445.     #[ORM\Column(type: LanguagesType::NAME)]
446.     private array $metadataLanguages = [Language::EN, Language::PL];
448.     #[ApiProperty(description: 'Native metadata language')]
449.     #[Groups(['read:' . self::class, 'read:stats', 'read:minimal'])]
450.     #[ORM\Column(
451.         type: Types::STRING,
452.         enumType: Language::class,
453.         length: 255,
454.         nullable: true,
455.     )]
456.     private ?Language $nativeMetadataLanguage = null;
458.     #[ApiProperty(description: 'Slug')]
459.     #[Groups(['read:' . self::class, 'write', 'read:minimal'])]
460.     #[Gedmo\Slug(separator: '-', style: 'default', updatable: true, fields: ['nativeTitleRaw'])]
461.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
462.     private ?string $slug = null;
464.     #[ApiProperty(description: 'Statistics: amount of views')]
465.     #[Groups(['read:stats'])]
466.     #[ORM\Column(type: Types::INTEGER)]
467.     private int $statsAmountOfViews = 0;
469.     #[ApiProperty(description: 'Statistics: amount of downloads')]
470.     #[Groups(['read:stats'])]
471.     #[ORM\Column(type: Types::INTEGER)]
472.     private int $statsAmountOfDownloads = 0;
474.     #[ApiProperty(description: 'Metadata translations')]
475.     #[Groups(['read', 'write', 'read:minimal'])]
476.     #[MaxDepth(2)]
477.     #[Assert\Type(Collection::class)]
478.     #[Assert\Valid]
479.     #[DenormalizationInject(method: ['name' => 'getMetadataTranslation', 'key' => 'lang'])]
480.     #[ORM\OneToMany(
481.         targetEntity: JournalArticleMetadataTranslation::class,
482.         mappedBy: 'parent',
483.         cascade: ['persist', 'remove'],
484.         orphanRemoval: true,
485.         indexBy: 'lang'
486.     )]
487.     private Collection $metadataTranslations;
489.     #[ApiProperty(description: 'Classifications')]
490.     #[ORM\OneToMany(targetEntity: JournalArticleClassification::class, mappedBy: 'parent', cascade: ['persist'])]
491.     #[ORM\OrderBy(['ord' => 'desc'])]
492.     private Collection $classifications;
494.     #[ApiProperty(description: 'Research datas')]
495.     #[ORM\OneToMany(targetEntity: JournalArticleResearchData::class, mappedBy: 'parent', cascade: ['persist'])]
496.     #[ORM\OrderBy(['ord' => 'desc'])]
497.     private Collection $researchDatas;
499.     #[ApiProperty(description: 'Relationships')]
500.     #[ORM\OneToMany(targetEntity: JournalArticleRelationship::class, mappedBy: 'parent', cascade: ['persist'])]
501.     #[ORM\OrderBy(['ord' => 'desc'])]
502.     private Collection $relationships;
504.     #[ApiProperty(description: 'Content blocks')]
505.     #[ORM\OneToMany(targetEntity: JournalArticleContentBlock::class, mappedBy: 'parent', cascade: ['persist'])]
506.     #[ORM\OrderBy(['ord' => 'desc'])]
507.     private Collection $contentBlocks;
509.     #[ApiProperty(description: 'Additional blocks')]
510.     #[ORM\OneToMany(targetEntity: JournalArticleAdditionalBlock::class, mappedBy: 'parent')]
511.     #[ORM\OrderBy(['ord' => 'desc'])]
512.     private Collection $additionalBlocks;
514.     #[ApiProperty(description: 'Bibliography entries')]
515.     #[ORM\OneToMany(
516.         targetEntity: JournalArticleBibliographyEntry::class,
517.         mappedBy: 'parent',
518.         cascade: ['persist', 'remove'],
519.         orphanRemoval: true
520.     )]
521.     #[ORM\OrderBy(['ord' => 'desc'])]
522.     private Collection $bibliographyEntries;
524.     #[ApiProperty(description: 'Files')]
525.     #[ORM\OneToMany(targetEntity: JournalArticleFile::class, mappedBy: 'parent', cascade: ['persist'])]
526.     #[ORM\OrderBy(['ord' => 'desc'])]
527.     private Collection $files;
529.     #[ApiProperty(description: 'Authors')]
530.     #[Groups(['read:' . self::class, 'read:minimal'])]
531.     #[MaxDepth(1)]
532.     #[ORM\OneToMany(targetEntity: JournalArticleAuthor::class, mappedBy: 'parent')]
533.     #[ORM\OrderBy(['ord' => 'desc'])]
534.     private Collection $authors;
536.     private ?array $redactors = null;
538.     #[ApiProperty(description: 'View entries')]
539.     #[ORM\OneToMany(targetEntity: JournalArticleViewEntry::class, mappedBy: 'parent', cascade: ['persist'])]
540.     #[ORM\OrderBy(['createdAt' => 'desc'])]
541.     private Collection $viewEntries;
543.     #[ApiProperty(description: 'Download entries')]
544.     #[ORM\OneToMany(targetEntity: JournalArticleDownloadEntry::class, mappedBy: 'parent', cascade: ['persist'])]
545.     #[ORM\OrderBy(['createdAt' => 'desc'])]
546.     private Collection $downloadEntries;
548.     #[ApiProperty(description: 'Slug title language', writableLink: false)]
549.     #[Groups(['read:' . self::class, 'read:minimal', 'write'])]
550.     #[Assert\Choice(callback: 'getMetadataLanguages', message: 'Można wybrać tylko jeden z języków tekstu.')]
551.     #[ORM\Column(
552.         type: Types::STRING,
553.         enumType: Language::class,
554.         length: 255,
555.         nullable: true,
556.     )]
557.     private ?Language $slugTitleLanguage = null;
559.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: JournalArticleSlugHistory::class, cascade: ['persist'], orphanRemoval: true,)]
560.     private Collection $slugHistory;
562.     #[ApiProperty(description: 'Is crossmark button visible')]
563.     #[Groups(['read:' . self::class, 'write'])]
564.     #[ORM\Column(type: Types::BOOLEAN, nullable: true)]
565.     private ?bool $isCrossmarkButtonVisible = null;
567.     #[ORM\OneToMany(mappedBy: 'article', targetEntity: CartProduct::class)]
568.     private Collection $cartProducts;
570.     #[ApiProperty(description: 'Statistics: full text url')]
571.     #[Groups(['read:stats'])]
572.     private ?string $statsFullTextUrl = null;
574.     #[ApiProperty(description: 'Statistics: article url')]
575.     #[Groups(['read:stats'])]
576.     private ?string $statsArticleUrl = null;
578.     public function __construct(Journal $parent, JournalIssue $issue)
579.     {
580.         $this->setUuid();
582.         $this->parent = $parent;
583.         $this->issue = $issue;
585.         $this->translations = new ArrayCollection();
586.         $this->metadataTranslations = new ArrayCollection();
588.         $this->classifications = new ArrayCollection();
589.         $this->researchDatas = new ArrayCollection();
590.         $this->relationships = new ArrayCollection();
591.         $this->contentBlocks = new ArrayCollection();
592.         $this->additionalBlocks = new ArrayCollection();
593.         $this->bibliographyEntries = new ArrayCollection();
594.         $this->files = new ArrayCollection();
595.         $this->authors = new ArrayCollection();
597.         $this->viewEntries = new ArrayCollection();
598.         $this->downloadEntries = new ArrayCollection();
599.         $this->slugHistory = new ArrayCollection();
601.         foreach ($this->parent->getLanguages() as $lang) {
602.             new JournalArticleTranslation($this, $lang);
603.         }
605.         foreach ($this->metadataLanguages as $lang) {
606.             new JournalArticleMetadataTranslation($this, $lang);
607.         }
609.         foreach (self::DEFAULT_FILES as $type) {
610.             new JournalArticleFile($this, $type);
611.         }
613.         $this->isOpen = $issue->getIsOpen();
614.         $this->price = $parent->getData()->getArticlePrice() ?? $parent->getData()->getIssuePrice();
616.         $this->citationType = $issue->getSuggestedCitationType();
618.         $this->licence = $issue->getLicence();
619.         $this->isCrossmarkButtonVisible = $issue->getIsCrossmarkButtonVisible();
621.         $this->createdAt = new \DateTimeImmutable();
622.         $this->updatedAt = new \DateTimeImmutable();
624.         $parent->addArticle($this);
625.         $this->cartProducts = new ArrayCollection();
626.     }
628.     public function getParent(): Journal
629.     {
630.         return $this->parent;
631.     }
633.     public function getNativeMetadataLanguage(): ?Language
634.     {
635.         return $this->nativeMetadataLanguage;
636.     }
638.     public function getNativeTitle(): ?string
639.     {
640.         return $this->nativeTitle;
641.     }
643.     public function setNativeTitle(?string $nativeTitle): self
644.     {
645.         $this->nativeTitle = $nativeTitle;
647.         return $this;
648.     }
650.     public function getNativeTitleRaw(): ?string
651.     {
652.         return $this->nativeTitleRaw;
653.     }
655.     public function setNativeTitleRaw(?string $nativeTitleRaw): self
656.     {
657.         $this->nativeTitleRaw = $nativeTitleRaw;
659.         $this->addCurrentSlugToHistory();
661.         return $this;
662.     }
664.     public function getWorkingTitle(): ?string
665.     {
666.         return $this->workingTitle;
667.     }
669.     public function setWorkingTitle(?string $workingTitle): self
670.     {
671.         $this->workingTitle = $workingTitle;
673.         return $this;
674.     }
676.     public function getLicence(): JournalLicence
677.     {
678.         return $this->licence;
679.     }
681.     public function setLicence(JournalLicence $licence): self
682.     {
683.         $this->licence = $licence;
685.         return $this;
686.     }
688.     public function getIssue(): JournalIssue
689.     {
690.         return $this->issue;
691.     }
693.     public function setIssue(JournalIssue $issue): self
694.     {
695.         $this->issue = $issue;
697.         return $this;
698.     }
700.     public function getFundingNumber(): ?string
701.     {
702.         return $this->fundingNumber;
703.     }
705.     public function setFundingNumber(?string $fundingNumber): self
706.     {
707.         $this->fundingNumber = $fundingNumber;
709.         return $this;
710.     }
712.     public function getType(): JournalArticleType
713.     {
714.         return $this->type;
715.     }
717.     public function setType(JournalArticleType $type): self
718.     {
719.         $this->type = $type;
721.         return $this;
722.     }
724.     public function getSection(): ?JournalSection
725.     {
726.         return $this->section;
727.     }
729.     public function setSection(?JournalSection $section): self
730.     {
731.         $this->section = $section;
733.         return $this;
734.     }
736.     public function getDoi(): ?string
737.     {
738.         return $this->doi;
739.     }
741.     public function setDoi(?string $doi): self
742.     {
743.         $this->doi = $doi;
745.         return $this;
746.     }
748.     public function getPageFrom(): ?string
749.     {
750.         return $this->pageFrom;
751.     }
753.     public function setPageFrom(?string $pageFrom): self
754.     {
755.         $this->pageFrom = $pageFrom;
757.         return $this;
758.     }
760.     public function getPageTo(): ?string
761.     {
762.         return $this->pageTo;
763.     }
765.     public function setPageTo(?string $pageTo): self
766.     {
767.         $this->pageTo = $pageTo;
769.         return $this;
770.     }
772.     public function getCitationType(): ?CitationType
773.     {
774.         return $this->citationType;
775.     }
777.     public function setCitationType(?CitationType $citationType): self
778.     {
779.         $this->citationType = $citationType;
781.         return $this;
782.     }
784.     public function getCitation(): ?string
785.     {
786.         return $this->citation;
787.     }
789.     public function setCitation(?string $citation): self
790.     {
791.         $this->citation = $citation;
793.         return $this;
794.     }
796.     public function getReceivedAt(): ?\DateTimeImmutable
797.     {
798.         return $this->receivedAt;
799.     }
801.     public function setReceivedAt(?\DateTimeImmutable $receivedAt): self
802.     {
803.         $this->receivedAt = $receivedAt;
805.         return $this;
806.     }
808.     public function getReceivedAtFormat(): JournalDateFormat
809.     {
810.         return $this->receivedAtFormat;
811.     }
813.     public function setReceivedAtFormat(JournalDateFormat $receivedAtFormat): self
814.     {
815.         $this->receivedAtFormat = $receivedAtFormat;
817.         return $this;
818.     }
820.     public function getAcceptedAt(): ?\DateTimeImmutable
821.     {
822.         return $this->acceptedAt;
823.     }
825.     public function setAcceptedAt(?\DateTimeImmutable $acceptedAt): self
826.     {
827.         $this->acceptedAt = $acceptedAt;
829.         return $this;
830.     }
832.     public function getAcceptedAtFormat(): JournalDateFormat
833.     {
834.         return $this->acceptedAtFormat;
835.     }
837.     public function setAcceptedAtFormat(JournalDateFormat $acceptedAtFormat): self
838.     {
839.         $this->acceptedAtFormat = $acceptedAtFormat;
841.         return $this;
842.     }
844.     public function getCorrectedAt(): ?\DateTimeImmutable
845.     {
846.         return $this->correctedAt;
847.     }
849.     public function setCorrectedAt(?\DateTimeImmutable $correctedAt): self
850.     {
851.         $this->correctedAt = $correctedAt;
853.         return $this;
854.     }
856.     public function getCorrectedAtFormat(): JournalDateFormat
857.     {
858.         return $this->correctedAtFormat;
859.     }
861.     public function setCorrectedAtFormat(JournalDateFormat $correctedAtFormat): self
862.     {
863.         $this->correctedAtFormat = $correctedAtFormat;
865.         return $this;
866.     }
868.     public function getOnlinePublishedAt(): ?\DateTimeImmutable
869.     {
870.         return $this->onlinePublishedAt;
871.     }
873.     public function setOnlinePublishedAt(?\DateTimeImmutable $onlinePublishedAt): self
874.     {
875.         if ($this->onlinePublishedAt === $onlinePublishedAt) {
876.             return $this;
877.         }
879.         $this->onlinePublishedAt = $onlinePublishedAt;
881.         if (!$onlinePublishedAt) {
882.             return $this;
883.         }
885.         $period = $this->parent->getData()->getOpenAccessGrantedAfterPeriod();
887.         if (!$period) {
888.             return $this;
889.         }
891.         $graceDate = new \DateTime("@{$this->onlinePublishedAt->getTimestamp()}");
892.         $graceDate->modify($period);
894.         $this->graceDate = new \DateTimeImmutable("@{$graceDate->getTimestamp()}");
896.         return $this;
897.     }
899.     public function getOnlinePublishedAtFormat(): JournalDateFormat
900.     {
901.         return $this->onlinePublishedAtFormat;
902.     }
904.     public function setOnlinePublishedAtFormat(JournalDateFormat $onlinePublishedAtFormat): self
905.     {
906.         $this->onlinePublishedAtFormat = $onlinePublishedAtFormat;
908.         return $this;
909.     }
911.     public function getAllDatesFormatted(): array
912.     {
913.         $properties = ['ReceivedAt', 'AcceptedAt', 'CorrectedAt', 'OnlinePublishedAt'];
914.         $dates = [];
916.         foreach ($properties as $property) {
917.             $date = $this->{'get' . $property}();
919.             $dates[$property] = null;
921.             if (!$date) {
922.                 continue;
923.             }
925.             $dates[$property] = match ($this->{'get' . $property . 'Format'}()) {
926.                 JournalDateFormat::YEAR => $date->format('Y'),
927.                 JournalDateFormat::YEAR_AND_MONTH => $date->format('m.Y'),
928.                 JournalDateFormat::COMPLETE => $date->format('d.m.Y'),
929.                 default => null,
930.             };
931.         }
933.         return $dates;
934.     }
936.     public function getIsOpen(): bool
937.     {
938.         return $this->isOpen;
939.     }
941.     public function setIsOpen(bool $isOpen): self
942.     {
943.         $this->isOpen = $isOpen;
945.         return $this;
946.     }
948.     public function getPrice(): ?int
949.     {
950.         return $this->price;
951.     }
953.     #[Groups(['read:' . self::class, 'read:' . Journal::class])]
954.     public function getPriceReal(): ?float
955.     {
956.         return $this->price ? round($this->price / 1000, 2) : null;
957.     }
959.     public function setPrice(?int $price): self
960.     {
961.         $this->price = $price;
963.         return $this;
964.     }
966.     #[Groups(['write'])]
967.     public function setPriceReal(?float $priceReal): self
968.     {
969.         $this->price = (int) ($priceReal * 1000);
971.         return $this;
972.     }
974.     public function getGraceDate(): ?\DateTimeImmutable
975.     {
976.         return $this->graceDate;
977.     }
979.     public function setGraceDate(?\DateTimeImmutable $graceDate): self
980.     {
981.         $this->graceDate = $graceDate;
983.         return $this;
984.     }
986.     public function getMetaLink(): ?string
987.     {
988.         return $this->metaLink;
989.     }
991.     public function setMetaLink(?string $metaLink): self
992.     {
993.         $this->metaLink = $metaLink;
995.         return $this;
996.     }
998.     /** @deprecated */
999.     public function getLanguage(): Language
1000.     {
1001.         return $this->language;
1002.     }
1004.     /** @deprecated */
1005.     public function setLanguage(Language $language): self
1006.     {
1007.         $this->language = $language;
1009.         return $this;
1010.     }
1012.     public function getVisibleAuthorProperties(): array
1013.     {
1014.         return $this->visibleAuthorProperties;
1015.     }
1017.     public function setVisibleAuthorProperties(array $visibleAuthorProperties): self
1018.     {
1019.         $this->visibleAuthorProperties = $visibleAuthorProperties;
1021.         return $this;
1022.     }
1024.     public function getPublicationLanguages(): array
1025.     {
1026.         return $this->publicationLanguages;
1027.     }
1029.     public function setPublicationLanguages(array $publicationLanguages): self
1030.     {
1031.         $this->publicationLanguages = $publicationLanguages;
1033.         return $this;
1034.     }
1036.     public function getMetadataLanguages(): array
1037.     {
1038.         return $this->metadataLanguages;
1039.     }
1041.     public function setMetadataLanguages(array $metadataLanguages): self
1042.     {
1043.         $this->metadataLanguages = $metadataLanguages;
1045.         /** @var JournalArticleMetadataTranslation */
1046.         foreach ($this->metadataTranslations as $metadataTranslation) {
1047.             if (in_array($metadataTranslation->getLang(), $this->metadataLanguages)) {
1048.                 continue;
1049.             }
1051.             $this->deleteMetadataTranslation($metadataTranslation);
1052.         }
1054.         foreach ($this->metadataLanguages as $lang) {
1055.             if (!$lang instanceof Language || isset($this->metadataTranslations[$lang->value])) {
1056.                 continue;
1057.             }
1059.             $class = JournalArticleMetadataTranslation::class;
1060.             new $class($this, $lang);
1061.         }
1063.         if (count($metadataLanguages) < 1) {
1064.             $this->nativeMetadataLanguage = null;
1066.             return $this;
1067.         }
1069.         $this->nativeMetadataLanguage = $this->metadataLanguages[array_key_first($this->metadataLanguages)];
1071.         return $this;
1072.     }
1074.     public function getAvailableMetadataLanguages(string $property): array
1075.     {
1076.         $langs = [];
1078.         foreach ($this->metadataLanguages as $lang) {
1079.             /** @var JournalArticleMetadataTranslation */
1080.             $metadataTranslation = $this->getMetadataTranslation($lang);
1082.             switch ($property) {
1083.                 case 'abstract':
1084.                     if (!empty($metadataTranslation->getAbstract())) {
1085.                         $langs[] = $lang;
1086.                     }
1087.                     break;
1088.                 case 'keywords':
1089.                     if (!empty($metadataTranslation->getKeywords())) {
1090.                         $langs[] = $lang;
1091.                     }
1092.                     break;
1093.                 case 'title':
1094.                     if (!empty($metadataTranslation->getTitle())) {
1095.                         $langs[] = $lang;
1096.                     }
1097.                 default:
1098.                     break;
1099.             }
1100.         }
1102.         return $langs;
1103.     }
1105.     public function getSlug(): ?string
1106.     {
1107.         return $this->slug;
1108.     }
1110.     public function setSlug(?string $slug): self
1111.     {
1112.         $this->slug = $slug;
1114.         return $this;
1115.     }
1117.     public function getStatsAmountOfViews(): int
1118.     {
1119.         return $this->statsAmountOfViews;
1120.     }
1122.     public function hitStatsView(): int
1123.     {
1124.         return $this->statsAmountOfViews++;
1125.     }
1127.     /*
1128.     public function updateStatsView(int $amount): self
1129.     {
1130.         $this->statsAmountOfViews += $amount;
1132.         return $this;
1133.     }*/
1135.     public function getStatsAmountOfDownloads(): int
1136.     {
1137.         return $this->statsAmountOfDownloads;
1138.     }
1140.     public function hitStatsDownload(): int
1141.     {
1142.         return $this->statsAmountOfDownloads++;
1143.     }
1145.     /*
1146.     public function updateStatsDownload(int $amount): self
1147.     {
1148.         $this->statsAmountOfDownloads += $amount;
1150.         return $this;
1151.     }*/
1153.     /**
1154.      * @return Collection|JournalArticleMetadataTranslation[]
1155.      */
1156.     public function getMetadataTranslations(): Collection
1157.     {
1158.         return $this->metadataTranslations;
1159.     }
1161.     public function getMetadataTranslation(Language $lang): mixed
1162.     {
1163.         return $this->metadataTranslations[$lang->value] ?? null;
1164.     }
1166.     public function addMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1167.     {
1168.         if ($this->metadataTranslations->contains($metadataTranslation)) {
1169.             return $this;
1170.         }
1172.         $this->metadataTranslations[$metadataTranslation->getLang()->value] = $metadataTranslation;
1174.         return $this;
1175.     }
1177.     public function deleteMetadataTranslation(JournalArticleMetadataTranslation $metadataTranslation): self
1178.     {
1179.         $this->metadataTranslations->removeElement($metadataTranslation);
1181.         return $this;
1182.     }
1184.     public function resetMetadataTranslations(): self
1185.     {
1186.         $this->metadataTranslations = new ArrayCollection();
1188.         return $this;
1189.     }
1191.     public function readMetadataTranslation(null|string|Language $lang, string $property): mixed
1192.     {
1193.         if (!$lang) {
1194.             return null;
1195.         }
1197.         $lang = is_string($lang)
1198.             ? Language::from($lang)
1199.             : $lang;
1201.         if (!isset($this->metadataTranslations[$lang->value])) {
1202.             return null;
1203.         }
1205.         if (!str_contains($property, '.')) {
1206.             return $this->metadataTranslations[$lang->value]->{'get' . ucfirst($property)}();
1207.         }
1209.         $path = explode('.', $property);
1210.         $current = array_shift($path);
1212.         return $this->readProperty(
1213.             object: $this->metadataTranslations[$lang->value]->{'get' . ucfirst($current)}(),
1214.             path: $path
1215.         );
1216.     }
1218.     public function readAvailableMetadataTranslation(
1219.         string|Language $lang,
1220.         string $property,
1221.         bool $isNotEmpty = true
1222.     ): mixed {
1223.         $lang = is_string($lang)
1224.             ? Language::from($lang)
1225.             : $lang;
1227.         if (!$this->isLanguageAvailable($lang, $this->metadataLanguages)) {
1228.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1229.         }
1231.         $value = $this->readMetadataTranslation($lang, $property);
1233.         if ($isNotEmpty && empty($value)) {
1234.             return $this->readMetadataTranslation($this->nativeMetadataLanguage, $property);
1235.         }
1237.         return $value;
1238.     }
1240.     private function isLanguageAvailable(Language $lang, ?array $languages): bool
1241.     {
1242.         return !$languages || in_array($lang, $languages);
1243.     }
1245.     /**
1246.      * @return Collection|JournalArticleClassification[]
1247.      */
1248.     public function getClassifications(): Collection
1249.     {
1250.         return $this->classifications;
1251.     }
1253.     public function getVisibleClassifications(): Collection
1254.     {
1255.         return $this->getClassifications()->filter(
1256.             fn (JournalArticleClassification $classification) => $classification->getType()->getStat() === true
1257.         );
1258.     }
1260.     public function addClassification(JournalArticleClassification $classification): self
1261.     {
1262.         if ($this->classifications->contains($classification)) {
1263.             return $this;
1264.         }
1266.         $this->classifications[] = $classification;
1268.         return $this;
1269.     }
1271.     public function removeClassification(JournalArticleClassification $classification): self
1272.     {
1273.         $this->classifications->removeElement($classification);
1275.         return $this;
1276.     }
1278.     public function resetClassifications(): self
1279.     {
1280.         $this->classifications = new ArrayCollection();
1282.         return $this;
1283.     }
1285.     /**
1286.      * @return Collection|JournalArticleResearchData[]
1287.      */
1288.     public function getResearchDatas(): Collection
1289.     {
1290.         return $this->researchDatas;
1291.     }
1293.     public function addResearchData(JournalArticleResearchData $researchData): self
1294.     {
1295.         if ($this->researchDatas->contains($researchData)) {
1296.             return $this;
1297.         }
1299.         $this->researchDatas[] = $researchData;
1301.         return $this;
1302.     }
1304.     public function removeResearchData(JournalArticleResearchData $researchData): self
1305.     {
1306.         $this->researchDatas->removeElement($researchData);
1308.         return $this;
1309.     }
1311.     public function resetResearchDatas(): self
1312.     {
1313.         $this->researchDatas = new ArrayCollection();
1315.         return $this;
1316.     }
1318.     /**
1319.      * @return Collection|JournalArticleRelationship[]
1320.      */
1321.     public function getRelationships(): Collection
1322.     {
1323.         return $this->relationships;
1324.     }
1326.     /**
1327.      * @return JournalArticleRelationship[]
1328.      */
1329.     public function getRelationshipsVisible(): array
1330.     {
1331.         $relations = [];
1333.         foreach ($this->getRelationships() as $relationship) {
1334.             if (!$relationship->getTargetArticle()?->getStat()) {
1335.                 continue;
1336.             }
1338.             $relations[] = $relationship;
1339.         }
1341.         return $relations;
1342.     }
1344.     public function addRelationship(JournalArticleRelationship $relationship): self
1345.     {
1346.         if ($this->relationships->contains($relationship)) {
1347.             return $this;
1348.         }
1350.         $this->relationships[] = $relationship;
1352.         return $this;
1353.     }
1355.     public function removeRelationship(JournalArticleRelationship $relationship): self
1356.     {
1357.         $this->relationships->removeElement($relationship);
1359.         return $this;
1360.     }
1362.     public function resetRelationships(): self
1363.     {
1364.         $this->relationships = new ArrayCollection();
1366.         return $this;
1367.     }
1369.     /**
1370.      * @return Collection|JournalArticleContentBlock[]
1371.      */
1372.     public function getContentBlocks(): Collection
1373.     {
1374.         return $this->contentBlocks;
1375.     }
1377.     public function getVisibleContentBlocks(): Collection
1378.     {
1379.         return $this->contentBlocks->filter(
1380.             fn (JournalArticleContentBlock $block) => $block->getStat() === true
1381.         );
1382.     }
1384.     public function addContentBlock(JournalArticleContentBlock $contentBlock): self
1385.     {
1386.         if ($this->contentBlocks->contains($contentBlock)) {
1387.             return $this;
1388.         }
1390.         $this->contentBlocks[] = $contentBlock;
1392.         return $this;
1393.     }
1395.     public function removeContentBlock(JournalArticleContentBlock $contentBlock): self
1396.     {
1397.         $this->contentBlocks->removeElement($contentBlock);
1399.         return $this;
1400.     }
1402.     public function resetContentBlocks(): self
1403.     {
1404.         $this->contentBlocks = new ArrayCollection();
1406.         return $this;
1407.     }
1409.     /**
1410.      * @return Collection|JournalArticleAddditionalBlock[]
1411.      */
1412.     public function getAdditionalBlocks(): Collection
1413.     {
1414.         return $this->additionalBlocks;
1415.     }
1417.     public function getVisibleAdditionalBlocks(): Collection
1418.     {
1419.         return $this->additionalBlocks->filter(
1420.             fn (JournalArticleAdditionalBlock $block) => $block->getStat() === true
1421.         );
1422.     }
1424.     public function addAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1425.     {
1426.         if ($this->additionalBlocks->contains($additionalBlock)) {
1427.             return $this;
1428.         }
1430.         $this->additionalBlocks[] = $additionalBlock;
1432.         return $this;
1433.     }
1435.     public function removeAdditionalBlock(JournalArticleAdditionalBlock $additionalBlock): self
1436.     {
1437.         $this->additionalBlocks->removeElement($additionalBlock);
1439.         return $this;
1440.     }
1442.     public function resetAdditionalBlocks(): self
1443.     {
1444.         $this->additionalBlocks = new ArrayCollection();
1446.         return $this;
1447.     }
1449.     /**
1450.      * @return Collection|JournalArticleBibliographyEntry[]
1451.      */
1452.     public function getBibliographyEntries(): Collection
1453.     {
1454.         return $this->bibliographyEntries;
1455.     }
1457.     public function addBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1458.     {
1459.         if ($this->bibliographyEntries->contains($bibliographyEntry)) {
1460.             return $this;
1461.         }
1463.         $this->bibliographyEntries[] = $bibliographyEntry;
1465.         return $this;
1466.     }
1468.     public function removeBibliographyEntry(JournalArticleBibliographyEntry $bibliographyEntry): self
1469.     {
1470.         $this->bibliographyEntries->removeElement($bibliographyEntry);
1472.         return $this;
1473.     }
1475.     public function resetBibliographyEntries(): self
1476.     {
1477.         $this->bibliographyEntries = new ArrayCollection();
1479.         return $this;
1480.     }
1482.     public function importBibliography(): self
1483.     {
1484.         $nativeLanguage = $this->getParentNativeLanguage();
1485.         $nativeTranslation = $this->getTranslation($nativeLanguage);
1487.         if (!$nativeTranslation?->getImportedBibliography()) {
1488.             return $this;
1489.         }
1491.         $otherLanguages = array_filter(
1492.             $this->getParentLanguages(),
1493.             fn (Language $lang) => $nativeLanguage !== $lang
1494.         );
1496.         $imported = [];
1498.         foreach ([$nativeLanguage] + $otherLanguages as $lang) {
1499.             $imported[$lang->value] = $this->getImportedBibliographyEntries($lang);
1500.         }
1502.         $this->resetBibliographyEntries();
1504.         $ord = count($imported[$nativeLanguage->value]);
1506.         foreach ($imported[$nativeLanguage->value] as $key => $title) {
1507.             preg_match('/10.\d{4,9}\/[-._;()\/:A-Z0-9]+$/i', $title, $doi);
1509.             $entry = new JournalArticleBibliographyEntry($this);
1510.             $entry
1511.                 ->setDoi($doi[0] ?? null)
1512.                 ->setOrd($ord--);
1514.             $translation = $entry->getTranslation($nativeLanguage);
1515.             $translation->setTitle($title);
1517.             $this->fillBibliographyEntryTranslations(
1518.                 entry: $entry,
1519.                 languages: $otherLanguages,
1520.                 imported: $imported,
1521.                 key: $key
1522.             );
1523.         }
1525.         return $this;
1526.     }
1528.     private function getImportedBibliographyEntries(Language $lang): array
1529.     {
1530.         $importedBibliography = $this->getTranslation($lang)?->getImportedBibliography() ?? '';
1532.         $bibliographyEntries = array_map(
1533.             fn (string $bibliograpyEntry) => trim($bibliograpyEntry),
1534.             preg_split('/\r\n|\r|\n|<br>|<br \/>|<br\/>/', $importedBibliography)
1535.         );
1537.         $bibliographyEntries = array_filter(
1538.             $bibliographyEntries,
1539.             fn (string $bibliograpyEntry) => !empty($bibliograpyEntry)
1540.         );
1542.         return $bibliographyEntries;
1543.     }
1545.     private function fillBibliographyEntryTranslations(
1546.         JournalArticleBibliographyEntry $entry,
1547.         array $languages,
1548.         array $imported,
1549.         int $key
1550.     ): self {
1551.         foreach ($languages as $language) {
1552.             $translation = $entry->getTranslation($language);
1553.             $translation->setTitle($imported[$language->value][$key] ?? null);
1554.         }
1556.         return $this;
1557.     }
1559.     /**
1560.      * @return Collection|JournalArticleFile[]
1561.      */
1562.     public function getFiles(): Collection
1563.     {
1564.         return $this->files;
1565.     }
1567.     public function addFile(JournalArticleFile $file): self
1568.     {
1569.         if ($this->files->contains($file)) {
1570.             return $this;
1571.         }
1573.         $this->files[] = $file;
1575.         return $this;
1576.     }
1578.     public function removeFile(JournalArticleFile $file): self
1579.     {
1580.         $this->files->removeElement($file);
1582.         return $this;
1583.     }
1585.     public function resetFiles(): self
1586.     {
1587.         $this->files = new ArrayCollection();
1589.         return $this;
1590.     }
1592.     #[Groups(['read:' . self::class, 'read:minimal'])]
1593.     public function getHasFiles(): bool
1594.     {
1595.         foreach ($this->files as $file) {
1596.             if (!$file->getHasFiles()) {
1597.                 continue;
1598.             }
1600.             return true;
1601.         }
1603.         return false;
1604.     }
1606.     public function getFullTextFile(): ?JournalArticleFile
1607.     {
1608.         foreach ($this->files as $file) {
1609.             if (!$file->getStat() || $file->getType() !== JournalArticleFileType::FULL_TEXT) {
1610.                 continue;
1611.             }
1613.             return $file;
1614.         }
1616.         return null;
1617.     }
1619.     public function getFullTextTranslationFile(string|Language $lang): ?JournalArticleFileTranslationFile
1620.     {
1621.         $fullText = $this->getFullTextFile();
1623.         if (!$fullText) {
1624.             return null;
1625.         }
1627.         $lang = is_string($lang)
1628.             ? Language::from($lang)
1629.             : $lang;
1631.         $files = $fullText->readAvailableTranslation($lang, 'files');
1633.         if (!$files) {
1634.             return null;
1635.         }
1637.         return ($first = $files->first()) === false ? null : $first;
1638.     }
1640.     public function getFullTextExtensions(): array
1641.     {
1642.         $fullText = $this->getFullTextFile();
1644.         if (!$fullText) {
1645.             return [];
1646.         }
1648.         $extensions = [];
1650.         /** @var JournalArticleFileTranslation $translation */
1651.         foreach ($fullText->getTranslations() as $translation) {
1652.             /** @var JournalArticleFileTranslationFile $file */
1653.             foreach ($translation->getVisibleFiles() as $file) {
1654.                 if ($file->getMedia()?->getExtension()) {
1655.                     $extensions[] = $file->getMedia()->getExtension();
1656.                 }
1657.             }
1658.         }
1660.         return array_unique($extensions);
1661.     }
1663.     /** @return <int, JournalArticleFileTranslationFile> */
1664.     public function getAdditionalFiles(string|Language $lang): array
1665.     {
1666.         $lang = is_string($lang)
1667.             ? Language::from($lang)
1668.             : $lang;
1669.         $files = [];
1671.         foreach ($this->files as $file) {
1672.             if (!$file->getStat() || $file->getType() === JournalArticleFileType::FULL_TEXT) {
1673.                 continue;
1674.             }
1676.             $files[] = $file;
1677.         }
1679.         $finalFiles = [];
1681.         /** @var JournalArticleFile $file */
1682.         foreach ($files as $file) {
1683.             /** @var JournalArticleFileTranslation $trans */
1684.             $files = $file->readAvailableTranslation($lang, 'files');
1685.             if (!$files) {
1686.                 continue;
1687.             }
1689.             foreach ($files as $finalFile) {
1690.                 if (!$finalFile->getMedia() || !$finalFile->getTitle()) {
1691.                     continue;
1692.                 }
1694.                 $finalFiles[] = $finalFile;
1695.             }
1696.         }
1698.         return $finalFiles;
1699.     }
1701.     public function getFileByType(JournalArticleFileType $type): ?JournalArticleFile
1702.     {
1703.         return $this->files->findFirst(
1704.             fn (int $key, JournalArticleFile $file) => $file->getType() === $type
1705.         );
1706.     }
1708.     /**
1709.      * @return Collection|JournalArticleAuthor[]
1710.      */
1711.     public function getAuthors(): Collection
1712.     {
1713.         return $this->authors;
1714.     }
1716.     public function setAuthors(array $authors): self
1717.     {
1718.         foreach ($authors as $author) {
1719.             $this->authors[] = $author;
1720.         }
1722.         return $this;
1723.     }
1725.     public function addAuthor(JournalArticleAuthor $author): self
1726.     {
1727.         if ($this->authors->contains($author)) {
1728.             return $this;
1729.         }
1731.         $this->authors[] = $author;
1733.         return $this;
1734.     }
1736.     public function removeAuthor(JournalArticleAuthor $author): self
1737.     {
1738.         $this->authors->removeElement($author);
1740.         return $this;
1741.     }
1743.     public function resetAuthors(): self
1744.     {
1745.         $this->authors = new ArrayCollection();
1747.         return $this;
1748.     }
1750.     public function getVisibleAuthors(string|Language $lang, ?Author $highlightAuthor = null): array
1751.     {
1752.         $lang = !is_string($lang)
1753.             ? $lang
1754.             : Language::from($lang);
1756.         $authors = $this->getVisibleAuthorsByRole($lang, JournalArticleAuthorRole::AUTHOR);
1758.         if (null !== $highlightAuthor) {
1759.             $authors = [
1760.                 $highlightAuthor,
1761.                 ...array_filter(
1762.                     $authors,
1763.                     fn (JournalArticleAuthor $author) => $author->getAuthor()->getUuid() === $highlightAuthor->getUuid()
1764.                 )
1765.             ];
1766.         }
1768.         return $authors;
1769.     }
1771.     public function getVisibleAuthorsByRole(string|Language $lang, JournalArticleAuthorRole|string $type): array
1772.     {
1773.         $lang = !is_string($lang)
1774.             ? $lang
1775.             : Language::from($lang);
1777.         $type = is_string($type)
1778.             ? JournalArticleAuthorRole::from($type)
1779.             : $type;
1781.         $isNameVisible = in_array(AuthorProperty::NAME, $this->visibleAuthorProperties);
1782.         $isSurnameVisible = in_array(AuthorProperty::SURNAME, $this->visibleAuthorProperties);
1784.         if (!$isNameVisible && !$isSurnameVisible) {
1785.             return [];
1786.         }
1788.         return $this->getAuthors()->filter(
1789.             fn (JournalArticleAuthor $author) => $author->getRole() === $type
1790.         )->toArray();
1791.     }
1793.     public function getIssueRedactors(): array
1794.     {
1795.         if ($this->redactors) {
1796.             return $this->redactors;
1797.         }
1799.         $this->redactors = [];
1801.         foreach ($this->issue?->getEditorialGroups() as $group) {
1802.             foreach ($group->getMembers() as $member) {
1803.                 if (in_array($member, $this->redactors)) {
1804.                     continue;
1805.                 }
1807.                 $this->redactors[] = $member;
1808.             }
1809.         }
1811.         return $this->redactors;
1812.     }
1814.     // -----
1815.     // STATS
1816.     // -----
1818.     /**
1819.      * @return Collection|JournalArticleViewEntry[]
1820.      */
1821.     public function getViewEntries(): Collection
1822.     {
1823.         return $this->viewEntries;
1824.     }
1826.     public function addViewEntry(JournalArticleViewEntry $viewEntry): self
1827.     {
1828.         if ($this->viewEntries->contains($viewEntry)) {
1829.             return $this;
1830.         }
1832.         $this->viewEntries[] = $viewEntry;
1834.         return $this;
1835.     }
1837.     public function removeViewEntry(JournalArticleViewEntry $viewEntry): self
1838.     {
1839.         $this->viewEntries->removeElement($viewEntry);
1841.         return $this;
1842.     }
1844.     public function resetViewEntries(): self
1845.     {
1846.         $this->viewEntries = new ArrayCollection();
1848.         return $this;
1849.     }
1851.     /**
1852.      * @return Collection|JournalArticleDownloadEntry[]
1853.      */
1854.     public function getDownloadEntries(): Collection
1855.     {
1856.         return $this->downloadEntries;
1857.     }
1859.     public function addDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1860.     {
1861.         if ($this->downloadEntries->contains($downloadEntry)) {
1862.             return $this;
1863.         }
1865.         $this->downloadEntries[] = $downloadEntry;
1867.         return $this;
1868.     }
1870.     public function removeDownloadEntry(JournalArticleDownloadEntry $downloadEntry): self
1871.     {
1872.         $this->downloadEntries->removeElement($downloadEntry);
1874.         return $this;
1875.     }
1877.     public function resetDownloadEntries(): self
1878.     {
1879.         $this->downloadEntries = new ArrayCollection();
1881.         return $this;
1882.     }
1884.     public function getSlugTitleLanguage(): ?Language
1885.     {
1886.         if (!$this->slugTitleLanguage) {
1887.             if (isset($this->getPublicationLanguages()[0]) && in_array($this->getPublicationLanguages()[0], $this->getMetadataLanguages())) {
1888.                 return $this->getPublicationLanguages()[0];
1889.             }
1891.             return $this->nativeMetadataLanguage;
1892.         }
1894.         return $this->slugTitleLanguage;
1895.     }
1897.     public function setSlugTitleLanguage(?Language $slugTitleLanguage): self
1898.     {
1899.         if ($this->slugTitleLanguage !== $slugTitleLanguage && $slugTitleLanguage !== null) {
1900.             $this->slugTitleLanguage = $slugTitleLanguage;
1902.             foreach ($this->getMetadataTranslations() as $metadataTranslation) {
1903.                 $metadataTranslation->setTitle($metadataTranslation->getTitle());
1904.             }
1905.         } else {
1906.             $this->slugTitleLanguage = $slugTitleLanguage;
1907.         }
1909.         return $this;
1910.     }
1912.     /**
1913.      * @return Collection<int, JournalArticleSlugHistory>
1914.      */
1915.     public function getSlugHistory(): Collection
1916.     {
1917.         return $this->slugHistory;
1918.     }
1920.     public function addCurrentSlugToHistory(): void
1921.     {
1922.         // check if already in history
1923.         foreach ($this->slugHistory as $entry) {
1924.             if ($entry->getSlug() === $this->slug) {
1925.                 return;
1926.             }
1927.         }
1929.         $entry = new JournalArticleSlugHistory($this, $this->slug);
1930.         $this->addSlugHistory($entry);
1931.     }
1933.     public function addSlugHistory(JournalArticleSlugHistory $slugHistory): self
1934.     {
1935.         if (!$this->slugHistory->contains($slugHistory)) {
1936.             $this->slugHistory->add($slugHistory);
1937.         }
1939.         return $this;
1940.     }
1942.     public function removeSlugHistory(JournalArticleSlugHistory $slugHistory): self
1943.     {
1944.         $this->slugHistory->removeElement($slugHistory);
1946.         return $this;
1947.     }
1949.     public function getIsCrossmarkButtonVisible(): ?bool
1950.     {
1951.         if ($this->isCrossmarkButtonVisible === null) {
1952.             return $this->getIssue()->getIsCrossmarkButtonVisible();
1953.         }
1955.         return $this->isCrossmarkButtonVisible;
1956.     }
1958.     public function setIsCrossmarkButtonVisible(?bool $isCrossmarkButtonVisible): self
1959.     {
1960.         $this->isCrossmarkButtonVisible = $isCrossmarkButtonVisible;
1962.         return $this;
1963.     }
1965.     #[Groups(['read:stats'])]
1966.     public function getStatsAuthors(): ?string
1967.     {
1968.         $authors = [];
1970.         /** @var JournalArticleAuthor */
1971.         foreach ($this->authors as $entry) {
1972.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1973.                 continue;
1974.             }
1976.             $author = $entry->getAuthor();
1978.             $authors[] = $author->getFullName();
1979.         }
1981.         sort($authors);
1983.         return implode(', ', $authors);
1984.     }
1986.     #[Groups(['read:stats'])]
1987.     public function getStatsAuthorsAffiliations(): ?string
1988.     {
1989.         $affiliations = [];
1991.         /** @var JournalArticleAuthor */
1992.         foreach ($this->authors as $entry) {
1993.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
1994.                 continue;
1995.             }
1997.             $author = $entry->getAuthor();
1999.             /** @var Affiliation */
2000.             foreach ($author->getAffiliations() as $affiliation) {
2001.                 if (isset($affiliations[$affiliation->getUuid()->toString()])) {
2002.                     continue;
2003.                 }
2005.                 $affiliations[$affiliation->getUuid()->toString()] = $affiliation->readNativeLanguageTranslation('title');
2006.             }
2007.         }
2009.         sort($affiliations);
2011.         return implode(', ',  $affiliations);
2012.     }
2014.     #[Groups(['read:stats'])]
2015.     public function getStatsAuthorsCountries(): ?string
2016.     {
2017.         $countries = [];
2019.         /** @var JournalArticleAuthor */
2020.         foreach ($this->authors as $entry) {
2021.             if ($entry->getRole() !== JournalArticleAuthorRole::AUTHOR) {
2022.                 continue;
2023.             }
2025.             $author = $entry->getAuthor();
2027.             /** @var Affiliation */
2028.             foreach ($author->getAffiliations() as $affiliation) {
2029.                 if (!$affiliation->getCountry()) {
2030.                     continue;
2031.                 }
2033.                 if (isset($countries[$affiliation->getCountry()->value])) {
2034.                     continue;
2035.                 }
2037.                 $countries[$affiliation->getCountry()->value] = $affiliation->getCountry()->value;
2038.             }
2039.         }
2041.         sort($countries);
2043.         return implode(', ',  $countries);
2044.     }
2046.     #[Groups(['read:stats'])]
2047.     public function getStatsTranslators(): ?string
2048.     {
2049.         $authors = [];
2051.         /** @var JournalArticleAuthor */
2052.         foreach ($this->authors as $entry) {
2053.             if ($entry->getRole() !== JournalArticleAuthorRole::TRANSLATOR) {
2054.                 continue;
2055.             }
2057.             $author = $entry->getAuthor();
2059.             $authors[] = $author->getFullName();
2060.         }
2062.         sort($authors);
2064.         return implode(', ', $authors);
2065.     }
2067.     #[Groups(['read:stats'])]
2068.     public function getStatsJournal(): string
2069.     {
2070.         return $this->parent->readNativeLanguageTranslation('title');
2071.     }
2073.     #[Groups(['read:stats'])]
2074.     public function getStatsJournalAffiliations(): string
2075.     {
2076.         $affiliations = [];
2078.         /** @var JournalAffiliation */
2079.         foreach ($this->parent->getAffiliations() as $entry) {
2080.             if (isset($affiliations[$entry->getAffiliation()->getUuid()->toString()])) {
2081.                 continue;
2082.             }
2084.             $affiliations[$entry->getAffiliation()->getUuid()->toString()] =
2085.                 $entry->getAffiliation()->readNativeLanguageTranslation('title');
2086.         }
2088.         sort($affiliations);
2090.         return implode(', ',  $affiliations);
2091.     }
2093.     #[Groups(['read:stats'])]
2094.     public function getStatsIssue(): string
2095.     {
2096.         return $this->issue->readNativeLanguageTranslation('title');
2097.     }
2099.     #[Groups(['read:stats'])]
2100.     public function getStatsVolume(): string
2101.     {
2102.         return $this->issue->getVolume()->readNativeLanguageTranslation('title');
2103.     }
2105.     #[Groups(['read:stats'])]
2106.     public function getStatsIssueFundingDescription(): ?string
2107.     {
2108.         return $this->issue->readNativeLanguageTranslation('fundingDescription');
2109.     }
2111.     #[Groups(['read:stats'])]
2112.     public function getStatsVolumeFundingDescription(): ?string
2113.     {
2114.         return $this->issue->getVolume()->readNativeLanguageTranslation('fundingDescription');
2115.     }
2117.     #[Groups(['read:stats'])]
2118.     public function getStatsSection(): ?string
2119.     {
2120.         return $this->section?->readNativeLanguageTranslation('title');
2121.     }
2123.     #[Groups(['read:stats'])]
2124.     public function getStatsKeywords(): ?string
2125.     {
2126.         $keywords = [];
2128.         $entries = $this->readMetadataTranslation($this->nativeMetadataLanguage, 'keywords');
2130.         if ($entries) {
2131.             /** @var JournalArticleMetadataTranslationKeyword */
2132.             foreach ($entries as $entry) {
2133.                 $keywords[] = $entry->getTitle();
2134.             }
2135.         }
2137.         sort($keywords);
2139.         return implode(', ', $keywords);
2140.     }
2142.     public function getStatsFullTextUrl(): ?string
2143.     {
2144.         return $this->statsFullTextUrl;
2145.     }
2147.     public function setStatsFullTextUrl(?string $statsFullTextUrl): self
2148.     {
2149.         $this->statsFullTextUrl = $statsFullTextUrl;
2151.         return $this;
2152.     }
2154.     public function getStatsArticleUrl(): ?string
2155.     {
2156.         return $this->statsArticleUrl;
2157.     }
2159.     public function setStatsArticleUrl(?string $statsArticleUrl): self
2160.     {
2161.         $this->statsArticleUrl = $statsArticleUrl;
2163.         return $this;
2164.     }
2166.     public function isForSale(): bool
2167.     {
2168.         if ($this->getIsOpen()) {
2169.             return false;
2170.         }
2172.         if (!$this->getPriceReal()) {
2173.             return false;
2174.         }
2176.         return true;
2177.     }
2179.     #[Groups(['read:' . self::class])]
2180.     public function getJournalSlug(): ?string
2181.     {
2182.         return $this->parent->getSlug();
2183.     }
2185.     #[Groups(['read:' . self::class])]
2186.     public function getParentLanguages(): array
2187.     {
2188.         return $this->getLanguageableParent()->getLanguages();
2189.     }
2191.     public function clone(): self
2192.     {
2193.         $clone = clone $this;
2195.         $clone->id = null;
2196.         $clone->setUuid();
2198.         $clone->ord = 0;
2199.         $clone->stat = false;
2200.         $clone->importId = null;
2202.         ClassUtils::cloneCollection($this, $clone, 'translations');
2203.         ClassUtils::cloneCollection($this, $clone, 'metadataTranslations');
2204.         $clone->synchronizeTranslations();
2206.         // title jest przeniesione do metadataTranslations, i wlasciwie to bezsensu jest teraz
2207.         // $nativeLanguage = $clone->parent->getNativeLanguage();
2208.         // $nativeTranslation = $clone->getMetadataTranslation($nativeLanguage);
2209.         // $nativeTranslation->setTitle($nativeTranslation->getTitle() . ' [KOPIA]');
2211.         // lepiej dopisac [KOPIA] do working title
2212.         $clone->setWorkingTitle($clone->getWorkingTitle() . ' [KOPIA]');
2214.         ClassUtils::cloneCollection($this, $clone, 'classifications');
2215.         ClassUtils::cloneCollection($this, $clone, 'researchDatas');
2216.         ClassUtils::cloneCollection($this, $clone, 'contentBlocks');
2217.         ClassUtils::cloneCollection($this, $clone, 'files');
2219.         $clone->statsAmountOfViews = 0;
2220.         $clone->statsAmountOfDownloads = 0;
2222.         $clone
2223.             ->resetAdditionalBlocks()
2224.             ->resetBibliographyEntries()
2225.             ->resetAuthors()
2226.             ->resetViewEntries()
2227.             ->resetDownloadEntries();
2229.         $clone->createdAt = new \DateTimeImmutable();
2230.         $clone->updatedAt = new \DateTimeImmutable();
2232.         return $clone;
2233.     }
2235.     /**
2236.      * @return Collection<int, CartProduct>
2237.      */
2238.     public function getCartProducts(): Collection
2239.     {
2240.         return $this->cartProducts;
2241.     }
2243.     public function addCartProduct(CartProduct $cartProduct): self
2244.     {
2245.         if (!$this->cartProducts->contains($cartProduct)) {
2246.             $this->cartProducts->add($cartProduct);
2247.             $cartProduct->setArticle($this);
2248.         }
2250.         return $this;
2251.     }
2253.     public function removeCartProduct(CartProduct $cartProduct): self
2254.     {
2255.         if ($this->cartProducts->removeElement($cartProduct)) {
2256.             // set the owning side to null (unless already changed)
2257.             if ($cartProduct->getArticle() === $this) {
2258.                 $cartProduct->setArticle(null);
2259.             }
2260.         }
2262.         return $this;
2263.     }
2264. }