src/Entity/Category.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  9. /**
  10.  * @ORM\Entity(repositoryClass="App\Repository\CategoryRepository")
  11.  *
  12.  * @ORM\HasLifecycleCallbacks()
  13.  */
  14. class Category
  15. {
  16.     public function __construct()
  17.     {
  18.         $this->menus = new ArrayCollection();
  19.         $this->channels = new ArrayCollection();
  20.         $this->children = new ArrayCollection();
  21.         $this->articleCategories = new ArrayCollection();
  22.         $this->rssFeedCategories = new ArrayCollection();
  23.         $this->userCategories = new ArrayCollection();
  24.     }
  26.     /**
  27.      * @ORM\Id()
  28.      *
  29.      * @ORM\GeneratedValue()
  30.      *
  31.      * @ORM\Column(type="integer")
  32.      */
  33.     private $id;
  35.     /**
  36.      * @ORM\Column(type="string", nullable=false, length=180)
  37.      */
  38.     private $name = null;
  40.     /**
  41.      * @ORM\Column(type="string", nullable=true, length=180)
  42.      */
  43.     private $slug;
  45.     public function getId(): ?int
  46.     {
  47.         return $this->id;
  48.     }
  50.     public function getName()
  51.     {
  52.         return $this->name;
  53.     }
  55.     public function setName($name)
  56.     {
  57.         $this->name = $name;
  59.         return $this;
  60.     }
  62.     /**
  63.      * @return mixed
  64.      */
  65.     public function getSlug()
  66.     {
  67.         return $this->slug;
  68.     }
  70.     /**
  71.      * @param mixed $slug
  72.      *
  73.      * @return Category
  74.      */
  75.     public function setSlug($slug)
  76.     {
  77.         $this->slug = $slug;
  79.         return $this;
  80.     }
  82.     /**
  83.      * @ORM\Column(type="datetime", nullable=false)
  84.      */
  85.     private $created_at;
  87.     /**
  88.      * @ORM\Column(type="datetime", nullable=true)
  89.      */
  90.     private $updated_at = null;
  92.     public function getCreatedAt()
  93.     {
  94.         return $this->created_at;
  95.     }
  97.     public function setCreatedAt($created_at)
  98.     {
  99.         $this->created_at = $created_at;
  101.         return $this;
  102.     }
  104.     public function getUpdatedAt()
  105.     {
  106.         return $this->updated_at;
  107.     }
  109.     public function setUpdatedAt($updated_at)
  110.     {
  111.         $this->updated_at = $updated_at;
  113.         return $this;
  114.     }
  116.     /**
  117.      * @ORM\PrePersist
  118.      */
  119.     public function setCreatedAtValue()
  120.     {
  121.         $this->setCreatedAt(new \DateTime());
  122.     }
  124.     /**
  125.      * @ORM\PreUpdate
  126.      */
  127.     public function setUpdatedAtValue()
  128.     {
  129.         $this->setUpdatedAt(new \DateTime());
  130.     }
  132.     /**
  133.      * @ORM\Column(type="datetime", nullable=true)
  134.      */
  135.     private $deleted_at;
  137.     /**
  138.      * @ORM\OneToMany(targetEntity="App\Entity\ChannelMenu", mappedBy="category")
  139.      */
  140.     private $menus;
  142.     /**
  143.      * @ORM\ManyToOne(targetEntity="App\Entity\Category", inversedBy="children")
  144.      *
  145.      * @ORM\JoinColumn(nullable=true)
  146.      */
  147.     private $parent;
  149.     public function getParent(): ?self
  150.     {
  151.         return $this->parent;
  152.     }
  154.     public function setParent(?self $parent): self
  155.     {
  156.         $this->parent = $parent;
  158.         return $this;
  159.     }
  161.     public function getDeletedAt(): ?\DateTimeInterface
  162.     {
  163.         return $this->deleted_at;
  164.     }
  166.     public function setDeletedAt(?\DateTimeInterface $deleted_at): self
  167.     {
  168.         $this->deleted_at = $deleted_at;
  170.         return $this;
  171.     }
  173.     /**
  174.      * @return Collection|ChannelMenu[]
  175.      */
  176.     public function getMenus(): Collection
  177.     {
  178.         return $this->menus;
  179.     }
  181.     public function addMenu(ChannelMenu $menu): self
  182.     {
  183.         if (!$this->menus->contains($menu)) {
  184.             $this->menus[] = $menu;
  185.             $menu->setCategory($this);
  186.         }
  188.         return $this;
  189.     }
  191.     public function removeMenu(ChannelMenu $menu): self
  192.     {
  193.         if ($this->menus->contains($menu)) {
  194.             $this->menus->removeElement($menu);
  195.             // set the owning side to null (unless already changed)
  196.             if ($menu->getCategory() === $this) {
  197.                 $menu->setCategory(null);
  198.             }
  199.         }
  201.         return $this;
  202.     }
  204.     /**
  205.      * @ORM\OneToMany(targetEntity="App\Entity\ChannelCategory", mappedBy="category")
  206.      */
  207.     private $channels;
  209.     /**
  210.      * @return Collection|ChannelCategory[]
  211.      */
  212.     public function getChannels(): Collection
  213.     {
  214.         return $this->channels;
  215.     }
  217.     public function addChannel(ChannelCategory $channel): self
  218.     {
  219.         if (!$this->channels->contains($channel)) {
  220.             $this->channels[] = $channel;
  221.             $channel->setCategory($this);
  222.         }
  224.         return $this;
  225.     }
  227.     public function removeChannel(ChannelCategory $channel): self
  228.     {
  229.         if ($this->channels->contains($channel)) {
  230.             $this->channels->removeElement($channel);
  231.             // set the owning side to null (unless already changed)
  232.             if ($channel->getCategory() === $this) {
  233.                 $channel->setCategory(null);
  234.             }
  235.         }
  237.         return $this;
  238.     }
  240.     /**
  241.      * @ORM\OneToMany(targetEntity="App\Entity\Category", mappedBy="parent")
  242.      */
  243.     private $children;
  245.     /**
  246.      * @ORM\OneToMany(targetEntity="App\Entity\ArticleCategory", mappedBy="category")
  247.      */
  248.     private $articleCategories;
  250.     /**
  251.      * @ORM\OneToMany(targetEntity="App\Entity\RssFeedCategory", mappedBy="category")
  252.      */
  253.     private $rssFeedCategories;
  255.     /**
  256.      * @ORM\OneToMany(targetEntity="App\Entity\NewsletterCategory", mappedBy="category")
  257.      */
  258.     private $newsletterCategories;
  260.     /**
  261.      * @ORM\OneToMany(targetEntity="App\Entity\UserCategory", mappedBy="category")
  262.      */
  263.     private $userCategories;
  265.     /**
  266.      * @ORM\Column(type="string", length=255, nullable=true)
  267.      */
  268.     private $color;
  270.     /**
  271.      * @ORM\Column(type="integer", nullable=true)
  272.      */
  273.     private $legacy_id;
  275.     /**
  276.      * @return Collection|Category[]
  277.      */
  278.     public function getChildren(): Collection
  279.     {
  280.         return $this->children;
  281.     }
  283.     public function addCategory(self $category): self
  284.     {
  285.         if (!$this->children->contains($category)) {
  286.             $this->children[] = $category;
  287.             $category->setParent($this);
  288.         }
  290.         return $this;
  291.     }
  293.     public function removeCategory(self $category): self
  294.     {
  295.         if ($this->children->contains($category)) {
  296.             $this->children->removeElement($category);
  297.             if ($category->getParent() === $this) {
  298.                 $category->setParent(null);
  299.             }
  300.         }
  302.         return $this;
  303.     }
  305.     /**
  306.      * @return Collection|ArticleCategory[]
  307.      */
  308.     public function getArticleCategories(): Collection
  309.     {
  310.         return $this->articleCategories;
  311.     }
  313.     public function addArticleCategory(ArticleCategory $articleCategory): self
  314.     {
  315.         if (!$this->articleCategories->contains($articleCategory)) {
  316.             $this->articleCategories[] = $articleCategory;
  317.             $articleCategory->setCategory($this);
  318.         }
  320.         return $this;
  321.     }
  323.     public function removeArticleCategory(ArticleCategory $articleCategory): self
  324.     {
  325.         if ($this->articleCategories->contains($articleCategory)) {
  326.             $this->articleCategories->removeElement($articleCategory);
  327.             // set the owning side to null (unless already changed)
  328.             if ($articleCategory->getCategory() === $this) {
  329.                 $articleCategory->setCategory(null);
  330.             }
  331.         }
  333.         return $this;
  334.     }
  336.     /**
  337.      * @return Collection|RssFeedCategory[]
  338.      */
  339.     public function getRssFeedCategories(): Collection
  340.     {
  341.         return $this->rssFeedCategories;
  342.     }
  344.     public function addRssFeedCategory(RssFeedCategory $rssFeedCategory): self
  345.     {
  346.         if (!$this->rssFeedCategories->contains($rssFeedCategory)) {
  347.             $this->rssFeedCategories[] = $rssFeedCategory;
  348.             $rssFeedCategory->setCategory($this);
  349.         }
  351.         return $this;
  352.     }
  354.     public function removeRssFeedCategory(RssFeedCategory $rssFeedCategory): self
  355.     {
  356.         if ($this->rssFeedCategories->contains($rssFeedCategory)) {
  357.             $this->rssFeedCategories->removeElement($rssFeedCategory);
  358.             // set the owning side to null (unless already changed)
  359.             if ($rssFeedCategory->getCategory() === $this) {
  360.                 $rssFeedCategory->setCategory(null);
  361.             }
  362.         }
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return Collection|UserCategory[]
  369.      */
  370.     public function getUserCategoriesCategories(): Collection
  371.     {
  372.         return $this->userCategories;
  373.     }
  375. //    public function addUserCategorieseCategory(UserCategory $userCategory): self
  376. //    {
  377. //        if (!$this->userCategories->contains($userCategory)) {
  378. //            $this->userCategories[] = $userCategory;
  379. //            $userCategory->setCategory($this);
  380. //        }
  381. //
  382. //        return $this;
  383. //    }
  384. //
  385. //    public function removeUserCategory(UserCategory $userCategory): self
  386. //    {
  387. //        if ($this->userCategories->contains($userCategory)) {
  388. //            $this->userCategories->removeElement($userCategory);
  389. //            // set the owning side to null (unless already changed)
  390. //            if ($userCategory->getCategory() === $this) {
  391. //                $userCategory->setCategory(null);
  392. //            }
  393. //        }
  394. //
  395. //        return $this;
  396. //    }
  398.     /**
  399.      * @return Collection|NewsletterCategory[]
  400.      */
  401.     public function getNewsletterCategories(): Collection
  402.     {
  403.         return $this->newsletterCategories;
  404.     }
  406.     public function addNewsletterCategory(NewsletterCategory $newsletterCategory): self
  407.     {
  408.         if (!$this->newsletterCategories->contains($newsletterCategory)) {
  409.             $this->newsletterCategories[] = $newsletterCategory;
  410.             $newsletterCategory->setCategory($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeNewsletterCategory(NewsletterCategory $newsletterCategory): self
  417.     {
  418.         if ($this->newsletterCategories->contains($newsletterCategory)) {
  419.             $this->newsletterCategories->removeElement($newsletterCategory);
  420.             // set the owning side to null (unless already changed)
  421.             if ($newsletterCategory->getCategory() === $this) {
  422.                 $newsletterCategory->setCategory(null);
  423.             }
  424.         }
  426.         return $this;
  427.     }
  429.     public function getColor(): ?string
  430.     {
  431.         return $this->color;
  432.     }
  434.     public function setColor(?string $color): self
  435.     {
  436.         $this->color = $color;
  438.         return $this;
  439.     }
  441.     public function getLegacyId(): ?int
  442.     {
  443.         return $this->legacy_id;
  444.     }
  446.     public function setLegacyId(?int $legacy_id): self
  447.     {
  448.         $this->legacy_id = $legacy_id;
  450.         return $this;
  451.     }
  452. }