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', 'write'])]
  43.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  44.     private ?string $title = null;
  46.     #[ApiProperty(description: 'Abstract')]
  47.     #[Groups(['read:' . self::class, 'write'])]
  48.     #[Sanitizeable]
  49.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  50.     private ?string $abstract = null;
  52.     #[ApiProperty(description: 'Translation language')]
  53.     #[ORM\Column(
  54.         type: Types::STRING,
  55.         enumType: Language::class,
  56.         length: 7,
  57.         options: ['default' => Language::EN]
  58.     )]
  59.     private Language $lang = Language::EN;
  61.     #[ApiProperty(description: 'Is keywords import reseting previous')]
  62.     #[Groups(['read:' . self::class, 'write'])]
  63.     #[DenormalizationPriority(DenormalizationPriority::TOP)]
  64.     private bool $isKeywordsImportResetingPrevious = false;
  66.     #[ApiProperty(description: 'Keywords')]
  67.     #[ORM\OneToMany(
  68.         targetEntity: JournalArticleMetadataTranslationKeyword::class,
  69.         mappedBy: 'parent',
  70.         cascade: ['persist', 'remove'],
  71.         orphanRemoval: true
  72.     )]
  73.     #[ORM\OrderBy(['ord' => 'desc'])]
  74.     private Collection $keywords;
  76.     public function __construct(JournalArticle $parent, Language $lang)
  77.     {
  78.         $this->setUuid();
  80.         $this->parent = $parent;
  81.         $this->lang = $lang;
  83.         $this->keywords = new ArrayCollection();
  85.         $this->createdAt = new \DateTimeImmutable();
  86.         $this->updatedAt = new \DateTimeImmutable();
  88.         $parent->addMetadataTranslation($this);
  89.     }
  91.     public function getParent(): JournalArticle
  92.     {
  93.         return $this->parent;
  94.     }
  96.     public function getTitle(): ?string
  97.     {
  98.         return $this->title;
  99.     }
  101.     public function getRawTitle(): ?string
  102.     {
  103.         return strip_tags($this->title);
  104.     }
  106.     public function setTitle(?string $title): self
  107.     {
  108.         $this->title = $title;
  110.         /** @var JournalArticle $parent*/
  111.         $parent = $this->parent;
  113.         if ($parent->getSlugTitleLanguage() !== null) {
  114.             $nativeTitleLang = $parent->getSlugTitleLanguage();
  115.         } else {
  116.             $nativeTitleLang = $parent->getNativeMetadataLanguage();
  117.         }
  119.         if ($this->lang === $nativeTitleLang) {
  120.             $parent
  121.                 ->setNativeTitle($title)
  122.                 ->setNativeTitleRaw(strip_tags($title));
  123.         }
  125.         return $this;
  126.     }
  128.     public function getAbstract(): ?string
  129.     {
  130.         return $this->abstract;
  131.     }
  133.     public function setAbstract(?string $abstract): self
  134.     {
  135.         $this->abstract = $abstract;
  137.         return $this;
  138.     }
  140.     public function getLang(): Language
  141.     {
  142.         return $this->lang;
  143.     }
  145.     public function setIsKeywordsImportResetingPrevious(bool $isKeywordsImportResetingPrevious)
  146.     {
  147.         $this->isKeywordsImportResetingPrevious = $isKeywordsImportResetingPrevious;
  149.         return $this;
  150.     }
  152.     public function getIsKeywordsImportResetingPrevious(): bool
  153.     {
  154.         return true;
  155.     }
  157.     #[Groups(['write'])]
  158.     public function setImportedKeywords(?string $importedKeywords): self
  159.     {
  160.         if (! $importedKeywords) {
  161.             return $this;
  162.         }
  164.         $importedKeywords = str_replace(';', ',', $importedKeywords);
  166.         /** @var JournalArticleTranslation|null */
  167.         $adjacentTranslation = $this->parent->getTranslation($this->lang);
  169.         if ($this->isKeywordsImportResetingPrevious) {
  170.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  172.             $this->resetKeywords();
  173.         } elseif (! empty($adjacentTranslation?->getMetaKeywords())) {
  174.             $adjacentTranslation?->setMetaKeywords("{$adjacentTranslation->getMetaKeywords()}, {$importedKeywords}");
  175.         } else {
  176.             $adjacentTranslation?->setMetaKeywords($importedKeywords);
  177.         }
  179.         $keywords = array_map(
  180.             fn(string $keyword) => trim($keyword),
  181.             explode(',', $importedKeywords)
  182.         );
  184.         $keywords = array_filter(
  185.             $keywords,
  186.             fn(string $keyword) => ! empty($keyword)
  187.         );
  189.         foreach($keywords as $keyword) {
  190.             new JournalArticleMetadataTranslationKeyword($this, $keyword);
  191.         }
  193.         $ord = count($this->keywords);
  195.         foreach($this->keywords as $keyword) {
  196.             $keyword->setOrd($ord--);
  197.         }
  199.         return $this;
  200.     }
  202.     /**
  203.      * @return Collection|JournalArticleMetadataTranslationKeyword[]
  204.      */
  205.     public function getKeywords(): Collection
  206.     {
  207.         return $this->keywords;
  208.     }
  210.     public function addKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  211.     {
  212.         if ($this->keywords->contains($keyword)) {
  213.             return $this;
  214.         }
  216.         $this->keywords[] = $keyword;
  218.         return $this;
  219.     }
  221.     public function removeKeyword(JournalArticleMetadataTranslationKeyword $keyword): self
  222.     {
  223.         $this->keywords->removeElement($keyword);
  225.         return $this;
  226.     }
  228.     public function resetKeywords(): self
  229.     {
  230.         $this->keywords = new ArrayCollection();
  232.         return $this;
  233.     }
  235.     public function clone(JournalArticle $parent): self
  236.     {
  237.         $clone = clone $this;
  239.         $clone->id = null;
  240.         $clone->setUuid();
  242.         $clone->parent = $parent;
  243.         $clone->parent->addMetadataTranslation($clone);
  245.         $clone->resetKeywords();
  247.         $clone->createdAt = new \DateTimeImmutable();
  248.         $clone->updatedAt = new \DateTimeImmutable();
  250.         return $clone;
  251.     }
  252. }