src/Entity/JournalArticleMetadataTranslation.php line 31

  1. <?php
  2. namespace App\Entity;
  4. use Doctrine\ORM\Mapping as ORM,
  5.     Doctrine\DBAL\Types\Types,
  6.     Doctrine\Common\Collections\Collection,
  7.     Doctrine\Common\Collections\ArrayCollection;
  9. use Symfony\Component\Serializer\Annotation\Groups;
  11. use ApiPlatform\Metadata\ApiProperty,
  12.     ApiPlatform\Metadata\ApiResource,
  13.     ApiPlatform\Metadata\Get;
  15. use App\Entity\Trait\IdTrait,
  16.     App\Entity\Trait\UuidTrait,
  17.     App\Entity\Trait\TimestampableTrait;
  19. use App\Enum\Language,
  20.     App\Attribute\Sanitizeable,
  21.     App\Attribute\DenormalizationPriority,
  22.     App\Repository\JournalArticleMetadataTranslationRepository;
  23. use App\Util\ClassUtils;
  25. #[ApiResource(
  26.     security: 'is_granted("' . Journal::class . '")',
  27.     operations: [ new Get() ],
  28.     extraProperties: ['standard_put' => false],
  29. )]
  30. #[ORM\Entity(repositoryClass: JournalArticleMetadataTranslationRepository::class)]
  31. class JournalArticleMetadataTranslation
  32. {
  33.     use IdTrait,
  34.         UuidTrait,
  35.         TimestampableTrait;
  37.     #[ApiProperty(description: 'Parent')]
  38.     #[ORM\ManyToOne(targetEntity: JournalArticle::class, inversedBy: 'metadataTranslations')]
  39.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
  40.     private JournalArticle $parent;
  42.     #[ApiProperty(description: 'Title')]
  43.     #[Groups(['read', 'read:minimal', 'write'])]
  44.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  45.     private ?string $title = null;
  47.     #[ApiProperty(description: 'Annotation')]
  48.     #[Groups(['read', 'write'])]
  49.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  50.     private ?string $annotation = null;
  52.     #[ApiProperty(description: 'Abstract')]
  53.     #[Groups(['read:' . self::class, 'write'])]
  54.     #[Sanitizeable]
  55.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  56.     private ?string $abstract = null;
  58.     #[ApiProperty(description: 'Translation language')]
  59.     #[ORM\Column(
  60.         type: Types::STRING,
  61.         enumType: Language::class,
  62.         length: 7,
  63.         options: ['default' => Language::EN]
  64.     )]
  65.     private Language $lang = Language::EN;
  67.     #[ApiProperty(description: 'Is keywords import reseting previous')]
  68.     #[Groups(['read:' . self::class, 'write'])]
  69.     #[DenormalizationPriority(DenormalizationPriority::TOP)]
  70.     private bool $isKeywordsImportResetingPrevious = false;
  72.     #[ApiProperty(description: 'Keywords')]
  73.     #[ORM\OneToMany(
  74.         targetEntity: JournalArticleMetadataTranslationKeyword::class,
  75.         mappedBy: 'parent',
  76.         cascade: ['persist', 'remove'],
  77.         orphanRemoval: true
  78.     )]
  79.     #[ORM\OrderBy(['ord' => 'desc'])]
  80.     private Collection $keywords;
  82.     public function __construct(JournalArticle $parent, Language $lang)
  83.     {
  84.         $this->setUuid();
  86.         $this->parent = $parent;
  87.         $this->lang = $lang;
  89.         $this->keywords = new ArrayCollection();
  91.         $this->createdAt = new \DateTimeImmutable();
  92.         $this->updatedAt = new \DateTimeImmutable();
  94.         $parent->addMetadataTranslation($this);
  95.     }
  97.     public function getParent(): JournalArticle
  98.     {
  99.         return $this->parent;
  100.     }
  102.     public function getTitle(): ?string
  103.     {
  104.         return $this->title;
  105.     }
  107.     #[Groups(['read:minimal'])]
  108.     public function getRawTitle(): ?string
  109.     {
  110.         return strip_tags($this->title);
  111.     }
  113.     public function setTitle(?string $title): self
  114.     {
  115.         $this->title = $title;
  117.         /** @var JournalArticle $parent*/
  118.         $parent = $this->parent;
  120.         if ($parent->getSlugTitleLanguage() !== null) {
  121.             $nativeTitleLang = $parent->getSlugTitleLanguage();
  122.         } else {
  123.             $nativeTitleLang = $parent->getNativeMetadataLanguage();
  124.         }
  126.         if ($this->lang === $nativeTitleLang) {
  127.             $parent
  128.                 ->setNativeTitle($title)
  129.                 ->setNativeTitleRaw(strip_tags($title));
  130.         }
  132.         return $this;
  133.     }
  135.     #[Groups(['read'])]
  136.     public function getFullTitle(): ?string
  137.     {
  138.         /** @var JournalArticle $parent */
  139.         $parent = $this->parent;
  141.         /** @var string|null $journalTitle */
  142.         $journalTitle = $parent->getParent()->readTranslation($this->lang, 'title');
  144.         /** @var string|null $volumeTitle */
  145.         $volumeTitle = $parent->getIssue()->getVolume()->readAvailableTranslation($this->lang, 'title');
  147.         /** @var string|null $issueTitle */
  148.         $issueTitle = $parent->getIssue()->readAvailableTranslation($this->lang, 'title');
  150.         return sprintf(
  151.             "%s - %s - %s - %s",
  152.             $journalTitle,
  153.             $volumeTitle,
  154.             $issueTitle,
  155.             $this->getRawTitle()
  156.         );
  157.     }
  159.     public function getAnnotation(): ?string
  160.     {
  161.         return $this->annotation;
  162.     }
  164.     public function setAnnotation(?string $annotation): self
  165.     {
  166.         $this->annotation = $annotation;
  168.         return $this;
  169.     }
  171.     public function getAbstract(): ?string
  172.     {
  173.         return $this->abstract;
  174.     }
  176.     public function setAbstract(?string $abstract): self
  177.     {
  178.         $this->abstract = $abstract;
  180.         return $this;
  181.     }
  183.     public function getLang(): Language
  184.     {
  185.         return $this->lang;
  186.     }
  188.     public function setIsKeywordsImportResetingPrevious(bool $isKeywordsImportResetingPrevious)
  189.     {
  190.         $this->isKeywordsImportResetingPrevious = $isKeywordsImportResetingPrevious;
  192.         return $this;
  193.     }
  195.     public function getIsKeywordsImportResetingPrevious(): bool
  196.     {
  197.         return true;
  198.     }
  200.     #[Groups(['write'])]
  201.     public function setImportedKeywords(?string $importedKeywords): self
  202.     {
  203.         if (! $importedKeywords) {
  204.             return $this;
  205.         }
  207.         $importedKeywords = str_replace(';', ',', $importedKeywords);
  209.         /** @var JournalArticleTranslation|null */
  210.         $adjacentTranslation = $this->parent->getTranslation($this->lang);
  212.         if ($this->isKeywordsImportResetingPrevious) {
  213.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  215.             $this->resetKeywords();
  216.         } elseif (! empty($adjacentTranslation?->getMetaKeywords())) {
  217.             $adjacentTranslation?->setMetaKeywords("{$adjacentTranslation->getMetaKeywords()}, {$importedKeywords}");
  218.         } else {
  219.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  220.         }
  222.         $keywords = array_map(
  223.             fn(string $keyword) => trim($keyword),
  224.             explode(',', $importedKeywords)
  225.         );
  227.         $keywords = array_filter(
  228.             $keywords,
  229.             fn(string $keyword) => ! empty($keyword)
  230.         );
  232.         foreach($keywords as $keyword) {
  233.             new JournalArticleMetadataTranslationKeyword($this, $keyword);
  234.         }
  236.         $ord = count($this->keywords);
  238.         foreach($this->keywords as $keyword) {
  239.             $keyword->setOrd($ord--);
  240.         }
  242.         return $this;
  243.     }
  245.     /**
  246.      * @return Collection|JournalArticleMetadataTranslationKeyword[]
  247.      */
  248.     public function getKeywords(): Collection
  249.     {
  250.         return $this->keywords;
  251.     }
  253.     public function addKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  254.     {
  255.         if ($this->keywords->contains($keyword)) {
  256.             return $this;
  257.         }
  259.         $this->keywords[] = $keyword;
  261.         return $this;
  262.     }
  264.     public function removeKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  265.     {
  266.         $this->keywords->removeElement($keyword);
  268.         return $this;
  269.     }
  271.     public function resetKeywords(): self
  272.     {
  273.         $this->keywords = new ArrayCollection();
  275.         return $this;
  276.     }
  278.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  279.     {
  280.         $this->updatedAt = $updatedAt;
  281.         $this->getParent()->setUpdatedAt($updatedAt);
  283.         return $this;
  284.     }
  286.     public function clone(JournalArticle $parent): self
  287.     {
  288.         $clone = clone $this;
  290.         $clone->id = null;
  291.         $clone->setUuid();
  293.         $clone->parent = $parent;
  294.         $clone->parent->addMetadataTranslation($clone);
  296.         ClassUtils::cloneCollection($this, $clone, 'keywords');
  298.         $clone->createdAt = new \DateTimeImmutable();
  299.         $clone->updatedAt = new \DateTimeImmutable();
  301.         return $clone;
  302.     }
  303. }