src/Entity/Artikel/Artikel.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Artikel;
  5. use App\Entity\Artikel\Exceptions\ArtikelNotValidForAGalleryException;
  6. use App\Entity\Artikel\Exceptions\ArtikelSelfReferenzException;
  7. use App\Entity\Dossier\Dossier;
  8. use App\Entity\EntityId;
  9. use App\Entity\ObjectFileHandlingInterface;
  10. use App\Entity\Redaktor\Redaktor;
  11. use App\Util\UrlSlug;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use Symfony\Component\Filesystem\Filesystem;
  16. use Symfony\Component\Finder\Finder;
  17. use Symfony\Component\OptionsResolver\OptionsResolver;
  18. use Symfony\Component\Validator\Constraints;
  19. use Webmozart\Assert\Assert;
  21. #[ORM\Entity]
  22. #[ORM\Table(name: 'artikel')]
  23. class Artikel implements ObjectFileHandlingInterface
  24. {
  25. public $redaktorAlternative;
  26. public const int MAX_LENGTH_TITEL = 80;
  27. public const int MAX_LENGTH_LEAD = 180;
  28. public const int MAX_LENGTH_HINWEIS = 80;
  29. public const int MAX_LENGTH_REDAKTOR_ALTERNATIVE = 64;
  30. public const int MAX_LENGTH_SPITZMARKE = 64;
  31. public const int MAX_LENGTH_URLSLUG = 255;
  32. public const int MAX_WIDTH_IMAGE = 1024;
  34. public const int MAX_WIDTH_PR_LOGO = 350;
  36. public const float MIN_IMAGE_RATIO = 1.65;
  37. public const float MAX_IMAGE_RATIO = 1.85;
  39. public const string REGEX_VIDEO_URL_PATTERN = '#^(|https:\/\/www\.youtube\.com\/watch\?v=[a-zA-Z0-9\-\_]{1,})$#';
  40. public const int MAX_CONCURRENT_LEAD_GALLERY_ARTIKEL = 3;
  42. #[ORM\Column(name: 'titel', type: 'string', length: 128, nullable: true)]
  43. private ?string $titel = null;
  45. #[ORM\Column(name: 'spitzmarke', type: 'string', length: 64, nullable: true)]
  46. private ?string $spitzmarke = null;
  48. #[ORM\Column(name: '`lead`', type: 'text', length: 300, nullable: true)]
  49. private ?string $lead = null;
  51. #[ORM\Column(name: 'contentHtml', type: 'text', nullable: true)]
  52. private ?string $contentHtml = null;
  54. #[ORM\Column(name: 'video_url', type: 'text', length: 255, nullable: true)]
  55. #[Constraints\Regex(pattern: '#^https:\/\/www\.youtube\.com\/watch\?v=[a-zA-Z0-9\-\_]{1,}$#', message: 'Die URL entspricht nicht der Formatvorgaben für eine YouTube URL.', match: true)]
  56. private ?string $videoUrl = null;
  58. /**
  59. * ArtikelRubrik[]
  60. */
  61. #[ORM\Column(name: 'rubrik_ids', type: 'json', nullable: true)]
  62. private ?array $rubrikIds = [];
  64. /**
  65. * ArtikelKanal[]
  66. */
  67. #[ORM\Column(name: 'kanal_ids', type: 'json', nullable: true)]
  68. private ?array $kanalIds = [];
  70. #[ORM\ManyToOne(targetEntity: Dossier::class)]
  71. #[ORM\JoinColumn(name: 'dossier_id', referencedColumnName: 'id', nullable: true)]
  72. private ?Dossier $dossier = null;
  74. /**
  75. * ArtikelStatus
  76. */
  77. #[ORM\Column(name: 'status_id', type: 'string', length: 16)]
  78. private ?string $statusId = null;
  80. /**
  81. * ArtikelTyp
  82. */
  83. #[ORM\Column(name: 'typ_id', type: 'string', length: 16)]
  84. private ?string $typId = null;
  86. /**
  87. * ArtikelAssettyp
  88. */
  89. #[ORM\Column(name: 'assettyp_id', type: 'string', length: 16)]
  90. private ?string $assettypId = null;
  92. #[ORM\ManyToOne(targetEntity: Redaktor::class)]
  93. #[ORM\JoinColumn(name: 'redaktor_id', referencedColumnName: 'id', nullable: true)]
  94. private ?Redaktor $redaktor = null;
  96. #[ORM\ManyToMany(targetEntity: Artikel::class)]
  97. #[ORM\JoinTable(name: 'lnk_artikel_artikel', joinColumns: [new ORM\JoinColumn(name: 'artikel_id', referencedColumnName: 'id')], inverseJoinColumns: [new ORM\JoinColumn(name: 'verwandter_artikel_id', referencedColumnName: 'id')])]
  98. private Collection $verwandteArtikel;
  100. /**
  101. * Artikel Datum, falls leer, erhält es das Publikationsdatum.
  102. */
  103. #[ORM\Column(name: 'authored_at', type: 'datetime', nullable: true)]
  104. private ?\DateTimeInterface $authoredAt = null;
  106. /**
  107. * Definitives Publikationsdatum.
  108. */
  109. #[ORM\Column(name: 'publish_at', type: 'datetime', nullable: true)]
  110. private ?\DateTimeInterface $publishAt = null;
  112. #[ORM\Column(name: 'edit_at', type: 'datetime', nullable: false)]
  113. private ?\DateTimeInterface $editAt = null;
  115. #[ORM\Column(name: 'storage_contents', type: 'json', nullable: true)]
  116. private array $storageContents = [];
  118. #[ORM\Column(name: 'url_slug', type: 'string', length: 255, unique: true, nullable: true)]
  119. private ?string $urlSlug = null;
  121. #[ORM\Column(name: 'is_lead_artikel', type: 'boolean', nullable: true)]
  122. private bool $isLeadArtikel = false;
  124. #[ORM\Column(name: 'is_lead_gallery_artikel', type: 'boolean', nullable: true)]
  125. private bool $isLeadGalleryArtikel = false;
  127. #[ORM\Column(name: 'pushed_to_twitter_at', type: 'datetime', nullable: true)]
  128. private ?\DateTimeInterface $pushedToTwitterAt = null;
  130. /**
  131. * Publireportage Anzeige in Feed angepinnt auf Position 3 bis zu diesem Datum.
  132. */
  133. #[ORM\Column(name: 'pr_pinned_until', type: 'date', nullable: true)]
  134. private ?\DateTimeInterface $prPinnedUntil = null;
  136. public function __construct(
  137. #[ORM\Id]
  138. #[ORM\Column(name: "id", type: "entityId")]
  139. #[ORM\GeneratedValue(strategy: "NONE")]
  140. private EntityId $id,
  141. string $titel,
  142. ?array $artikelKanale = null
  143. )
  144. {
  145. $this->setTitel($titel);
  147. // Default Values
  148. $this->setStatus(ArtikelStatus::fromString(ArtikelStatus::ID_AS_2)); // Draft Status
  149. $this->setTyp(ArtikelTyp::fromString(ArtikelTyp::ID_AT_1)); // Free
  150. $this->setAssettyp(); // Asset Typ None
  151. $this->verwandteArtikel = new ArrayCollection();
  152. $this->setArtikelKanale($artikelKanale);
  153. $this->setEditAtNow();
  154. $this->setHinweis('Mehr dazu in der gedruckten Ausgabe oder im E-Paper. Kein Abo? Hier bestellen!'); // ACHTUNG: Text "Hier bestellen!" (nicht ändern oder JS-Logik erweitern) wird automatisch im Frontend mit dem ABO Link verlinkt
  155. }
  157. public function change(array $options): void
  158. {
  159. $resolver = new OptionsResolver();
  160. $resolver->setRequired([
  161. 'titel',
  162. 'rubriken',
  163. 'status',
  164. 'typ',
  165. 'lead',
  166. 'hinweis',
  167. 'dossier',
  168. 'content_html',
  169. 'content_html_media_code',
  170. 'video_url',
  171. 'redaktor',
  172. 'redaktor_alternative',
  173. 'spitzmarke',
  174. 'verwandte_artikel',
  175. 'artikel_kanale',
  176. 'publish_at',
  177. 'authored_at',
  178. 'images',
  179. 'pr_content_html',
  180. 'pr_logo',
  181. 'pr_pinned_until',
  182. ]);
  183. $options = $resolver->resolve($options);
  185. $this->setTitel($options['titel']);
  186. $this->setHinweis($options['hinweis']);
  187. $this->setRubriken($options['rubriken']);
  188. $this->setStatus($options['status']);
  189. $this->setTyp($options['typ']);
  190. $this->setLead($options['lead']);
  191. $this->setDossier($options['dossier']);
  192. $this->setContentHtml($options['content_html']);
  193. $this->setContentHtmlMediaCode($options['content_html_media_code']);
  194. $this->setVideoUrl($options['video_url']);
  195. $this->setRedaktor($options['redaktor'], $options['redaktor_alternative']);
  196. $this->setSpitzmarke($options['spitzmarke']);
  197. $this->setVerwandteArtikel($options['verwandte_artikel']);
  198. $this->setArtikelKanale($options['artikel_kanale']);
  199. $this->setAuthoredAt($options['authored_at']);
  200. $this->setImages($options['images']); // setze auch den Assettyp
  202. $this->setPrContentHtml($options['pr_content_html']);
  203. $this->setPrLogo($options['pr_logo']);
  205. // --- Domain Logiken
  206. $this->setAssettyp($this->images());
  207. $this->setPublishAtAndPrPinnedUntil($options['status'], $options['publish_at'], $options['pr_pinned_until']);
  209. // Falls LeadGalleryArtikel aktiv, diesen überprüfen ob noch valid()
  210. if ($this->isLeadGalleryArtikel()) {
  211. $this->autoConfigureLeadArtikelGallery();
  212. }
  213. // Ende
  215. $this->setEditAtNow();
  216. }
  218. /**
  219. * Spez function, welche die Flags der Frontendanzeige regelt!
  220. */
  221. public function changeFrontendConfig(array $options): void
  222. {
  223. // Validierung input
  224. $resolver = new OptionsResolver();
  225. $resolver->setDefaults(
  226. [
  227. 'is_lead_artikel' => null,
  228. 'is_lead_gallery_artikel' => null,
  229. ]
  230. );
  231. $options = $resolver->resolve($options);
  232. // End
  234. if (null !== $options['is_lead_artikel']) {
  235. $this->setIsLeadArtikel($options['is_lead_artikel']);
  236. }
  238. if (null !== $options['is_lead_gallery_artikel']) {
  239. $this->setIsLeadArtikelGallery($options['is_lead_gallery_artikel']);
  240. }
  241. }
  243. /**
  244. * Setzt die Zeit, wann die Mitteilung auf Twitter gepushed wurde.
  245. */
  246. public function setPushedToTwitterNow(): void
  247. {
  248. $this->setPushedToTwitterAt(new \DateTime());
  249. }
  251. public function setPublishAtAndPrPinnedUntil(ArtikelStatus $status, ?\DateTime $publishAt = null, ?\DateTime $prPinnedUntil = null): void
  252. {
  253. // Berechne und setze das Publikationsdatum
  254. if ($status->isPublish() && !$publishAt) {
  255. $this->publishAt = new \DateTime('now'); // umgehend publizieren
  256. } else {
  257. $this->publishAt = $publishAt;
  258. }
  260. // Berechne und setze das Publireportage pinned Datum
  261. if (!$this->typ()->isPublireportage()) {
  262. $this->prPinnedUntil = null;
  263. } elseif ($status->isPublish() && !$prPinnedUntil) {
  264. $dateTmp = clone $this->publishAt;
  265. $this->prPinnedUntil = $dateTmp->add(new \DateInterval('P10D'));
  266. // Standard
  267. } else {
  268. $this->prPinnedUntil = $prPinnedUntil;
  269. }
  270. // end
  271. }
  273. // ----- Ende Domain Functions --------------------------
  275. public function id(): EntityId
  276. {
  277. return $this->id;
  278. }
  280. public function titel(): ?string
  281. {
  282. return $this->titel;
  283. }
  285. public function spitzmarke(): ?string
  286. {
  287. return $this->spitzmarke;
  288. }
  290. /**
  291. * @return ArtikelRubrik[]
  292. */
  293. public function rubriken(): array
  294. {
  295. $artikelRubriken = [];
  296. if ($this->rubrikIds) {
  297. foreach ($this->rubrikIds as $rubrikId) {
  298. $artikelRubriken[] = ArtikelRubrik::fromString($rubrikId);
  299. }
  300. }
  302. return $artikelRubriken;
  303. }
  305. /**
  306. * @return ArtikelKanal[]
  307. */
  308. public function artikelKanale(): array
  309. {
  310. $artikelKanale = [];
  312. if ($this->kanalIds) {
  313. foreach ($this->kanalIds as $kanalId) {
  314. $artikelKanale[] = ArtikelKanal::fromString($kanalId);
  315. }
  316. }
  318. return $artikelKanale;
  319. }
  321. /**
  322. * @return ArtikelStatus
  323. */
  324. public function status(): ArtikelStatus
  325. {
  326. return ArtikelStatus::fromString($this->statusId);
  327. }
  329. /**
  330. * @return ArtikelTyp
  331. */
  332. public function typ(): ArtikelTyp
  333. {
  334. return ArtikelTyp::fromString($this->typId);
  335. }
  337. /**
  338. * @return ArtikelAssettyp
  339. */
  340. public function assettyp(): ArtikelAssettyp
  341. {
  342. return ArtikelAssettyp::fromString($this->assettypId);
  343. }
  345. public function lead(): ?string
  346. {
  347. return $this->lead;
  348. }
  350. private function setLead(?string $lead): void
  351. {
  352. Assert::maxLength($lead, self::MAX_LENGTH_LEAD);
  353. $this->lead = $lead;
  354. }
  356. public function dossier(): ?Dossier
  357. {
  358. return $this->dossier;
  359. }
  361. public function videoUrl(bool $extractYouTubeIdOnly = false): ?string
  362. {
  363. if (true === $extractYouTubeIdOnly && $this->videoUrl) {
  364. return explode('v=', $this->videoUrl)[1];
  365. }
  367. return $this->videoUrl;
  368. }
  370. public function redaktor(): ?Redaktor
  371. {
  372. return $this->redaktor;
  373. }
  375. public function authoredAt(bool $rawData = false): ?\DateTimeInterface
  376. {
  377. if ($rawData || $this->authoredAt) {
  378. return $this->authoredAt;
  379. }
  381. return $this->publishAt();
  382. }
  384. public function publishAt(): ?\DateTimeInterface
  385. {
  386. return $this->publishAt;
  387. }
  389. public function pushedToTwitterAt(): ?\DateTimeInterface
  390. {
  391. return $this->pushedToTwitterAt;
  392. }
  394. public function isPublished(): bool
  395. {
  396. return $this->status()->isPublish() && $this->publishAt() < new \DateTime('now');
  397. }
  399. public function verwandteArtikel(): ArrayCollection|Collection
  400. {
  401. return $this->verwandteArtikel;
  402. }
  404. protected function setStatus(ArtikelStatus $status): static
  405. {
  406. $this->statusId = $status->id();
  407. return $this;
  408. }
  410. protected function setTyp(ArtikelTyp $typ): static
  411. {
  412. $this->typId = $typ->id();
  413. return $this;
  414. }
  416. protected function setAssettyp(?ArtikelImageCollection $artikelImageCollection = null): static
  417. {
  418. $this->assettypId = ArtikelAssettyp::ID_AAT_1;
  420. if ($artikelImageCollection instanceof ArtikelImageCollection) {
  421. if ($artikelImageCollection->count() > 1) {
  422. $this->assettypId = ArtikelAssettyp::ID_AAT_3;
  423. } elseif ($artikelImageCollection->count() === 1) {
  424. $this->assettypId = ArtikelAssettyp::ID_AAT_2;
  425. }
  426. }
  428. return $this;
  429. }
  431. protected function setRubriken(array $rubriken): static
  432. {
  433. $this->rubrikIds = [];
  435. if ($rubriken) {
  436. Assert::allIsInstanceOf($rubriken, ArtikelRubrik::class);
  437. foreach ($rubriken as $item) {
  438. /*
  439. * @var ArtikelKanal $item
  440. */
  441. $this->rubrikIds[] = $item->id();
  442. }
  443. }
  445. return $this;
  446. }
  448. protected function setDossier(?Dossier $dossier = null): static
  449. {
  450. $this->dossier = $dossier;
  451. return $this;
  452. }
  454. protected function setVideoUrl(?string $url): static
  455. {
  456. Assert::regex($url, self::REGEX_VIDEO_URL_PATTERN);
  458. $this->videoUrl = $url;
  460. return $this;
  461. }
  463. private function setTitel(?string $titel): static
  464. {
  465. Assert::minLength($titel, 1);
  466. Assert::maxLength($titel, self::MAX_LENGTH_TITEL);
  468. // Urlslug generieren und setzen
  469. $this->setUrlSlug($titel);
  471. $this->titel = $titel;
  473. return $this;
  474. }
  476. private function setSpitzmarke(?string $spitzmarke): static
  477. {
  478. Assert::maxLength($spitzmarke, self::MAX_LENGTH_SPITZMARKE);
  480. $this->spitzmarke = $spitzmarke;
  482. return $this;
  483. }
  485. private function setRedaktor(?Redaktor $redaktor = null, $redaktorAlternative = null): static
  486. {
  487. $redaktorAlternative = trim((string) $redaktorAlternative);
  489. if ($redaktor && strlen($redaktorAlternative) > 0) {
  490. throw new \InvalidArgumentException('Gleichzeitige Setzung eines Redaktors und einer Redaktor-Alternative ist nicht erlaubt!');
  491. }
  493. $this->redaktor = null;
  494. $this->redaktorAlternative = null;
  496. if ($redaktor instanceof Redaktor) {
  497. $this->redaktor = $redaktor;
  498. } elseif (strlen($redaktorAlternative) > 0) {
  499. $this->storageContents['redaktor_alternative'] = $redaktorAlternative;
  500. }
  502. return $this;
  503. }
  505. public function isLeadArtikel(): bool
  506. {
  507. return $this->isLeadArtikel;
  508. }
  510. private function setIsLeadArtikel(bool $isLeadArtikel): static
  511. {
  512. Assert::boolean($isLeadArtikel);
  514. $this->isLeadArtikel = $isLeadArtikel;
  516. return $this;
  517. }
  519. public function isLeadGalleryArtikel(): bool
  520. {
  521. return $this->isLeadGalleryArtikel;
  522. }
  524. private function setIsLeadArtikelGallery(bool $boolean): static
  525. {
  526. Assert::boolean($boolean);
  528. // Validierung
  529. if ($boolean) {
  530. if ($this->hasGalleryAssets()) {
  531. $this->isLeadGalleryArtikel = true;
  532. } else {
  533. throw new ArtikelNotValidForAGalleryException();
  534. }
  535. } else {
  536. $this->isLeadGalleryArtikel = false;
  537. }
  539. return $this;
  540. }
  542. /**
  543. * Wert wird automatisch gemäss Artikel Daten gesetzt.
  544. */
  545. private function autoConfigureLeadArtikelGallery(): void
  546. {
  547. $this->isLeadGalleryArtikel = $this->hasGalleryAssets();
  548. }
  550. /**
  551. * Kann dieser Artikel in einer Gallery angezeigt werden?
  552. */
  553. public function hasGalleryAssets(): bool
  554. {
  555. return $this->assettyp()->id() === ArtikelAssettyp::ID_AAT_3 || $this->videoUrl();
  556. }
  558. /* --- Publireportage Felder --- */
  559. private function setPrContentHtml(?string $prContentHtml = null): void
  560. {
  561. $prContentHtml = (string) $prContentHtml;
  562. $this->storageContents['pr_content_html'] = $prContentHtml;
  563. }
  565. public function prContentHtml(): ?string
  566. {
  567. return $this->storageContents('pr_content_html');
  568. }
  570. private function setPrLogo(?ArtikelImage $image = null): void
  571. {
  572. if (!$image instanceof ArtikelImage) {
  573. $image = ArtikelImage::createNonExistImage();
  574. }
  576. $this->storageContents['pr_logo'] = [
  577. 'filename' => $image->getFilename(),
  578. 'alt' => $image->getAlt(),
  579. 'caption' => $image->getCaption(),
  580. ];
  581. }
  583. public function prLogo(): ArtikelImage
  584. {
  585. $imageData = $this->storageContents('pr_logo');
  586. if (is_array($imageData)) {
  587. return ArtikelImage::create($imageData['filename'], $imageData['alt'], $imageData['caption'], '', $this->baseObjectServerDirPath(), $this->baseObjectWebDirPath());
  588. }
  590. return ArtikelImage::createNonExistImage();
  591. }
  593. public function prPinnedUntil(): ?\DateTimeInterface
  594. {
  595. return $this->prPinnedUntil;
  596. }
  598. /* --- Ende Publireportage Felder --- */
  601. public function contentHtml(): ?string
  602. {
  603. return $this->contentHtml;
  604. }
  606. private function setContentHtml(?string $contentHtml): void
  607. {
  608. $this->contentHtml = $contentHtml;
  609. }
  611. private function setAuthoredAt(?\DateTime $authoredAt = null): void
  612. {
  613. $this->authoredAt = $authoredAt;
  614. }
  616. private function setPushedToTwitterAt(?\DateTime $pushedToTwitterAt = null): void
  617. {
  618. $this->pushedToTwitterAt = $pushedToTwitterAt;
  619. }
  621. /**
  622. * Zusätzlicher Media HTML-Code welcher zum ContentHtml Inhalt dazu generiert wird
  623. * z.B. ein fertiger IFrame Code oder ein HTML Image Code usw. oder auch ein Javascript.
  624. *
  625. * ACHTUNG: Ausgabe wird nicht escaped!
  626. */
  627. public function contentHtmlMediaCode()
  628. {
  629. return $this->storageContents('content_html_media_code');
  630. }
  632. private function setContentHtmlMediaCode($string): void
  633. {
  634. $this->storageContents['content_html_media_code'] = $string;
  635. }
  637. /**
  638. * Hinweis Text.
  639. */
  640. public function hinweis()
  641. {
  642. return $this->storageContents('hinweis');
  643. }
  645. private function setHinweis($string): void
  646. {
  647. $this->storageContents['hinweis'] = $string;
  648. }
  650. private function setImages(ArtikelImageCollection|array $images = null): void
  651. {
  652. $this->storageContents['images'] = []; // resetten
  653. if ($images) {
  654. Assert::isInstanceOf($images, ArtikelImageCollection::class);
  655. foreach ($images as $image) {
  656. $this->storageContents['images'][] = $image->toArray();
  657. }
  658. }
  659. }
  661. public function images(): ?ArtikelImageCollection
  662. {
  663. $imageDataRaw = $this->storageContents('images');
  665. if ($imageDataRaw) {
  666. // Filepath wieder gemäss $path Parameter wieder dazu bilden hinzufügen
  667. $imageCollection = new ArtikelImageCollection();
  668. foreach ($imageDataRaw as $data) {
  669. $fileName = $data['filename'];
  670. $alt = $data['alt'];
  671. $caption = $data['caption'];
  672. $rightholder = $data['rightholder'];
  674. $imageCollection->add(ArtikelImage::create($fileName, $alt, $caption, $rightholder, $this->baseObjectServerDirPath(), $this->baseObjectWebDirPath()));
  675. }
  676. // Ende
  678. return $imageCollection;
  679. }
  681. return null;
  682. }
  684. private function setEditAtNow(): void
  685. {
  686. $this->editAt = new \DateTime();
  687. }
  689. public function editAt(): ?\DateTimeInterface
  690. {
  691. return $this->editAt;
  692. }
  694. public function redaktorAlternativ()
  695. {
  696. return $this->storageContents('redaktor_alternative');
  697. }
  699. // Hier muss array der Typ sein, weil es als Array aus dem Form kommt und nicht als Collection, evtl, weil der ChoiceType verwendet wird anstatt EntityType.
  700. // Habe ehrlich gesagt langsam die Schnauze voll von dieser Typisierung. SB/7.3.2024
  701. private function setVerwandteArtikel(?array $verwandteArtikel = null): void
  702. {
  703. // Verwandte Artikel nullen
  704. $this->verwandteArtikel = new ArrayCollection();
  706. if ($verwandteArtikel) {
  707. Assert::allIsInstanceOf($verwandteArtikel, Artikel::class);
  709. // Entferne verwandter Artikel, welcher er selbst ist
  710. foreach ($verwandteArtikel as $artikel) {
  711. if ($artikel->id != $this->id) {
  712. $this->verwandteArtikel[] = $artikel;
  713. } else {
  714. throw new ArtikelSelfReferenzException();
  715. }
  716. }
  717. }
  718. }
  720. private function setArtikelKanale($artikelKanale = null): void
  721. {
  722. $this->kanalIds = [];
  724. if ($artikelKanale) {
  725. Assert::allIsInstanceOf($artikelKanale, ArtikelKanal::class);
  726. foreach ($artikelKanale as $item) {
  727. /*
  728. * @var ArtikelKanal $item
  729. */
  730. $this->kanalIds[] = $item->id();
  731. }
  733. foreach ($this->kanalIds as $kanalId) {
  734. // Falls nicht als Lead Artikel verwendet werden darf isLeadArtikel Flag zurücksetzen
  735. if (in_array($kanalId, [ArtikelKanal::ID_AK_2, ArtikelKanal::ID_AK_3], true)) {
  736. $this->setIsLeadArtikel(false);
  737. }
  738. }
  739. }
  740. }
  742. private function storageContents($key)
  743. {
  744. $storage = $this->storageContents ?: [];
  745. if (array_key_exists($key, $storage)) {
  746. return $storage[$key];
  747. }
  749. return null;
  750. }
  752. #[\Override]
  753. public function baseObjectServerDirPath(): string
  754. {
  755. return __DIR__.'/../../../var/data/public/artikel/'.substr($this->id, 0, 2).'/'.substr($this->id, 2, 2).'/'.$this->id;
  756. }
  758. #[\Override]
  759. public function baseObjectWebDirPath(): string
  760. {
  761. return '/data/artikel/'.substr($this->id, 0, 2).'/'.substr($this->id, 2, 2).'/'.$this->id;
  762. }
  764. #[\Override]
  765. public function removeUnusedFiles(): void
  766. {
  767. $serverPath = $this->baseObjectServerDirPath();
  769. // Auflistung aller effektiv benötigter Filenamen dieses Objects, damit diese erhalten bleiben
  770. $usedFiles_ = [];
  772. if ($this->images()) {
  773. foreach ($this->images() as $image) {
  774. $usedFiles_[] = $image->getFilename();
  775. }
  776. }
  777. if ($this->prLogo()->doesExist()) {
  778. $usedFiles_[] = $this->prLogo()->getFilename();
  779. }
  780. // Ende
  782. // Lösche alle Files aus dem Objektverzeichnis, welche nicht im Objekt vorhanden sind
  783. $fs = new Filesystem();
  784. if ($fs->exists($serverPath)) {
  785. $finder = new Finder();
  786. $finder->files()->in($serverPath);
  787. foreach ($finder as $file) {
  788. if (!in_array($file->getFilename(), $usedFiles_)) {
  789. $fs->remove($file->getRealPath());
  790. }
  791. }
  792. }
  793. // Ende
  794. }
  796. public function urlSlug(): ?string
  797. {
  798. return $this->urlSlug;
  799. }
  801. /**
  802. * Generiert einen Spez. Slug mit Suffix -p{Nummer}.
  803. */
  804. public function generateNextUrlSlug(): void
  805. {
  806. // Filtere eine bestehende UrlSlug Nummer raus und erhöhe diese!
  807. $result = [];
  808. preg_match('/.*-p(\\d+)$/', $this->urlSlug, $result);
  809. if ($result) {
  810. $pageNrSuffix = ($result[1] + 1); // inkrementiere die bestehende p Nummer um 1
  811. } else {
  812. $pageNrSuffix = 1;
  813. }
  814. // end
  816. $this->setUrlSlug($this->titel.'-p'.$pageNrSuffix);
  817. }
  819. private function setUrlSlug($string): void
  820. {
  821. // all chars lowercase
  822. $urlSlug = self::extractUrlSlug($string);
  824. Assert::notEmpty($urlSlug);
  825. Assert::maxLength($urlSlug, self::MAX_LENGTH_URLSLUG);
  827. $this->urlSlug = $urlSlug;
  828. }
  830. public static function extractUrlSlug($string): array|string|null
  831. {
  832. return UrlSlug::fromString($string);
  833. }
  834. }