src/Entity/Page.php line 32

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Config;
  6. use App\Entity\Menu\Item;
  7. use App\Entity\Utils\HistoryInterface;
  8. use App\Entity\Utils\IntlInterface;
  9. use App\Entity\Utils\ReleaseInterface;
  10. use App\Entity\Utils\Traits\SeoTrait;
  11. use App\Entity\Utils\Traits\TemplateTrait;
  12. use App\Entity\Utils\Traits\TimestampTrait;
  13. use App\Entity\Utils\Traits\VisibilityTrait;
  14. use App\Entity\Utils\VersionInterface;
  15. use App\Model\ContentProperties;
  16. use App\Model\Slice;
  17. use App\Repository\PageRepository;
  18. use App\Utils\Helper;
  19. use DateTime;
  20. use Doctrine\Common\Collections\ArrayCollection;
  21. use Doctrine\Common\Collections\Collection;
  22. use Doctrine\DBAL\Types\Types;
  23. use Doctrine\ORM\Mapping as ORM;
  24. use Stringable;
  25. use Symfony\Component\Validator\Constraints as Assert;
  27. /**
  28.  * Class Page.
  29.  */
  30. #[ORM\Table(name: 'page')]
  31. #[ORM\Entity(repositoryClass: PageRepository::class)]
  32. class Page implements VersionInterface, ReleaseInterface, HistoryInterface, IntlInterface, Stringable
  33. {
  34.     use TimestampTrait;
  35.     use TemplateTrait;
  36.     use VisibilityTrait;
  37.     use SeoTrait;
  39.     final public const STATUS_DRAFT     = 'draft';
  40.     final public const STATUS_PENDING   = 'pending';
  41.     final public const STATUS_PUBLISHED = 'published';
  42.     final public const STATUS_ARCHIVED  = 'archived';
  43.     final public const STATUS_TRASH     = 'trash';
  44.     final public const CACHING_NO_CACHE   = 'no-cache';
  45.     final public const CACHING_BASIC      = 'basic';
  46.     final public const CACHING_SIMPLE     = 'simple';
  47.     final public const CACHING_AGGRESSIVE = 'aggressive';
  49.     #[ORM\Id]
  50.     #[ORM\Column(type: Types::INTEGER)]
  51.     #[ORM\GeneratedValue]
  52.     protected ?int $id = null;
  54.     #[ORM\Column(type: Types::STRING, length: 255)]
  55.     #[Assert\NotBlank(message: 'form.error.required')]
  56.     #[Assert\Length(min: 2, max: 255, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  57.     protected string $type;
  59.     #[ORM\Column(type: Types::STRING, length: 255)]
  60.     #[Assert\NotBlank(message: 'form.error.required')]
  61.     #[Assert\Length(min: 2, max: 255, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  62.     protected string $cachingLevel = self::CACHING_BASIC;
  64.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  65.     #[Assert\Length(min: 2, max: 255, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  66.     protected ?string $globalTitle;
  68.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  69.     #[Assert\Length(min: 2, max: 10000, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  70.     protected ?string $globalDescription = null;
  72.     #[ORM\Column(type: Types::STRING, length: 255)]
  73.     #[Assert\NotBlank(message: 'form.error.required')]
  74.     #[Assert\Length(min: 2, max: 255, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  75.     protected string $title;
  77.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  78.     #[Assert\Length(min: 2, max: 10000, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  79.     protected ?string $description = null;
  81.     #[ORM\Column(type: Types::JSON, nullable: true)]
  82.     protected ?array $contentProperties = [];
  84.     #[ORM\Column(type: Types::STRING, length: 255)]
  85.     #[Assert\NotBlank(message: 'form.error.required')]
  86.     protected string $locale = 'en';
  88.     #[ORM\OneToMany(mappedBy: 'master', targetEntity: 'Page', cascade: ['detach'])]
  89.     protected Collection $translations;
  91.     #[ORM\ManyToOne(targetEntity: 'Page', cascade: ['detach'], inversedBy: 'translations')]
  92.     #[ORM\JoinColumn(name: 'master_id', onDelete: 'SET NULL')]
  93.     protected $master;
  95.     #[ORM\Column(type: Types::JSON, nullable: true)]
  96.     protected ?array $slices = [];
  98.     #[Assert\Valid]
  99.     #[ORM\OneToMany(mappedBy: 'page', targetEntity: 'Path', cascade: ['all'])]
  100.     protected Collection $paths;
  102.     #[ORM\Column(type: Types::JSON, nullable: true)]
  103.     protected ?array $breadcrumb;
  105.     #[ORM\Column(type: Types::STRING)]
  106.     #[Assert\NotBlank(message: 'form.error.required')]
  107.     protected string $status = self::STATUS_DRAFT;
  109.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  110.     #[Assert\Length(min: 2, max: 2000, minMessage: 'form.error.short', maxMessage: 'form.error.long')]
  111.     protected ?string $updateComment = null;
  113.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  114.     protected ?DateTime $published = null;
  116.     #[ORM\ManyToOne(targetEntity: 'BackUser', cascade: ['persist'])]
  117.     #[ORM\JoinColumn(name: 'lastPublisher_id')]
  118.     protected ?BackUser $lastPublisher = null;
  120.     protected bool $hasBeenPublished = false;
  122.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  123.     protected ?DateTime $expired = null;
  125.     #[ORM\ManyToMany(targetEntity: 'Tag', inversedBy: 'pages', cascade: ['detach'])]
  126.     #[ORM\JoinTable(name: 'page_tags', joinColumns: [new ORM\JoinColumn(name: 'page_id', referencedColumnName: 'id')], inverseJoinColumns: [new ORM\JoinColumn(name: 'tag_id', referencedColumnName: 'id')])]
  127.     protected Collection $tags;
  129.     #[ORM\OneToMany(mappedBy: 'page', targetEntity: Item::class, cascade: ['detach'])]
  130.     protected Collection $menuItems;
  132.     /**
  133.      * Page constructor.
  134.      */
  135.     public function __construct(string $title, ?string $type = null, string $locale = 'en', ?string $template = null, ?string $description = null)
  136.     {
  137.         $this->tags         = new ArrayCollection();
  138.         $this->translations = new ArrayCollection();
  139.         $this->menuItems    = new ArrayCollection();
  140.         $this->paths        = new ArrayCollection();
  142.         $this->setTitle($title);
  143.         $this->setGlobalTitle($title);
  144.         if ($locale) {
  145.             $this->setLocale($locale);
  146.         }
  148.         if ($type) {
  149.             $this->setType($type);
  151.             if ($template) {
  152.                 $this->setTemplate($template);
  153.             }
  154.             $this->setDescription($description);
  155.             $this->setGlobalDescription($description);
  157.             if ($this->canBeSeen()) {
  158.                 if ($this->isMulti()) {
  159.                     $path = new Path(Config::getContentDefaultPath($type).Helper::toSlug($this->getTitle()), $this->getLocale());
  160.                 } else {
  161.                     $path = new Path(Config::getContentDefaultPath($type), $this->getLocale());
  162.                 }
  163.                 $this->addPath($path);
  164.             }
  165.         }
  166.     }
  168.     public function __toString(): string
  169.     {
  170.         return (string) $this->globalTitle;
  171.     }
  173.     public function setId(int $id): void
  174.     {
  175.         $this->id = $id;
  176.     }
  178.     public function getId(): int
  179.     {
  180.         return $this->id;
  181.     }
  183.     public function getType(): ?string
  184.     {
  185.         return $this->type;
  186.     }
  188.     public function setType(string $type): void
  189.     {
  190.         $this->type = $type;
  191.     }
  193.     public function isMulti(): bool
  194.     {
  195.         return Config::isContentMulti($this->type);
  196.     }
  198.     public function getCachingLevel(): string
  199.     {
  200.         return $this->cachingLevel;
  201.     }
  203.     public function setCachingLevel(string $cachingLevel): void
  204.     {
  205.         $this->cachingLevel = $cachingLevel;
  206.     }
  208.     public function getGlobalTitle(): string
  209.     {
  210.         return $this->globalTitle;
  211.     }
  213.     public function setGlobalTitle(string $globalTitle): void
  214.     {
  215.         $this->globalTitle = $globalTitle;
  217.         if ($this->isMaster()) {
  218.             /** @var Page $translation */
  219.             foreach ($this->translations as $translation) {
  220.                 $translation->setGlobalTitle($globalTitle);
  221.             }
  222.         }
  223.     }
  225.     public function getGlobalDescription(): ?string
  226.     {
  227.         return $this->globalDescription;
  228.     }
  230.     public function setGlobalDescription(?string $globalDescription): void
  231.     {
  232.         $this->globalDescription = $globalDescription;
  233.     }
  235.     public function getTitle(): string
  236.     {
  237.         return $this->title;
  238.     }
  240.     public function setTitle(string $title): void
  241.     {
  242.         $this->title = $title;
  243.     }
  245.     public function getDescription(): ?string
  246.     {
  247.         return $this->description;
  248.     }
  250.     public function setDescription(?string $description): void
  251.     {
  252.         $this->description = $description;
  253.     }
  255.     public function getContentProperties(): ContentProperties
  256.     {
  257.         return new ContentProperties(array_merge($this->contentProperties ?? [], [
  258.             'locale' => $this->getLocale(),
  259.         ]));
  260.     }
  262.     public function setContentProperties(ContentProperties $contentProperties): void
  263.     {
  264.         $this->contentProperties = $contentProperties->export();
  265.     }
  267.     public function addSlice(Slice $slice): Page
  268.     {
  269.         $this->slices[$slice->getPosition()] = $slice->export();
  271.         return $this;
  272.     }
  274.     public function removeSlice(Slice $slice): void
  275.     {
  276.         unset($this->slices[$slice->getPosition()]);
  277.     }
  279.     public function getSlices(): ?array
  280.     {
  281.         $slices = [];
  283.         if ($this->slices) {
  284.             foreach ($this->slices as $slice) {
  285.                 $slices[] = new Slice(array_merge($slice, [
  286.                     'locale' => $this->getLocale(),
  287.                 ]));
  288.             }
  289.         }
  291.         return $slices;
  292.     }
  294.     public function getSlicesFront(): array
  295.     {
  296.         $slices = [];
  298.         if ($this->slices) {
  299.             foreach ($this->slices as $slice) {
  300.                 if ('public' == $slice['visibility']) {
  301.                     $slices[] = new Slice(array_merge($slice, [
  302.                         'context' => 'front',
  303.                     ]));
  304.                 }
  305.             }
  306.         }
  308.         return $slices;
  309.     }
  311.     public function getSlicesType(): ?array
  312.     {
  313.         $slices = [];
  315.         if ($this->slices) {
  316.             foreach ($this->slices as $slice) {
  317.                 $slices[] = $slice['type'];
  318.             }
  319.         }
  321.         return $slices;
  322.     }
  324.     public function setSlices(array $slices): void
  325.     {
  326.         foreach ($slices as $b) {
  327.             if (!($b instanceof Slice)) {
  328.                 $b = new Slice($b);
  329.             }
  330.             $this->addSlice($b);
  331.         }
  332.     }
  334.     public function removeAllSlices(): void
  335.     {
  336.         if ($this->slices && is_countable($this->slices)) {
  337.             foreach ($this->slices as $b) {
  338.                 if (!($b instanceof Slice)) {
  339.                     $b = new Slice($b);
  340.                 }
  341.                 $this->removeSlice($b);
  342.             }
  343.         }
  344.     }
  346.     public function import(array $data, bool $partial = false): void
  347.     {
  348.         $fields = $this->getArrayModel($partial);
  350.         foreach ($fields as $field) {
  351.             $setter = 'set'.ucfirst((string) $field);
  353.             if (isset($data[$field])) {
  354.                 $fields[$field] = $this->{$setter}($data[$field]);
  355.             }
  356.         }
  358.         if (!$partial) {
  359.             if (isset($data['slices'])) {
  360.                 $this->setSlices($data['slices']);
  361.             }
  362.             if (isset($data['contentProperties'])) {
  363.                 $this->setContentProperties(new ContentProperties($data['contentProperties']));
  364.             }
  366.             if (isset($data['path']) && $this->getCurrentPath() != $data['path']) {
  367.                 $oldPath = $this->hasPath($data['path']);
  368.                 if (!$oldPath) {
  369.                     $path = new Path($data['path'], $this->getLocale());
  370.                     $this->addPath($path);
  371.                 } else {
  372.                     $this->getCurrentPath(false)->setType(Path::TYPE_REDIRECT);
  373.                     $oldPath->setType(Path::TYPE_CURRENT);
  374.                 }
  375.             }
  376.         }
  377.     }
  379.     public function export(string $locale = null): array
  380.     {
  381.         $fields = [];
  383.         foreach ($this->getArrayModel() as $field) {
  384.             $getter = 'get'.ucfirst((string) $field);
  386.             $fields[$field] = $this->{$getter}();
  387.         }
  389.         if ($this->canBeSeen()) {
  390.             $fields['path'] = $this->getCurrentPath();
  391.         }
  393.         if ($locale) {
  394.             $fields['locale'] = $locale;
  395.         }
  397.         return array_merge(
  398.             $fields,
  399.             [
  400.                 'slices'            => $this->slices,
  401.                 'contentProperties' => $this->contentProperties,
  402.             ]
  403.         );
  404.     }
  406.     public function getArrayModel(bool $partial = false): array
  407.     {
  408.         if ($partial) {
  409.             $data = array_merge(
  410.                 [
  411.                     'type',
  412.                     'globalTitle',
  413.                     'title',
  414.                     'locale',
  415.                 ],
  416.                 $this->getTemplateArrayModel()
  417.             );
  418.         } else {
  419.             $data = array_merge(
  420.                 [
  421.                     'type',
  422.                     'globalTitle',
  423.                     'globalDescription',
  424.                     'title',
  425.                     'description',
  426.                     'locale',
  427.                 ],
  428.                 $this->getVisibilityArrayModel(),
  429.                 $this->getSeoArrayModel(),
  430.                 $this->getTemplateArrayModel()
  431.             );
  432.         }
  434.         return $data;
  435.     }
  437.     public function getLocale(): string
  438.     {
  439.         return $this->locale;
  440.     }
  442.     public function setLocale(string $locale): void
  443.     {
  444.         $this->locale = $locale;
  445.     }
  447.     public function getExistingLocales(): array
  448.     {
  449.         $locales = [];
  451.         $master    = $this->getMaster();
  452.         $locales[] = $master->getLocale();
  454.         /** @var Page $translation */
  455.         foreach ($this->getTranslations() as $translation) {
  456.             $locales[] = $translation->getLocale();
  457.         }
  459.         return $locales;
  460.     }
  462.     public function getTranslations(): Collection
  463.     {
  464.         $master = $this->getMaster();
  466.         return $master->translations;
  467.     }
  469.     public function getTranslation(string $locale): mixed
  470.     {
  471.         $master = $this->getMaster();
  473.         if ($master->getLocale() == $locale) {
  474.             return $master;
  475.         }
  477.         if (is_countable($master->getTranslations()) ? count($master->getTranslations()) : 0) {
  478.             /** @var Page $translation */
  479.             foreach ($master->getTranslations() as $translation) {
  480.                 if ($translation->getLocale() == $locale) {
  481.                     return $translation;
  482.                 }
  483.             }
  484.         }
  486.         return null;
  487.     }
  489.     public function addTranslation(object $translation): void
  490.     {
  491.         $this->translations[] = $translation;
  492.         $translation->setMaster($this);
  493.     }
  495.     public function removeTranslation(object $translation): void
  496.     {
  497.         $this->translations->removeElement($translation);
  498.         $translation->setMaster(null);
  499.     }
  501.     public function removeAllTranslation(): void
  502.     {
  503.         foreach ($this->translations as $translation) {
  504.             $this->removeTranslation($translation);
  505.         }
  506.     }
  508.     public function isMaster(): bool
  509.     {
  510.         return !$this->master;
  511.     }
  513.     public function getMaster()
  514.     {
  515.         if (!$this->master) {
  516.             return $this;
  517.         }
  519.         return $this->master;
  520.     }
  522.     public function setMaster(?object $master): void
  523.     {
  524.         $this->master = $master;
  525.     }
  527.     public function addPath(Path $path): Page
  528.     {
  529.         $this->paths[] = $path;
  530.         $path->setPage($this);
  532.         return $this;
  533.     }
  535.     public function removePath(Path $path): void
  536.     {
  537.         $this->paths->removeElement($path);
  538.         $path->setPage(null);
  539.     }
  541.     public function getPaths(bool $string = false): ArrayCollection|Collection|array
  542.     {
  543.         if ($string) {
  544.             $paths = [];
  546.             /** @var Path $path */
  547.             foreach ($this->paths as $path) {
  548.                 $paths[] = $path->getPath();
  549.             }
  551.             return $paths;
  552.         }
  554.         return $this->paths;
  555.     }
  557.     public function getRedirections(): array
  558.     {
  559.         $paths = [];
  561.         if (isset($this->paths)) {
  562.             /** @var Path $path */
  563.             foreach ($this->paths as $path) {
  564.                 if (Path::TYPE_REDIRECT == $path->getType()) {
  565.                     $paths[] = $path;
  566.                 }
  567.             }
  568.         }
  570.         return $paths;
  571.     }
  573.     public function getCurrentPath(bool $string = true): string|Path|null
  574.     {
  575.         if (isset($this->paths)) {
  576.             /** @var Path $path */
  577.             foreach ($this->paths as $path) {
  578.                 if (Path::TYPE_CURRENT == $path->getType()) {
  579.                     return $string ? $path->getPath() : $path;
  580.                 }
  581.             }
  582.         }
  584.         return null;
  585.     }
  587.     public function hasPath(string $checkPath): ?Path
  588.     {
  589.         if (isset($this->paths)) {
  590.             /** @var Path $path */
  591.             foreach ($this->paths as $path) {
  592.                 if ($checkPath == $path->getPath()) {
  593.                     return $path;
  594.                 }
  595.             }
  596.         }
  598.         return null;
  599.     }
  601.     public function getBreadcrumb(): ?array
  602.     {
  603.         return $this->breadcrumb;
  604.     }
  606.     public function setBreadcrumb($breadcrumb): void
  607.     {
  608.         $this->breadcrumb = $breadcrumb;
  609.     }
  611.     public function isVisible(): bool
  612.     {
  613.         return 'public' == $this->visibility && Page::STATUS_PUBLISHED == $this->status;
  614.     }
  616.     public static function getPublicationStatusesHuman(): array
  617.     {
  618.         $statusesHmn = [];
  620.         $statuses = [
  621.             self::STATUS_DRAFT,
  622.             self::STATUS_PENDING,
  623.             'soon_published',
  624.             self::STATUS_PUBLISHED,
  625.             'soon_expired',
  626.             'expired',
  627.             self::STATUS_ARCHIVED,
  628.         ];
  630.         foreach ($statuses as $status) {
  631.             $statusesHmn['publication.status.'.$status] = $status;
  632.         }
  634.         return $statusesHmn;
  635.     }
  637.     public static function getPublicationStatusesString(): string
  638.     {
  639.         return implode(',', self::getPublicationStatusesHuman());
  640.     }
  642.     public function isPublishedSoon(): bool
  643.     {
  644.         if (!$this->getPublished()) {
  645.             return false;
  646.         }
  648.         $today     = new DateTime();
  649.         $inTwoDays = new DateTime();
  650.         $inTwoDays->add(new \DateInterval('P2D'));
  652.         if ($this->getPublished() > $today && $this->getPublished() < $inTwoDays) {
  653.             return true;
  654.         }
  656.         return false;
  657.     }
  659.     public function isExpiredSoon(): bool
  660.     {
  661.         if (!$this->getExpired()) {
  662.             return false;
  663.         }
  665.         $today     = new DateTime();
  666.         $inTwoDays = new DateTime();
  667.         $inTwoDays->add(new \DateInterval('P2D'));
  669.         if ($this->getExpired() > $today && $this->getExpired() < $inTwoDays) {
  670.             return true;
  671.         }
  673.         return false;
  674.     }
  676.     public function getStatus(): string
  677.     {
  678.         return $this->status;
  679.     }
  681.     public function setStatus($status): void
  682.     {
  683.         $this->status = $status;
  684.         if (Page::STATUS_PUBLISHED == $status) {
  685.             $this->hasBeenPublished = true;
  686.         }
  687.     }
  689.     public function getUpdateComment(): ?string
  690.     {
  691.         return $this->updateComment;
  692.     }
  694.     public function setUpdateComment(?string $updateComment): void
  695.     {
  696.         $this->updateComment = $updateComment;
  697.     }
  699.     public function getPublished(): ?DateTime
  700.     {
  701.         return $this->published;
  702.     }
  704.     public function setPublished(?DateTime $published = null): void
  705.     {
  706.         $this->published = $published;
  707.     }
  709.     public function getLastPublisher(): ?BackUser
  710.     {
  711.         return $this->lastPublisher;
  712.     }
  714.     public function setLastPublisher(?BackUser $lastPublisher = null): void
  715.     {
  716.         $this->lastPublisher = $lastPublisher;
  717.     }
  719.     /**
  720.      * @throws \Exception
  721.      */
  722.     public function updatePublisher(BackUser $lastPublisher): bool
  723.     {
  724.         if ($this->hasBeenPublished) {
  725.             $this->setLastPublisher($lastPublisher);
  726.             $this->setPublished(new DateTime());
  727.             $this->hasBeenPublished = false;
  729.             return true;
  730.         }
  732.         return false;
  733.     }
  735.     public function getExpired(): ?DateTime
  736.     {
  737.         return $this->expired;
  738.     }
  740.     public function setExpired(?DateTime $expired = null): void
  741.     {
  742.         $this->expired = $expired;
  743.     }
  745.     public function addTag(Tag $tag): void
  746.     {
  747.         $this->tags[] = $tag;
  748.         $tag->addPage($this);
  749.     }
  751.     public function removeTag(Tag $tag): void
  752.     {
  753.         $this->tags->removeElement($tag);
  754.         $tag->removePage($this);
  755.     }
  757.     public function removeAllTags(string $type): void
  758.     {
  759.         if (is_countable($this->tags)) {
  760.             foreach ($this->tags as $tag) {
  761.                 if ($tag->getType() === $type) {
  762.                     $this->removeTag($tag);
  763.                 }
  764.             }
  765.         }
  766.     }
  768.     public function getTags(?string $type = null): Collection
  769.     {
  770.         if ($type) {
  771.             $tags = new ArrayCollection();
  772.             /** @var Tag $tag */
  773.             foreach ($this->tags as $tag) {
  774.                 if ($tag->getType() == $type) {
  775.                     $tags->add($tag);
  776.                 }
  777.             }
  779.             return $tags;
  780.         }
  782.         return $this->tags;
  783.     }
  785.     public function hasTag(int $tagId): bool
  786.     {
  787.         foreach ($this->tags as $tag) {
  788.             if ($tag->getId() == $tagId) {
  789.                 return true;
  790.             }
  791.         }
  793.         return false;
  794.     }
  796.     public function addMenuItem(Item $item): void
  797.     {
  798.         $this->menuItems[] = $item;
  799.         $item->setPage($this);
  800.     }
  802.     public function removeMenuItem(Item $item): void
  803.     {
  804.         $this->menuItems->removeElement($item);
  805.         $item->setPage($this);
  806.     }
  808.     public function getMenuItems(): Collection
  809.     {
  810.         return $this->menuItems;
  811.     }
  813.     public function cleanJson(): bool
  814.     {
  815.         $contentProperties = $this->getContentProperties();
  816.         $contentProperties->clean(Config::getContentProperties($this->type));
  817.         $this->setContentProperties($contentProperties);
  819.         $slices = $this->getSlices();
  821.         $cleanedSlices = [];
  823.         /** @var Slice $slice */
  824.         foreach ($slices as $key => $slice) {
  825.             if (Config::getSliceFields($slice->getType())) {
  826.                 $slice->clean();
  828.                 $cleanedSlices[] = $slice;
  829.             }
  830.         }
  832.         $this->setSlices($cleanedSlices);
  834.         return true;
  835.     }
  837.     public function hasSlicesAllowed(): bool
  838.     {
  839.         return 'free-html' != $this->getTemplate() && count(Config::getSlices($this->getTemplate()));
  840.     }
  842.     public function canBeSeen(): bool
  843.     {
  844.         return !Config::isContentHidden(self::getType());
  845.     }
  847.     public function getEntityType(): ?string
  848.     {
  849.         return 'page';
  850.     }
  851. }