src/Entity/EditionTemplate.php line 14

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\Table(name="edition_template",    indexes={@ORM\Index(name="edition_template_key", columns={"key"})})
  11.  * @ORM\Entity (repositoryClass="App\Repository\EditionTemplateRepository")
  12.  */
  14. class EditionTemplate
  15. {
  16.     /**
  17.      * @ORM\Id()
  18.      * @ORM\GeneratedValue()
  19.      * @ORM\Column(type="integer")
  20.      */
  21.     private $id;
  22.     /**
  23.      * @ORM\Column(type="string", length=255, nullable=true, options={"comment":"Nom du template"})
  24.      */
  25.     private $name;
  27.     /**
  28.      * @ORM\Column(type="string", length=255, nullable=true, options={"comment":"Clé du template"})
  29.      */
  30.     private $key;
  32.     /**
  33.      * @ORM\Column(type="string", length=255, nullable=true, options={"comment":"URL du fichier CSS du template"})
  34.      */
  35.     private $urlCss;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true, options={"comment":"Dossier de rangement du template"})
  39.      */
  40.     private $templateFolder;
  42.     /**
  43.      * @ORM\Column(type="string", length=1024, nullable=true, options={"comment":"Chemin du service"})
  44.      */
  45.     private $serviceName;
  46.     /**
  47.      * @ORM\Column(type="boolean", nullable=false, options={"default":true})
  48.      */
  49.     private $visibleForAll;
  50.     /**
  51.      * @var \Doctrine\Common\Collections\Collection
  52.      *
  53.      * @ORM\ManyToMany(targetEntity="App\Entity\DnsitEntity")
  54.      * @ORM\JoinTable(name="edition_template_entity",
  55.      *      joinColumns={@ORM\JoinColumn(name="template_id", referencedColumnName="id")},
  56.      *      inverseJoinColumns={@ORM\JoinColumn(name="entity_id", referencedColumnName="id")}
  57.      *      )
  58.      */
  59.     private $authorizedEntities;
  60.     /**
  61.      * @ORM\Column(type="string", length=1024, nullable=true, options={"comment":"Chemin de la documentation"})
  62.      */
  63.     private $documentation;
  64.     /**
  65.      * @ORM\Column(type="string", length=1024, nullable=true, options={"comment":"Chemin du thumbnail"})
  66.      */
  67.     private $thumbnail;
  68.     /**
  69.      * @ORM\Column(type="json", nullable=true, options={"comment":"Parametres techniques"})
  70.      */
  71.     private $params;
  72.     /**
  73.      * @var \Doctrine\Common\Collections\Collection
  74.      *
  75.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplateParameterGroup", mappedBy="template", cascade={"persist","remove"})
  76.      * @ORM\OrderBy({"ordering" = "ASC"})
  77.      */
  78.     private $parameterGroups;
  79.     /**
  80.      * @var \Doctrine\Common\Collections\Collection
  81.      *
  82.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplateGabarit", mappedBy="template", cascade={"persist","remove"}, orphanRemoval=true)
  83.      * @ORM\OrderBy({"ordering" = "ASC"})
  84.      */
  85.     private $gabarits;
  86.     /**
  87.      * @var \Doctrine\Common\Collections\Collection
  88.      *
  89.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplateTetiere", mappedBy="template", cascade={"persist","remove"}, orphanRemoval=true)
  90.      * @ORM\OrderBy({"ordering" = "ASC"})
  91.      */
  92.     private $tetieres;
  93.     /**
  94.      * @var \Doctrine\Common\Collections\Collection
  95.      *
  96.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplateEntete", mappedBy="template", cascade={"persist","remove"}, orphanRemoval=true)
  97.      * @ORM\OrderBy({"ordering" = "ASC"})
  98.      */
  99.     private $entetes;
  100.     /**
  101.      * @var \Doctrine\Common\Collections\Collection
  102.      *
  103.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplatePied", mappedBy="template", cascade={"persist","remove"}, orphanRemoval=true)
  104.      * @ORM\OrderBy({"ordering" = "ASC"})
  105.      */
  106.     private $pieds;
  107.     /**
  108.      * @var \Doctrine\Common\Collections\Collection
  109.      *
  110.      * @ORM\OneToMany(targetEntity="App\Entity\EditionTemplateVariant", mappedBy="template", cascade={"persist","remove"})
  111.      * @ORM\OrderBy({"ordering" = "ASC"})
  112.      */
  113.     private $variants;
  114.     /**
  115.      * @var \Doctrine\Common\Collections\Collection
  116.      *
  117.      * @ORM\OneToMany(targetEntity="App\Entity\EditionModele", mappedBy="template", cascade={"persist","remove"})
  118.      */
  119.     private $modeles;
  121.     /**
  122.      * @var \Doctrine\Common\Collections\Collection
  123.      *
  124.      * @ORM\OneToMany(targetEntity="App\Entity\EditionModeleRubriqueDynamiqueModele", mappedBy="template", cascade={"persist","remove"})
  125.      */
  126.     private $modeleRubriqueDynamiqueModeles;
  128.     /**
  129.      * @ORM\ManyToMany(targetEntity="App\Entity\CustomCode", mappedBy="editionTemplates")
  130.      */
  131.     private $customCodes;
  133.     public function __construct()
  134.     {
  135.         $this->authorizedEntities = new ArrayCollection();
  136.         $this->parameterGroups = new ArrayCollection();
  137.         $this->gabarits = new ArrayCollection();
  138.         $this->tetieres = new ArrayCollection();
  139.         $this->entetes = new ArrayCollection();
  140.         $this->pieds = new ArrayCollection();
  141.         $this->modeles = new ArrayCollection();
  142.         $this->modeleRubriqueDynamiqueModeles = new ArrayCollection();
  143.         $this->variants = new ArrayCollection();
  144.         $this->customCodes = new ArrayCollection();
  145.     }
  146.     public function getId() : ?int
  147.     {
  148.         return $this->id;
  149.     }
  150.     public function getName() : ?string
  151.     {
  152.         return $this->name;
  153.     }
  154.     public function setName(?string $name) : self
  155.     {
  156.         $this->name = $name;
  157.         return $this;
  158.     }
  159.     public function getKey() : ?string
  160.     {
  161.         return $this->key;
  162.     }
  163.     public function setKey(?string $key) : self
  164.     {
  165.         $this->key = $key;
  166.         return $this;
  167.     }
  168.     public function getUrlCss() : ?string
  169.     {
  170.         return $this->urlCss;
  171.     }
  172.     public function setUrlCss(?string $url) : self
  173.     {
  174.         $this->urlCss = $url;
  175.         return $this;
  176.     }
  177.     public function getTemplateFolder() : ?string
  178.     {
  179.         return $this->templateFolder;
  180.     }
  181.     public function setTemplateFolder(?string $folder) : self
  182.     {
  183.         $this->templateFolder = $folder;
  184.         return $this;
  185.     }
  186.     public function getServiceName() : ?string
  187.     {
  188.         return $this->serviceName;
  189.     }
  190.     public function setServiceName(?string $serviceName) : self
  191.     {
  192.         $this->serviceName = $serviceName;
  193.         return $this;
  194.     }
  195.     public function getVisibleForAll() : ?bool
  196.     {
  197.         return $this->visibleForAll;
  198.     }
  199.     public function setVisibleForAll(bool $visibleForAll) : self
  200.     {
  201.         $this->visibleForAll = $visibleForAll;
  202.         return $this;
  203.     }
  204.     /**
  205.      * @return Collection|DnsitEntity[]
  206.      */
  207.     public function getAuthorizedEntities() : Collection
  208.     {
  209.         return $this->authorizedEntities;
  210.     }
  211.     public function addAuthorizedEntity(DnsitEntity $authorizedEntity) : self
  212.     {
  213.         if (!$this->authorizedEntities->contains($authorizedEntity)) {
  214.             $this->authorizedEntities[] = $authorizedEntity;
  215.         }
  216.         return $this;
  217.     }
  218.     public function removeAuthorizedEntity(DnsitEntity $authorizedEntity) : self
  219.     {
  220.         if ($this->authorizedEntities->contains($authorizedEntity)) {
  221.             $this->authorizedEntities->removeElement($authorizedEntity);
  222.         }
  223.         return $this;
  224.     }
  225.     public function getDocumentation() : ?string
  226.     {
  227.         return $this->documentation;
  228.     }
  229.     public function setDocumentation(?string $documentation) : self
  230.     {
  231.         $this->documentation = $documentation;
  232.         return $this;
  233.     }
  234.     public function getThumbnail() : ?string
  235.     {
  236.         return $this->thumbnail;
  237.     }
  238.     public function setThumbnail(?string $thumbnail) : self
  239.     {
  240.         $this->thumbnail = $thumbnail;
  241.         return $this;
  242.     }
  243.     /**
  244.      * @return Collection|EditionTemplateParameterGroup[]
  245.      */
  246.     public function getParameterGroups() : Collection
  247.     {
  248.         return $this->parameterGroups;
  249.     }
  250.     public function addParameterGroup(EditionTemplateParameterGroup $parameterGroup) : self
  251.     {
  252.         if (!$this->parameterGroups->contains($parameterGroup)) {
  253.             $this->parameterGroups[] = $parameterGroup;
  254.             $parameterGroup->setTemplate($this);
  255.         }
  256.         return $this;
  257.     }
  258.     public function removeParameterGroup(EditionTemplateParameterGroup $parameterGroup) : self
  259.     {
  260.         if ($this->parameterGroups->contains($parameterGroup)) {
  261.             $this->parameterGroups->removeElement($parameterGroup);
  262.             // set the owning side to null (unless already changed)
  263.             if ($parameterGroup->getTemplate() === $this) {
  264.                 $parameterGroup->setTemplate(null);
  265.             }
  266.         }
  267.         return $this;
  268.     }
  269.     /**
  270.      * @return Collection|EditionTemplateGabarit[]
  271.      */
  272.     public function getGabarits() : Collection
  273.     {
  274.         return $this->gabarits;
  275.     }
  276.     public function addGabarit(EditionTemplateGabarit $gabarit) : self
  277.     {
  278.         if (!$this->gabarits->contains($gabarit)) {
  279.             $this->gabarits[] = $gabarit;
  280.             $gabarit->setTemplate($this);
  281.         }
  282.         return $this;
  283.     }
  284.     public function removeGabarit(EditionTemplateGabarit $gabarit) : self
  285.     {
  286.         if ($this->gabarits->contains($gabarit)) {
  287.             $this->gabarits->removeElement($gabarit);
  288.             // set the owning side to null (unless already changed)
  289.             if ($gabarit->getTemplate() === $this) {
  290.                 $gabarit->setTemplate(null);
  291.             }
  292.         }
  293.         return $this;
  294.     }
  295.     /**
  296.      * @return Collection|EditionTemplateTetiere[]
  297.      */
  298.     public function getTetieres() : Collection
  299.     {
  300.         return $this->tetieres;
  301.     }
  302.     public function addTetiere(EditionTemplateTetiere $tetiere) : self
  303.     {
  304.         if (!$this->tetieres->contains($tetiere)) {
  305.             $this->tetieres[] = $tetiere;
  306.             $tetiere->setTemplate($this);
  307.         }
  308.         return $this;
  309.     }
  310.     public function removeTetiere(EditionTemplateTetiere $tetiere) : self
  311.     {
  312.         if ($this->tetieres->contains($tetiere)) {
  313.             $this->tetieres->removeElement($tetiere);
  314.             // set the owning side to null (unless already changed)
  315.             if ($tetiere->getTemplate() === $this) {
  316.                 $tetiere->setTemplate(null);
  317.             }
  318.         }
  319.         return $this;
  320.     }
  321.     /**
  322.      * @return Collection|EditionTemplateEntete[]
  323.      */
  324.     public function getEntetes() : Collection
  325.     {
  326.         return $this->entetes;
  327.     }
  328.     public function addEntete(EditionTemplateEntete $entete) : self
  329.     {
  330.         if (!$this->entetes->contains($entete)) {
  331.             $this->entetes[] = $entete;
  332.             $entete->setTemplate($this);
  333.         }
  334.         return $this;
  335.     }
  336.     public function removeEntete(EditionTemplateEntete $entete) : self
  337.     {
  338.         if ($this->entetes->contains($entete)) {
  339.             $this->entetes->removeElement($entete);
  340.             // set the owning side to null (unless already changed)
  341.             if ($entete->getTemplate() === $this) {
  342.                 $entete->setTemplate(null);
  343.             }
  344.         }
  345.         return $this;
  346.     }
  347.     /**
  348.      * @return Collection|EditionTemplatePied[]
  349.      */
  350.     public function getPieds() : Collection
  351.     {
  352.         return $this->pieds;
  353.     }
  354.     public function addPied(EditionTemplatePied $pied) : self
  355.     {
  356.         if (!$this->pieds->contains($pied)) {
  357.             $this->pieds[] = $pied;
  358.             $pied->setTemplate($this);
  359.         }
  360.         return $this;
  361.     }
  362.     public function removePied(EditionTemplatePied $pied) : self
  363.     {
  364.         if ($this->pieds->contains($pied)) {
  365.             $this->pieds->removeElement($pied);
  366.             // set the owning side to null (unless already changed)
  367.             if ($pied->getTemplate() === $this) {
  368.                 $pied->setTemplate(null);
  369.             }
  370.         }
  371.         return $this;
  372.     }
  373.     /**
  374.      * @return Collection|EditionModele[]
  375.      */
  376.     public function getModeles() : Collection
  377.     {
  378.         return $this->modeles;
  379.     }
  380.     public function addModele(EditionModele $modele) : self
  381.     {
  382.         if (!$this->modeles->contains($modele)) {
  383.             $this->modeles[] = $modele;
  384.             $modele->setTemplate($this);
  385.         }
  386.         return $this;
  387.     }
  388.     public function removeModele(EditionModele $modele) : self
  389.     {
  390.         if ($this->modeles->contains($modele)) {
  391.             $this->modeles->removeElement($modele);
  392.             // set the owning side to null (unless already changed)
  393.             if ($modele->getTemplate() === $this) {
  394.                 $modele->setTemplate(null);
  395.             }
  396.         }
  397.         return $this;
  398.     }
  399.     /**
  400.      * @return Collection|EditionModeleRubriqueDynamiqueModele[]
  401.      */
  402.     public function getModeleRubriqueDynamiqueModeles() : Collection
  403.     {
  404.         return $this->modeleRubriqueDynamiqueModeles;
  405.     }
  406.     public function addModeleRubriqueDynamiqueModele(EditionModeleRubriqueDynamiqueModele $modeleRubrique) : self
  407.     {
  408.         if (!$this->modeleRubriqueDynamiqueModeles->contains($modeleRubrique)) {
  409.             $this->modeleRubriqueDynamiqueModeles[] = $modeleRubrique;
  410.             $modeleRubrique->setTemplate($this);
  411.         }
  412.         return $this;
  413.     }
  414.     public function removeModeleRubriqueDynamiqueModele(EditionModeleRubriqueDynamiqueModele $modeleRubrique) : self
  415.     {
  416.         if ($this->modeleRubriqueDynamiqueModeles->contains($modeleRubrique)) {
  417.             $this->modeleRubriqueDynamiqueModeles->removeElement($modeleRubrique);
  418.             // set the owning side to null (unless already changed)
  419.             if ($modeleRubrique->getTemplate() === $this) {
  420.                 $modeleRubrique->setTemplate(null);
  421.             }
  422.         }
  423.         return $this;
  424.     }
  425.     /**
  426.      * @return Collection|EditionTemplateVariant[]
  427.      */
  428.     public function getVariants() : Collection
  429.     {
  430.         return $this->variants;
  431.     }
  432.     public function addVariant(EditionTemplateVariant $variant) : self
  433.     {
  434.         if (!$this->variants->contains($variant)) {
  435.             $this->variants[] = $variant;
  436.             $variant->setTemplate($this);
  437.         }
  438.         return $this;
  439.     }
  440.     public function removeVariant(EditionTemplateVariant $variant) : self
  441.     {
  442.         if ($this->variants->contains($variant)) {
  443.             $this->variants->removeElement($variant);
  444.             // set the owning side to null (unless already changed)
  445.             if ($variant->getTemplate() === $this) {
  446.                 $variant->setTemplate(null);
  447.             }
  448.         }
  449.         return $this;
  450.     }
  451.     public function getParams() : ?array
  452.     {
  453.         return $this->params;
  454.     }
  455.     public function setParams(?array $params) : self
  456.     {
  457.         $this->params = $params;
  458.         return $this;
  459.     }
  460.     /**
  461.      * @return Collection|CustomCode[]
  462.      */
  463.     public function getCustomCodes () : Collection
  464.     {
  465.         return $this->customCodes;
  466.     }
  467.     public function addCustomCode (CustomCode $code) : self
  468.     {
  469.         if (!$this->customCodes->contains($code)) {
  470.             $this->customCodes[] = $code;
  471.         }
  472.         return $this;
  473.     }
  474.     public function removeCustomCode(CustomCode $code) : self
  475.     {
  476.         if ($this->customCodes->contains($code)) {
  477.             $this->customCodes->removeElement($code);
  478.         }
  479.         return $this;
  480.     }
  481. }