src/Entity/JournalArticleMetadataTranslation.php line 30

  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;
  24. #[ApiResource(
  25.     security: 'is_granted("' . Journal::class . '")',
  26.     operations: [ new Get() ],
  27.     extraProperties: ['standard_put' => false],
  28. )]
  29. #[ORM\Entity(repositoryClass: JournalArticleMetadataTranslationRepository::class)]
  30. class JournalArticleMetadataTranslation
  31. {
  32.     use IdTrait,
  33.         UuidTrait,
  34.         TimestampableTrait;
  36.     #[ApiProperty(description: 'Parent')]
  37.     #[ORM\ManyToOne(targetEntity: JournalArticle::class, inversedBy: 'metadataTranslations')]
  38.     #[ORM\JoinColumn(onDelete: 'cascade', nullable: false)]
  39.     private JournalArticle $parent;
  41.     #[ApiProperty(description: 'Title')]
  42.     #[Groups(['read', 'read:minimal', 'write'])]
  43.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  44.     private ?string $title = null;
  46.     #[ApiProperty(description: 'Annotation')]
  47.     #[Groups(['read', 'write'])]
  48.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  49.     private ?string $annotation = null;
  51.     #[ApiProperty(description: 'Abstract')]
  52.     #[Groups(['read:' . self::class, 'write'])]
  53.     #[Sanitizeable]
  54.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  55.     private ?string $abstract = null;
  57.     #[ApiProperty(description: 'Translation language')]
  58.     #[ORM\Column(
  59.         type: Types::STRING,
  60.         enumType: Language::class,
  61.         length: 7,
  62.         options: ['default' => Language::EN]
  63.     )]
  64.     private Language $lang = Language::EN;
  66.     #[ApiProperty(description: 'Is keywords import reseting previous')]
  67.     #[Groups(['read:' . self::class, 'write'])]
  68.     #[DenormalizationPriority(DenormalizationPriority::TOP)]
  69.     private bool $isKeywordsImportResetingPrevious = false;
  71.     #[ApiProperty(description: 'Keywords')]
  72.     #[ORM\OneToMany(
  73.         targetEntity: JournalArticleMetadataTranslationKeyword::class,
  74.         mappedBy: 'parent',
  75.         cascade: ['persist', 'remove'],
  76.         orphanRemoval: true
  77.     )]
  78.     #[ORM\OrderBy(['ord' => 'desc'])]
  79.     private Collection $keywords;
  81.     public function __construct(JournalArticle $parent, Language $lang)
  82.     {
  83.         $this->setUuid();
  85.         $this->parent = $parent;
  86.         $this->lang = $lang;
  88.         $this->keywords = new ArrayCollection();
  90.         $this->createdAt = new \DateTimeImmutable();
  91.         $this->updatedAt = new \DateTimeImmutable();
  93.         $parent->addMetadataTranslation($this);
  94.     }
  96.     public function getParent(): JournalArticle
  97.     {
  98.         return $this->parent;
  99.     }
  101.     public function getTitle(): ?string
  102.     {
  103.         return $this->title;
  104.     }
  106.     #[Groups(['read:minimal'])]
  107.     public function getRawTitle(): ?string
  108.     {
  109.         return strip_tags($this->title);
  110.     }
  112.     public function setTitle(?string $title): self
  113.     {
  114.         $this->title = $title;
  116.         /** @var JournalArticle $parent*/
  117.         $parent = $this->parent;
  119.         if ($parent->getSlugTitleLanguage() !== null) {
  120.             $nativeTitleLang = $parent->getSlugTitleLanguage();
  121.         } else {
  122.             $nativeTitleLang = $parent->getNativeMetadataLanguage();
  123.         }
  125.         if ($this->lang === $nativeTitleLang) {
  126.             $parent
  127.                 ->setNativeTitle($title)
  128.                 ->setNativeTitleRaw(strip_tags($title));
  129.         }
  131.         return $this;
  132.     }
  134.     #[Groups(['read'])]
  135.     public function getFullTitle(): ?string
  136.     {
  137.         /** @var JournalArticle $parent */
  138.         $parent = $this->parent;
  140.         /** @var string|null $journalTitle */
  141.         $journalTitle = $parent->getParent()->readTranslation($this->lang, 'title');
  143.         /** @var string|null $volumeTitle */
  144.         $volumeTitle = $parent->getIssue()->getVolume()->readAvailableTranslation($this->lang, 'title');
  146.         /** @var string|null $issueTitle */
  147.         $issueTitle = $parent->getIssue()->readAvailableTranslation($this->lang, 'title');
  149.         return sprintf(
  150.             "%s - %s - %s - %s",
  151.             $journalTitle,
  152.             $volumeTitle,
  153.             $issueTitle,
  154.             $this->getRawTitle()
  155.         );
  156.     }
  158.     public function getAnnotation(): ?string
  159.     {
  160.         return $this->annotation;
  161.     }
  163.     public function setAnnotation(?string $annotation): self
  164.     {
  165.         $this->annotation = $annotation;
  167.         return $this;
  168.     }
  170.     public function getAbstract(): ?string
  171.     {
  172.         return $this->abstract;
  173.     }
  175.     public function setAbstract(?string $abstract): self
  176.     {
  177.         $this->abstract = $abstract;
  179.         return $this;
  180.     }
  182.     public function getLang(): Language
  183.     {
  184.         return $this->lang;
  185.     }
  187.     public function setIsKeywordsImportResetingPrevious(bool $isKeywordsImportResetingPrevious)
  188.     {
  189.         $this->isKeywordsImportResetingPrevious = $isKeywordsImportResetingPrevious;
  191.         return $this;
  192.     }
  194.     public function getIsKeywordsImportResetingPrevious(): bool
  195.     {
  196.         return true;
  197.     }
  199.     #[Groups(['write'])]
  200.     public function setImportedKeywords(?string $importedKeywords): self
  201.     {
  202.         if (! $importedKeywords) {
  203.             return $this;
  204.         }
  206.         $importedKeywords = str_replace(';', ',', $importedKeywords);
  208.         /** @var JournalArticleTranslation|null */
  209.         $adjacentTranslation = $this->parent->getTranslation($this->lang);
  211.         if ($this->isKeywordsImportResetingPrevious) {
  212.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  214.             $this->resetKeywords();
  215.         } elseif (! empty($adjacentTranslation?->getMetaKeywords())) {
  216.             $adjacentTranslation?->setMetaKeywords("{$adjacentTranslation->getMetaKeywords()}, {$importedKeywords}");
  217.         } else {
  218.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  219.         }
  221.         $keywords = array_map(
  222.             fn(string $keyword) => trim($keyword),
  223.             explode(',', $importedKeywords)
  224.         );
  226.         $keywords = array_filter(
  227.             $keywords,
  228.             fn(string $keyword) => ! empty($keyword)
  229.         );
  231.         foreach($keywords as $keyword) {
  232.             new JournalArticleMetadataTranslationKeyword($this, $keyword);
  233.         }
  235.         $ord = count($this->keywords);
  237.         foreach($this->keywords as $keyword) {
  238.             $keyword->setOrd($ord--);
  239.         }
  241.         return $this;
  242.     }
  244.     /**
  245.      * @return Collection|JournalArticleMetadataTranslationKeyword[]
  246.      */
  247.     public function getKeywords(): Collection
  248.     {
  249.         return $this->keywords;
  250.     }
  252.     public function addKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  253.     {
  254.         if ($this->keywords->contains($keyword)) {
  255.             return $this;
  256.         }
  258.         $this->keywords[] = $keyword;
  260.         return $this;
  261.     }
  263.     public function removeKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  264.     {
  265.         $this->keywords->removeElement($keyword);
  267.         return $this;
  268.     }
  270.     public function resetKeywords(): self
  271.     {
  272.         $this->keywords = new ArrayCollection();
  274.         return $this;
  275.     }
  277.     public function setUpdatedAt(\DateTimeImmutable $updatedAt): self
  278.     {
  279.         $this->updatedAt = $updatedAt;
  280.         $this->getParent()->setUpdatedAt($updatedAt);
  282.         return $this;
  283.     }
  285.     public function clone(JournalArticle $parent): self
  286.     {
  287.         $clone = clone $this;
  289.         $clone->id = null;
  290.         $clone->setUuid();
  292.         $clone->parent = $parent;
  293.         $clone->parent->addMetadataTranslation($clone);
  295.         $clone->resetKeywords();
  297.         $clone->createdAt = new \DateTimeImmutable();
  298.         $clone->updatedAt = new \DateTimeImmutable();
  300.         return $clone;
  301.     }
  302. }