src/Entity/Tag.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. /**
  10.  * @ORM\Entity (repositoryClass="App\Repository\TagRepository")
  11.  */
  13. class Tag
  14. {
  15.     public function __construct()
  16.     {
  17.         $this->selections = new ArrayCollection();
  18.         $this->blocks = new ArrayCollection();
  19.         $this->sorts = new ArrayCollection();
  20.         $this->webEngines = new ArrayCollection();
  21.         $this->webPages = new ArrayCollection();
  22.         $this->webLists = new ArrayCollection();
  23.         $this->listModels = new ArrayCollection();
  24.         $this->webFilters = new ArrayCollection();
  25.         $this->scoringProfiles = new ArrayCollection();
  26.         $this->diaporama = new ArrayCollection();
  27.         $this->webMaps = new ArrayCollection();
  28.     }
  29.     /**
  30.      * @ORM\Id()
  31.      * @ORM\GeneratedValue()
  32.      * @ORM\Column(type="integer")
  33.      */
  34.     private $id;
  35.     /**
  36.      * @ORM\Column(type="string", length=255)
  37.      */
  38.     private $name;
  39.     /**
  40.      * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="tags")
  41.      * @ORM\JoinColumns({
  42.      *   @ORM\JoinColumn(name="owner_id", referencedColumnName="id")
  43.      * })
  44.      */
  45.     private $owner;
  46.     /**
  47.      * @ORM\ManyToOne(targetEntity="App\Entity\DnsitEntity", inversedBy="tags")
  48.      * @ORM\JoinColumns({
  49.      *   @ORM\JoinColumn(name="entity_id", referencedColumnName="id")
  50.      * })
  51.      */
  52.     private $entity;
  53.     /**
  54.      * @ORM\ManyToMany(targetEntity="App\Entity\Selection", mappedBy="tags")
  55.      */
  56.     private $selections;
  57.     /**
  58.      * @ORM\ManyToMany(targetEntity="App\Entity\Block", mappedBy="tags")
  59.      */
  60.     private $blocks;
  61.     /**
  62.      * @ORM\ManyToMany(targetEntity="App\Entity\WebSort", mappedBy="tags")
  63.      */
  64.     private $sorts;
  65.     /**
  66.      * @ORM\ManyToMany(targetEntity="App\Entity\WebEngine", mappedBy="tags")
  67.      */
  68.     private $webEngines;
  69.     /**
  70.      * @ORM\ManyToMany(targetEntity="App\Entity\WebPage", mappedBy="tags")
  71.      */
  72.     private $webPages;
  73.     /**
  74.      * @ORM\ManyToMany(targetEntity="App\Entity\WebList", mappedBy="tags")
  75.      */
  76.     private $webLists;
  77.     /**
  78.      * @ORM\ManyToMany(targetEntity="App\Entity\ListModel", mappedBy="tags")
  79.      */
  80.     private $listModels;
  81.     /**
  82.      * @ORM\ManyToMany(targetEntity="App\Entity\WebFilter", mappedBy="tags")
  83.      */
  84.     private $webFilters;
  85.     /**
  86.      * @ORM\ManyToMany(targetEntity="App\Entity\DnsitScoringProfile", mappedBy="tags")
  87.      */
  88.     private $scoringProfiles;
  89.     /**
  90.      * @ORM\Column(type="datetime", nullable=true)
  91.      */
  92.     private $createdAt;
  93.     /**
  94.      * @ORM\Column(type="datetime", nullable=true)
  95.      */
  96.     private $updatedAt;
  97.     /**
  98.      * @ORM\ManyToMany(targetEntity="App\Entity\Diaporama", mappedBy="tags")
  99.      */
  100.     private $diaporama;
  101.     /**
  102.      * @ORM\ManyToMany(targetEntity="App\Entity\WebMap", mappedBy="tags")
  103.      */
  104.     private $webMaps;
  105.     public function getId() : ?int
  106.     {
  107.         return $this->id;
  108.     }
  109.     public function getName() : ?string
  110.     {
  111.         return $this->name;
  112.     }
  113.     public function setName(string $name) : self
  114.     {
  115.         $this->name = $name;
  116.         return $this;
  117.     }
  118.     public function getOwner() : ?User
  119.     {
  120.         return $this->owner;
  121.     }
  122.     public function setOwner(?User $owner) : self
  123.     {
  124.         $this->owner = $owner;
  125.         return $this;
  126.     }
  127.     public function getEntity() : ?DnsitEntity
  128.     {
  129.         return $this->entity;
  130.     }
  131.     public function setEntity(?DnsitEntity $entity) : self
  132.     {
  133.         $this->entity = $entity;
  134.         return $this;
  135.     }
  136.     public function getCreatedAt() : ?\DateTimeInterface
  137.     {
  138.         return $this->createdAt;
  139.     }
  140.     public function setCreatedAt(\DateTimeInterface $createdAt) : self
  141.     {
  142.         $this->createdAt = $createdAt;
  143.         return $this;
  144.     }
  145.     public function getUpdatedAt() : ?\DateTimeInterface
  146.     {
  147.         return $this->updatedAt;
  148.     }
  149.     public function setUpdatedAt(?\DateTimeInterface $updatedAt) : self
  150.     {
  151.         $this->updatedAt = $updatedAt;
  152.         return $this;
  153.     }
  154.     /**
  155.      * @return Collection|Selection[]
  156.      */
  157.     public function getSelections() : Collection
  158.     {
  159.         return $this->selections;
  160.     }
  161.     public function addSelection(Selection $selection) : self
  162.     {
  163.         if (!$this->selections->contains($selection)) {
  164.             $this->selections[] = $selection;
  165.             $selection->addTag($this);
  166.         }
  167.         return $this;
  168.     }
  169.     public function removeSelection(Selection $selection) : self
  170.     {
  171.         if ($this->selections->contains($selection)) {
  172.             $this->selections->removeElement($selection);
  173.             $selection->removeTag($this);
  174.         }
  175.         return $this;
  176.     }
  177.     /**
  178.      * @return Collection|Block[]
  179.      */
  180.     public function getBlocks() : Collection
  181.     {
  182.         return $this->blocks;
  183.     }
  184.     public function addBlock(Block $block) : self
  185.     {
  186.         if (!$this->blocks->contains($block)) {
  187.             $this->blocks[] = $block;
  188.             $block->addTag($this);
  189.         }
  190.         return $this;
  191.     }
  192.     public function removeBlock(Block $block) : self
  193.     {
  194.         if ($this->blocks->contains($block)) {
  195.             $this->blocks->removeElement($block);
  196.             $block->removeTag($this);
  197.         }
  198.         return $this;
  199.     }
  200.     /**
  201.      * @return Collection|WebSort[]
  202.      */
  203.     public function getSorts() : Collection
  204.     {
  205.         return $this->sorts;
  206.     }
  207.     public function addSort(WebSort $sort) : self
  208.     {
  209.         if (!$this->sorts->contains($sort)) {
  210.             $this->sorts[] = $sort;
  211.             $sort->addTag($this);
  212.         }
  213.         return $this;
  214.     }
  215.     public function removeSort(WebSort $sort) : self
  216.     {
  217.         if ($this->sorts->contains($sort)) {
  218.             $this->sorts->removeElement($sort);
  219.             $sort->removeTag($this);
  220.         }
  221.         return $this;
  222.     }
  223.     /**
  224.      * @return Collection|WebEngine[]
  225.      */
  226.     public function getWebEngines() : Collection
  227.     {
  228.         return $this->webEngines;
  229.     }
  230.     public function addWebEngine(WebEngine $engine) : self
  231.     {
  232.         if (!$this->webEngines->contains($engine)) {
  233.             $this->webEngines[] = $engine;
  234.             $engine->addTag($this);
  235.         }
  236.         return $this;
  237.     }
  238.     public function removeWebEngine(WebEngine $engine) : self
  239.     {
  240.         if ($this->webEngines->contains($engine)) {
  241.             $this->webEngines->removeElement($engine);
  242.             $engine->removeTag($this);
  243.         }
  244.         return $this;
  245.     }
  246.     /**
  247.      * @return Collection|WebPage[]
  248.      */
  249.     public function getWebPages() : Collection
  250.     {
  251.         return $this->webPages;
  252.     }
  253.     public function addWebPage(WebPage $webPage) : self
  254.     {
  255.         if (!$this->webPages->contains($webPage)) {
  256.             $this->webPages[] = $webPage;
  257.             $webPage->addTag($this);
  258.         }
  259.         return $this;
  260.     }
  261.     public function removeWebPage(WebPage $webPage) : self
  262.     {
  263.         if ($this->webPages->contains($webPage)) {
  264.             $this->webPages->removeElement($webPage);
  265.             $webPage->removeTag($this);
  266.         }
  267.         return $this;
  268.     }
  269.     /**
  270.      * @return Collection|WebList[]
  271.      */
  272.     public function getWebLists() : Collection
  273.     {
  274.         return $this->webLists;
  275.     }
  276.     public function addWebList(WebList $webList) : self
  277.     {
  278.         if (!$this->webLists->contains($webList)) {
  279.             $this->webLists[] = $webList;
  280.             $webList->addTag($this);
  281.         }
  282.         return $this;
  283.     }
  284.     public function removeWebList(WebList $webList) : self
  285.     {
  286.         if ($this->webLists->contains($webList)) {
  287.             $this->webLists->removeElement($webList);
  288.             $webList->removeTag($this);
  289.         }
  290.         return $this;
  291.     }
  292.     /**
  293.      * @return Collection|ListModel[]
  294.      */
  295.     public function getListModels() : Collection
  296.     {
  297.         return $this->listModels;
  298.     }
  299.     public function addListModel(ListModel $listModel) : self
  300.     {
  301.         if (!$this->listModels->contains($listModel)) {
  302.             $this->listModels[] = $listModel;
  303.             $listModel->addTag($this);
  304.         }
  305.         return $this;
  306.     }
  307.     public function removeListModel(ListModel $listModel) : self
  308.     {
  309.         if ($this->listModels->contains($listModel)) {
  310.             $this->listModels->removeElement($listModel);
  311.             $listModel->removeTag($this);
  312.         }
  313.         return $this;
  314.     }
  315.     /**
  316.      * @return Collection|WebFilter[]
  317.      */
  318.     public function getWebFilters() : Collection
  319.     {
  320.         return $this->webFilters;
  321.     }
  322.     public function addWebFilter(WebFilter $webFilter) : self
  323.     {
  324.         if (!$this->webFilters->contains($webFilter)) {
  325.             $this->webFilters[] = $webFilter;
  326.             $webFilter->addTag($this);
  327.         }
  328.         return $this;
  329.     }
  330.     public function removeWebFilter(WebFilter $webFilter) : self
  331.     {
  332.         if ($this->webFilters->contains($webFilter)) {
  333.             $this->webFilters->removeElement($webFilter);
  334.             $webFilter->removeTag($this);
  335.         }
  336.         return $this;
  337.     }
  338.     /**
  339.      * @return Collection|DnsitScoringProfile[]
  340.      */
  341.     public function getScoringProfiles() : Collection
  342.     {
  343.         return $this->scoringProfiles;
  344.     }
  345.     public function addScoringProfile(DnsitScoringProfile $scoringProfile) : self
  346.     {
  347.         if (!$this->scoringProfiles->contains($scoringProfile)) {
  348.             $this->scoringProfiles[] = $scoringProfile;
  349.             $scoringProfile->addTag($this);
  350.         }
  351.         return $this;
  352.     }
  353.     public function removeScoringProfile(DnsitScoringProfile $scoringProfile) : self
  354.     {
  355.         if ($this->scoringProfiles->contains($scoringProfile)) {
  356.             $this->scoringProfiles->removeElement($scoringProfile);
  357.             $scoringProfile->removeTag($this);
  358.         }
  359.         return $this;
  360.     }
  361.     /**
  362.      * @return Collection|Diaporama[]
  363.      */
  364.     public function getDiaporama() : Collection
  365.     {
  366.         return $this->diaporama;
  367.     }
  368.     public function addDiaporama(Diaporama $diaporama) : self
  369.     {
  370.         if (!$this->diaporama->contains($diaporama)) {
  371.             $this->diaporama[] = $diaporama;
  372.             $diaporama->addTag($this);
  373.         }
  374.         return $this;
  375.     }
  376.     public function removeDiaporama(Diaporama $diaporama) : self
  377.     {
  378.         if ($this->diaporama->contains($diaporama)) {
  379.             $this->diaporama->removeElement($diaporama);
  380.             $diaporama->removeTag($this);
  381.         }
  382.         return $this;
  383.     }
  384.     /**
  385.      * @return Collection|WebMap[]
  386.      */
  387.     public function getWebMaps() : Collection
  388.     {
  389.         return $this->webMaps;
  390.     }
  391.     public function addWebMap(WebMap $webMap) : self
  392.     {
  393.         if (!$this->webMaps->contains($webMap)) {
  394.             $this->webMaps[] = $webMap;
  395.             $webMap->addTag($this);
  396.         }
  397.         return $this;
  398.     }
  399.     public function removeWebMap(WebMap $webMap) : self
  400.     {
  401.         if ($this->webMaps->contains($webMap)) {
  402.             $this->webMaps->removeElement($webMap);
  403.             $webMap->removeTag($this);
  404.         }
  405.         return $this;
  406.     }
  407. }