src/Admin/Entity/StdPages.php line 22

Open in your IDE?
  1. <?php
  3. namespace App\Admin\Entity;
  5. use App\Entity\StdPagesTracking;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\Common\Collections\Criteria;
  11. /**
  12.  * StdPages
  13.  */
  14. #[ORM\Table(name: 'std_pages')]
  15. #[ORM\Index(name: 'fk_std_pages_std_users', columns: ['created_by'])]
  16. #[ORM\Index(name: 'fk_std_pages_std_users_0', columns: ['updated_by'])]
  17. #[ORM\Index(name: 'fk_std_pages_std_templates', columns: ['template_id'])]
  18. #[ORM\Index(name: 'fk_std_pages_std_content_types', columns: ['content_type'])]
  19. #[ORM\Index(name: 'idx_machine_name', columns: ['machine_name'])]
  20. #[ORM\Entity(repositoryClass: 'App\Admin\Repository\StdPagesRepository')]
  21. #[ORM\HasLifecycleCallbacks]
  22. class StdPages
  23. {
  24.     /**
  25.      * @var int
  26.      */
  27.     #[ORM\Column(name: 'id', type: 'integer', nullable: false, options: ['unsigned' => true, 'comment' => 'Page unique identifier'])]
  28.     #[ORM\Id]
  29.     #[ORM\GeneratedValue(strategy: 'IDENTITY')]
  30.     private $id;
  32.     /**
  33.      * @var string
  34.      */
  35.     #[ORM\Column(name: 'name', type: 'string', length: 100, nullable: true, options: ['comment' => 'Page name'])]
  36.     private $name;
  38.     /**
  39.      * @var \StdContentTypes
  40.      */
  41.     #[ORM\JoinColumn(name: 'content_type', referencedColumnName: 'id')]
  42.     #[ORM\ManyToOne(targetEntity: 'StdContentTypes')]
  43.     private $contentType;
  45.     /**
  46.      * @var \StdTemplates|null
  47.      */
  48.     #[ORM\JoinColumn(name: 'template_id', referencedColumnName: 'id')]
  49.     #[ORM\ManyToOne(targetEntity: 'StdTemplates')]
  50.     private $templateId;
  52.     /**
  53.      * @var bool
  54.      */
  55.     #[ORM\Column(name: 'is_active', type: 'boolean', nullable: false, options: ['default' => 1, 'comment' => 'Flag that indicates if the page is active'])]
  56.     private $isActive = '1';
  58.     #[ORM\OneToOne(mappedBy: 'page', targetEntity: StdPagesApprovalStatus::class, cascade: ['persist', 'remove'])]
  59.     private ?StdPagesApprovalStatus $approvalStatus = null;
  61.     /**
  62.      * @var \StdUsers
  63.      */
  64.     #[ORM\JoinColumn(name: 'created_by', referencedColumnName: 'id')]
  65.     #[ORM\ManyToOne(targetEntity: 'StdUsers')]
  66.     private $createdBy;
  68.     /**
  69.      * @var \DateTime
  70.      */
  71.     #[ORM\Column(name: 'created_date', type: 'datetime', nullable: false, options: ['comment' => 'Date and time of the record creation'])]
  72.     private $createdDate;
  74.     /**
  75.      * @var \StdUsers
  76.      */
  77.     #[ORM\JoinColumn(name: 'updated_by', referencedColumnName: 'id')]
  78.     #[ORM\ManyToOne(targetEntity: 'StdUsers')]
  79.     private $updatedBy;
  81.     /**
  82.      * @var \DateTime
  83.      */
  84.     #[ORM\Column(name: 'updated_date', type: 'datetime', nullable: false, options: ['comment' => 'Date and time the record was last updated'])]
  85.     private $updatedDate;
  87.     /**
  88.      * @var int
  89.      */
  90.     #[ORM\Column(name: 'order_value', type: 'integer', nullable: true, options: ['comment' => 'Page order'])]
  91.     private $orderValue;
  93.     /**
  94.      * @var \DateTime|null
  95.      */
  96.     #[ORM\Column(name: 'publish_date', type: 'datetime', nullable: true, options: ['comment' => 'Date/hour when to publish page'])]
  97.     private $publishDate;
  99.     /**
  100.      * @var \DateTime|null
  101.      */
  102.     #[ORM\Column(name: 'expire_date', type: 'datetime', nullable: true, options: ['comment' => 'Date/time when to expire (unpublish) page'])]
  103.     private $expireDate;
  106.       /**
  107.      * @var Doctrine\Common\Collections\ArrayCollection|null
  108.      */
  109.     #[ORM\OneToMany(targetEntity: 'StdFavoritePagesUsers', mappedBy: 'pageId', cascade: ['persist', 'remove'], orphanRemoval: true, fetch: 'EXTRA_LAZY')]
  110.     private $favoriteUsers;
  112.     #[ORM\JoinTable(name: 'std_page_web_role')]
  113.     #[ORM\JoinColumn(name: 'page_id', referencedColumnName: 'id')]
  114.     #[ORM\InverseJoinColumn(name: 'webrole_id', referencedColumnName: 'id')]
  115.     #[ORM\ManyToMany(targetEntity: 'StdWebRoles', inversedBy: 'pages', cascade: ['persist'])]
  116.     private $webroles;
  117.     /**
  118.      * @var string
  119.      */
  120.     #[ORM\Column(name: 'layout', type: 'string', length: 100, nullable: true, options: ['comment' => 'Page layout'])]
  121.     private $layout;
  123.      /**
  124.      * @var Doctrine\Common\Collections\ArrayCollection|null
  125.      */
  126.     #[ORM\OneToMany(targetEntity: 'StdPagesContent', mappedBy: 'pageId', cascade: ['persist', 'remove'], orphanRemoval: true)]
  127.     private $pagesContent;
  129.     #[ORM\OneToMany(mappedBy: 'page', targetEntity: StdPagesTag::class, cascade: ['persist', 'remove'], orphanRemoval: true, fetch: 'EAGER')]
  130.     private Collection $tags;
  132.     #[ORM\Column(name:'machine_name', type:'string', length: 255, nullable: true)]
  133.     private ?string $machineName = null;
  135.     /**
  136.      * @var bool
  137.      */
  138.     #[ORM\Column(name: 'include_sitemap', type: 'boolean', nullable: false, options: ['default' => 1, 'comment' => 'Flag that indicates if the page is to be included in Sitemap'])]
  139.     private $includeSitemap = '1';
  141.     #[ORM\OneToMany(mappedBy: 'pageId', targetEntity: StdPagesPages::class)]
  142.     private Collection $relations;
  144.     #[ORM\OneToMany(mappedBy: 'page', targetEntity: StdPagesTracking::class, cascade: ['persist', 'remove'])]
  145.     private Collection $trackings;
  147.     /**
  148.      * @var Collection<int, StdUsers>
  149.      */
  150.     #[ORM\ManyToMany(targetEntity: StdUsers::class, inversedBy: 'authoredPages')]
  151.     #[ORM\JoinTable(name: 'std_pages_authors')]
  152.     private Collection $pageAuthors;
  154.     public function __construct()
  155.     {
  156.         $this->webroles = new ArrayCollection();
  157.         $this->pagesContent = new ArrayCollection();
  158.         $this->trackings = new ArrayCollection();
  159.         $this->relations = new ArrayCollection();
  160.         $this->tags = new ArrayCollection();
  161.         $this->pageAuthors = new ArrayCollection();
  162.     }
  164.     public function getId(): ?int
  165.     {
  166.         return $this->id;
  167.     }
  169.     public function getName(): ?string
  170.     {
  171.         return $this->name;
  172.     }
  174.     public function setName(string $name): self
  175.     {
  176.         $this->name = $name;
  178.         return $this;
  179.     }
  181.     public function getContentType(): ?StdContentTypes
  182.     {
  183.         return $this->contentType;
  184.     }
  186.     public function setContentType(StdContentTypes $contentType): self
  187.     {
  188.         $this->contentType = $contentType;
  190.         return $this;
  191.     }
  193.     public function getTemplateId(): ?StdTemplates
  194.     {
  195.         return $this->templateId;
  196.     }
  198.     public function setTemplateId(?StdTemplates $templateId): self
  199.     {
  200.         $this->templateId = $templateId;
  202.         return $this;
  203.     }
  205.     public function getIsActive(): ?bool
  206.     {
  207.         return $this->isActive;
  208.     }
  210.     public function setIsActive(bool $isActive): self
  211.     {
  212.         $this->isActive = $isActive;
  214.         return $this;
  215.     }
  217.     public function getCreatedDate(): ?\DateTimeInterface
  218.     {
  219.         return $this->createdDate;
  220.     }
  222.     public function setCreatedDate(\DateTimeInterface $createdDate): self
  223.     {
  224.         $this->createdDate = $createdDate;
  226.         return $this;
  227.     }
  229.     public function getUpdatedDate(): ?\DateTimeInterface
  230.     {
  231.         return $this->updatedDate;
  232.     }
  234.     public function setUpdatedDate(\DateTimeInterface $updatedDate): self
  235.     {
  236.         $this->updatedDate = $updatedDate;
  238.         return $this;
  239.     }
  241.     public function getCreatedBy(): ?StdUsers
  242.     {
  243.         return $this->createdBy;
  244.     }
  246.     public function setCreatedBy(?StdUsers $createdBy): self
  247.     {
  248.         $this->createdBy = $createdBy;
  250.         return $this;
  251.     }
  253.     public function getUpdatedBy(): ?StdUsers
  254.     {
  255.         return $this->updatedBy;
  256.     }
  258.     public function setUpdatedBy(?StdUsers $updatedBy): self
  259.     {
  260.         $this->updatedBy = $updatedBy;
  262.         return $this;
  263.     }
  265.     public function getOrderValue(): ?int
  266.     {
  267.         return $this->orderValue;
  268.     }
  270.     public function setOrderValue(?int $orderValue): self
  271.     {
  272.         $this->orderValue = $orderValue;
  274.         return $this;
  275.     }
  277.     public function getPublishDate(): ?\DateTimeInterface
  278.     {
  279.         return $this->publishDate;
  280.     }
  282.     public function setPublishDate(\DateTimeInterface $publishDate): self
  283.     {
  284.         $this->publishDate = $publishDate;
  286.         return $this;
  287.     }
  289.     public function getLayout(): ?string
  290.     {
  291.         return $this->layout;
  292.     }
  294.     public function setLayout(?string $layout): self
  295.     {
  296.         $this->layout = $layout;
  298.         return $this;
  299.     }
  301.     public function getExpireDate(): ?\DateTimeInterface
  302.     {
  303.         return $this->expireDate;
  304.     }
  306.     public function setExpireDate(?\DateTimeInterface $expireDate): self
  307.     {
  308.         $this->expireDate = $expireDate;
  310.         return $this;
  311.     }
  313.     public function addRole(StdWebRoles $webroles): self
  314.     {
  315.         $this->webroles[] = $webroles;
  316.  
  317.         return $this;
  318.     }
  319.  
  320.     public function removeRole(StdWebRoles $webroles): bool
  321.     {
  322.         return $this->webroles->removeElement($webroles);
  323.     }
  324.  
  325.     public function getRoles(): Collection
  326.     {
  327.         return $this->webroles;
  328.     }
  330.     public function getRolesByNames(array $names): ?Collection
  331.     {
  332.         $criteria = Criteria::create()
  333.             ->where(Criteria::expr()->in("name", $names));
  334.         return $this->getRoles()->matching($criteria);
  335.     }
  338.     #[ORM\PreUpdate]
  339.     public function setUpdated()
  340.     {
  341.         $this->setUpdatedDate(new \DateTime());
  342.     }
  343.     
  344.     #[ORM\PrePersist]
  345.     public function setCreated()
  346.     {
  347.         $this->setUpdatedDate(new \DateTime());
  348.         $this->setCreatedDate(new \DateTime());
  349.     }
  351.     public function __toString() {
  352.         return $this->name;
  353.     }
  354.     /**
  355.      * @return Collection|StdPagesContent[]
  356.      */
  357.     public function getPagesContent(): ?Collection
  358.     {
  359.         return $this->pagesContent;
  360.     }
  362.     public function removePagesContent(StdPagesContent $pagescontent): self
  363.     {
  364.         if ($this->pagesContent->contains($pagescontent)) {
  365.             $this->pagesContent->removeElement($pagescontent);
  366.             // set the owning side to null (unless already changed)
  367.             if ($pagescontent->getPageId() === $this) {
  368.                 $pagescontent->setPageId(null);
  369.             }
  370.         }
  371.         return $this;
  372.     }
  374.     public function addPagesContent(StdPagesContent $pagescontent): self
  375.     {
  376.         if (!$this->pagesContent->contains($pagescontent)) {
  377.             $this->pagesContent[] = $pagescontent;
  378.             $pagescontent->setPageId($this);
  379.         }
  380.         return $this;
  381.     }
  382.     /**
  383.      * @return StdPagesContent
  384.      */
  385.     public function getLocalizedContents(StdLanguages $locale): ?StdPagesContent
  386.     {
  387.         $criteria = Criteria::create()
  388.         ->where(Criteria::expr()->eq("languageCode", $locale))
  389.         ->setMaxResults(1);
  390.         if($this->getPagesContent()){
  391.             $contents = $this->getPagesContent()->matching($criteria);
  392.             if(count($contents)){
  393.                 $contents = array_values($contents->toArray());
  394.                 return $contents[0];
  395.             }else{
  396.                 return null;
  397.             }
  398.         }else{
  399.             return null;
  400.         }
  401.     }
  403.     public function getMachineName(): ?string
  404.     {
  405.         return $this->machineName;
  406.     }
  408.     public function setMachineName(?string $machineName): self
  409.     {
  410.         $this->machineName = $machineName;
  412.         return $this;
  413.     }
  415.     public function getIncludeSitemap(): ?bool
  416.     {
  417.         return $this->includeSitemap;
  418.     }
  420.     public function setIncludeSitemap(bool $includeSitemap): self
  421.     {
  422.         $this->includeSitemap = $includeSitemap;
  424.         return $this;
  425.     }
  427.     public function addTag(StdPagesTag $tag): self
  428.     {
  429.         if (!$this->tags->contains($tag)) {
  430.             $this->tags[] = $tag;
  431.             $tag->setPage($this);
  432.         }
  434.         return $this;
  435.     }
  437.     public function removeTag(StdPagesTag $tag): self
  438.     {
  439.         if ($this->tags->removeElement($tag)) {
  440.             if ($tag->getDomainValue() === $this) {
  441.                 $tag->setDomainValue(null);
  442.             }
  443.         }
  445.         return $this;
  446.     }
  448.     public function getTags(): Collection {
  449.         return $this->tags;
  450.     }
  452.     public function addTracking(StdPagesTracking $tracking): static
  453.     {
  454.         if (!$this->trackings->contains($tracking)) {
  455.             $this->trackings[] = $tracking;
  456.             $tracking->setPage($this);
  457.         }
  459.         return $this;
  460.     }
  462.     public function removeTracking(StdPagesTracking $tracking): static
  463.     {
  464.         if ($this->trackings->removeElement($tracking)) {
  465.             if ($tracking->getPage() === $this) {
  466.                 $tracking->setPage(null);
  467.             }
  468.         }
  470.         return $this;
  471.     }
  474.     public function getApprovalStatus(): ?StdPagesApprovalStatus
  475.     {
  476.         return $this->approvalStatus;
  477.     }
  479.     public function setApprovalStatus(?StdPagesApprovalStatus $approvalStatus): void
  480.     {
  481.         $this->approvalStatus = $approvalStatus;
  483.         if ($approvalStatus !== null && $approvalStatus->getPage() !== $this) {
  484.             $approvalStatus->setPage($this);
  485.         }
  486.     }
  488.     public function getRelations(): Collection
  489.     {
  490.         return $this->relations;
  491.     }
  493.     public function setRelations(Collection $relations): void
  494.     {
  495.         $this->relations = $relations;
  496.     }
  498.     /**
  499.      * @return Collection<int, StdUsers>
  500.      */
  501.     public function getPageAuthors(): Collection
  502.     {
  503.         return $this->pageAuthors;
  504.     }
  506.     public function addPageAuthors(array $users) {
  507.         foreach ($users as $user) {
  508.             if ($user instanceof StdUsers && !$this->pageAuthors->contains($user)) {
  509.                 $this->pageAuthors->add($user);
  510.             }
  511.         }
  512.         return $this;
  513.     }
  515.     public function addPageAuthor(StdUsers $user): self
  516.     {
  517.         if (!$this->pageAuthors->contains($user)) {
  518.             $this->pageAuthors->add($user);
  519.         }
  520.         return $this;
  521.     }
  523.     public function removePageAuthor(StdUsers $user): self
  524.     {
  525.         $this->pageAuthors->removeElement($user);
  526.         return $this;
  527.     }
  529. }