src/Entity/Site.php line 25

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\SiteRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\HttpFoundation\File\File;
  10. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Validator\Constraints as Assert;
  13. use Serializable;
  15. /**
  16.  * @ORM\Entity(repositoryClass=SiteRepository::class)
  17.  * @Vich\Uploadable
  18.  * @UniqueEntity(
  19.  *      fields={"email"},
  20.  *      message="Ce mail est déjà utilisé."
  21.  * )
  22.  * @UniqueEntity(fields={"telephone"},message="Ce téléphone est déjà utilisé." )
  23.  * @UniqueEntity(fields={"wording"},message="Ce nom est déjà utilisé." )
  24.  */
  25. class Site implements Serializable
  26. {
  27.     /**
  28.      * @ORM\Id
  29.      * @ORM\GeneratedValue
  30.      * @ORM\Column(type="integer")
  31.      */
  32.     private $id;
  34.     /**
  35.      * @ORM\Column(type="text")
  36.      */
  37.     private $wording;
  39.     /**
  40.      * @ORM\Column(type="text")
  41.      */
  42.     private $address;
  44.      /**
  45.      * @ORM\Column(type="string", length=255,nullable=true)
  46.      * @Assert\Email(message = "L'email '{{ value }}' n'est pas valide.")
  47.      */
  48.     private $email;
  50.     /**
  51.      * @ORM\Column(type="string", length=40)
  52.      * @Assert\Length(min=10,minMessage = "La taille minimum doit être de {{ limit }} caractères")
  53.      */
  54.     private $telephone;
  56.     /**
  57.      * @ORM\Column(type="text")
  58.      */
  59.     private $director;
  61.     /**
  62.      * @ORM\OneToMany(targetEntity=Session::class, mappedBy="site", orphanRemoval=true)
  63.      */
  64.     private $sessions;
  66.     /**
  67.      * @Doctrine\ORM\Mapping\Column(type="string", length=255, nullable=true)
  68.      */
  69.     private $image;
  71.     /**
  72.      * @Vich\UploadableField(mapping="cachet_site", fileNameProperty="image")
  73.      */
  74.     private $fichier;
  76.     /**
  77.      * @Doctrine\ORM\Mapping\Column(type="string", length=255, nullable=true)
  78.      */
  79.     private $imageCachet;
  81.     /**
  82.      * @Vich\UploadableField(mapping="cachet_site", fileNameProperty="imageCachet")
  83.      */
  84.     private $fichierCachet;
  86.     /**
  87.      * @ORM\Column(type="string", length=255)
  88.      */
  89.     private $titre;
  91.     /**
  92.      * @ORM\Column(type="string", length=1)
  93.      */
  94.     private $sexe;
  96.    /**
  97.      * @Doctrine\ORM\Mapping\Column(type="string", length=255, nullable=true)
  98.      */
  99.     private $map;
  101.     /**
  102.      * @Vich\UploadableField(mapping="signature_site", fileNameProperty="map")
  103.      */
  104.     private $fichiermap;
  105.     /**
  106.      * @ORM\Column(type="datetime_immutable", nullable=true)
  107.      */
  108.     private $updateAt;
  110.     /**
  111.      * @ORM\Column(type="string", nullable=true)
  112.      */
  113.     private $departement;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="site")
  117.      */
  118.     private $users;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity=CalendarEvent::class, mappedBy="site")
  122.      */
  123.     private $calendarEvents;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=Diplome::class, mappedBy="site")
  127.      */
  128.     private $diplomes;
  130.     /**
  131.      * @ORM\OneToMany(targetEntity=Inscrit::class, mappedBy="site")
  132.      */
  133.     private $inscrits;
  135.     /**
  136.      * @ORM\OneToMany(targetEntity=Message::class, mappedBy="site")
  137.      */
  138.     private $messages;
  140.     /**
  141.      * @Doctrine\ORM\Mapping\Column(type="string", length=255, nullable=true)
  142.      */
  143.     private $cachetSignature;
  145.     /**
  146.      * @Vich\UploadableField(mapping="signature_site_cachet", fileNameProperty="cachetSignature")
  147.      */
  148.     private $fichiCachetSignature;
  149.     /**
  150.      * @ORM\OneToMany(targetEntity=EnteteFacture::class, mappedBy="site")
  151.      */
  152.     private $enteteFactures;
  153.     
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=EnteteDevis::class, mappedBy="site")
  156.      */
  157.     private $enteteDevis;
  159.      /**
  160.      * @ORM\OneToMany(targetEntity=DemandeDevisEntete::class, mappedBy="site")
  161.      */
  162.     private $demandeDevisEntetes;
  164.     /**
  165.      * @ORM\OneToMany(targetEntity=DemandePro::class, mappedBy="site")
  166.      */
  167.     private $demandePros;
  169.     public function __construct()
  170.     {
  171.         $this->sessions = new ArrayCollection();
  172.         $this->users = new ArrayCollection();
  173.         $this->calendarEvents = new ArrayCollection();
  174.         $this->diplomes = new ArrayCollection();
  175.         $this->inscrits = new ArrayCollection();
  176.         $this->messages = new ArrayCollection();
  177.         $this->enteteFactures = new ArrayCollection();
  178.         $this->enteteDevis = new ArrayCollection();
  179.         $this->demandeDevisEntetes = new ArrayCollection();
  180.         $this->demandePros = new ArrayCollection();
  181.     }
  183.     public function getId(): ?int
  184.     {
  185.         return $this->id;
  186.     }
  188.     public function getWording(): ?string
  189.     {
  190.         return $this->wording;
  191.     }
  193.     public function setWording(string $wording): self
  194.     {
  195.         $this->wording = $wording;
  197.         return $this;
  198.     }
  200.     public function getAddress(): ?string
  201.     {
  202.         return $this->address;
  203.     }
  205.     public function setAddress(string $address): self
  206.     {
  207.         $this->address = $address;
  209.         return $this;
  210.     }
  212.     public function getTelephone(): ?string
  213.     {
  214.         return $this->telephone;
  215.     }
  217.     public function setTelephone(string $telephone): self
  218.     {
  219.         $this->telephone = $telephone;
  221.         return $this;
  222.     }
  224.     public function getDirector(): ?string
  225.     {
  226.         return $this->director;
  227.     }
  229.     public function setDirector(string $director): self
  230.     {
  231.         $this->director = $director;
  233.         return $this;
  234.     }
  236.     public function getEmail(): ?string
  237.     {
  238.         return $this->email;
  239.     }
  241.     public function setEmail(string $email): self
  242.     {
  243.         $this->email = $email;
  245.         return $this;
  246.     }
  248.     /**
  249.      * @return Collection<int, Session>
  250.      */
  251.     public function getSessions(): Collection
  252.     {
  253.         return $this->sessions;
  254.     }
  256.     public function addSession(Session $session): self
  257.     {
  258.         if (!$this->sessions->contains($session)) {
  259.             $this->sessions[] = $session;
  260.             $session->setSite($this);
  261.         }
  263.         return $this;
  264.     }
  266.     public function removeSession(Session $session): self
  267.     {
  268.         if ($this->sessions->removeElement($session)) {
  269.             // set the owning side to null (unless already changed)
  270.             if ($session->getSite() === $this) {
  271.                 $session->setSite(null);
  272.             }
  273.         }
  275.         return $this;
  276.     }
  278.     public function setFichier(?File $image = null)
  279.     {
  280.         $this->fichier = $image;
  282.         if ($image) {
  283.             $this->updateAt = new \DateTimeImmutable();
  284.         }
  286.     }
  288.     public function getFichier()
  289.     {
  290.         return $this->fichier;
  291.     }
  292.     public function setImage($image)
  293.     {
  294.         $this->image = $image;
  295.     }
  297.     public function getImage()
  298.     {
  299.         return $this->image;
  300.     }
  301.     public function setFichierMap(?File $imageCachet = null)
  302.     {
  303.         $this->fichiermap = $imageCachet;
  304.         if ($imageCachet) {
  305.             $this->updateAt = new \DateTimeImmutable();
  306.         }
  308.     }
  310.     public function getFichierMap()
  311.     {
  312.         return $this->fichiermap;
  313.     }
  314.     public function setMap($image)
  315.     {
  316.         $this->map = $image;
  317.     }
  319.     public function getMap()
  320.     {
  321.         return $this->map;
  322.     }
  324.     public function getTitre(): ?string
  325.     {
  326.         return $this->titre;
  327.     }
  329.     public function setTitre(string $titre): self
  330.     {
  331.         $this->titre = $titre;
  333.         return $this;
  334.     }
  336.     public function getSexe(): ?string
  337.     {
  338.         return $this->sexe;
  339.     }
  341.     public function setSexe(string $sexe): self
  342.     {
  343.         $this->sexe = $sexe;
  345.         return $this;
  346.     }
  348.     public function setFichierCachet(?File $imageCachet = null)
  349.     {
  350.         $this->fichierCachet = $imageCachet;
  351.         if ($imageCachet) {
  352.             $this->updateAt = new \DateTimeImmutable();
  353.         }
  355.     }
  357.     public function getFichierCachet()
  358.     {
  359.         return $this->fichierCachet;
  360.     }
  361.     public function setImageCachet($image)
  362.     {
  363.         $this->imageCachet = $image;
  364.     }
  366.     public function getImageCachet()
  367.     {
  368.         return $this->imageCachet;
  369.     }
  371.     public function getUpdateAt(): ?\DateTimeImmutable
  372.     {
  373.         return $this->updateAt;
  374.     }
  376.     public function setUpdateAt(?\DateTimeImmutable $updateAt): self
  377.     {
  378.         $this->updateAt = $updateAt;
  380.         return $this;
  381.     }
  383.     public function getDepartement(): ?string
  384.     {
  385.         return $this->departement;
  386.     }
  388.     public function setDepartement(?string $departement): self
  389.     {
  390.         $this->departement = $departement;
  392.         return $this;
  393.     }
  395.     /**
  396.      * @return Collection<int, User>
  397.      */
  398.     public function getUsers(): Collection
  399.     {
  400.         return $this->users;
  401.     }
  403.     public function addUser(User $user): self
  404.     {
  405.         if (!$this->users->contains($user)) {
  406.             $this->users[] = $user;
  407.             $user->setSite($this);
  408.         }
  410.         return $this;
  411.     }
  413.     public function removeUser(User $user): self
  414.     {
  415.         if ($this->users->removeElement($user)) {
  416.             // set the owning side to null (unless already changed)
  417.             if ($user->getSite() === $this) {
  418.                 $user->setSite(null);
  419.             }
  420.         }
  422.         return $this;
  423.     }
  425.     /**
  426.      * @return Collection<int, CalendarEvent>
  427.      */
  428.     public function getCalendarEvents(): Collection
  429.     {
  430.         return $this->calendarEvents;
  431.     }
  433.     public function addCalendarEvent(CalendarEvent $calendarEvent): self
  434.     {
  435.         if (!$this->calendarEvents->contains($calendarEvent)) {
  436.             $this->calendarEvents[] = $calendarEvent;
  437.             $calendarEvent->setSite($this);
  438.         }
  440.         return $this;
  441.     }
  443.     public function removeCalendarEvent(CalendarEvent $calendarEvent): self
  444.     {
  445.         if ($this->calendarEvents->removeElement($calendarEvent)) {
  446.             // set the owning side to null (unless already changed)
  447.             if ($calendarEvent->getSite() === $this) {
  448.                 $calendarEvent->setSite(null);
  449.             }
  450.         }
  452.         return $this;
  453.     }
  455.     /**
  456.      * @return Collection<int, Diplome>
  457.      */
  458.     public function getDiplomes(): Collection
  459.     {
  460.         return $this->diplomes;
  461.     }
  463.     public function addDiplome(Diplome $diplome): self
  464.     {
  465.         if (!$this->diplomes->contains($diplome)) {
  466.             $this->diplomes[] = $diplome;
  467.             $diplome->setSite($this);
  468.         }
  470.         return $this;
  471.     }
  473.     public function removeDiplome(Diplome $diplome): self
  474.     {
  475.         if ($this->diplomes->removeElement($diplome)) {
  476.             // set the owning side to null (unless already changed)
  477.             if ($diplome->getSite() === $this) {
  478.                 $diplome->setSite(null);
  479.             }
  480.         }
  482.         return $this;
  483.     }
  485.     /**
  486.      * @return Collection<int, Inscrit>
  487.      */
  488.     public function getInscrits(): Collection
  489.     {
  490.         return $this->inscrits;
  491.     }
  493.     public function addInscrit(Inscrit $inscrit): self
  494.     {
  495.         if (!$this->inscrits->contains($inscrit)) {
  496.             $this->inscrits[] = $inscrit;
  497.             $inscrit->setSite($this);
  498.         }
  500.         return $this;
  501.     }
  503.     public function removeInscrit(Inscrit $inscrit): self
  504.     {
  505.         if ($this->inscrits->removeElement($inscrit)) {
  506.             // set the owning side to null (unless already changed)
  507.             if ($inscrit->getSite() === $this) {
  508.                 $inscrit->setSite(null);
  509.             }
  510.         }
  512.         return $this;
  513.     }
  515.     /**
  516.      * @return Collection<int, Message>
  517.      */
  518.     public function getMessages(): Collection
  519.     {
  520.         return $this->messages;
  521.     }
  523.     public function addMessage(Message $message): self
  524.     {
  525.         if (!$this->messages->contains($message)) {
  526.             $this->messages[] = $message;
  527.             $message->setSite($this);
  528.         }
  530.         return $this;
  531.     }
  533.     public function removeMessage(Message $message): self
  534.     {
  535.         if ($this->messages->removeElement($message)) {
  536.             // set the owning side to null (unless already changed)
  537.             if ($message->getSite() === $this) {
  538.                 $message->setSite(null);
  539.             }
  540.         }
  542.         return $this;
  543.     }
  545.     public function setFichiCachetSignature(?File $imageCachet = null)
  546.     {
  547.         $this->fichiCachetSignature = $imageCachet;
  548.         if ($imageCachet) {
  549.             $this->updateAt = new \DateTimeImmutable();
  550.         }
  552.     }
  554.     public function getFichiCachetSignature()
  555.     {
  556.         return $this->fichiCachetSignature;
  557.     }
  558.     public function setCachetSignature($image)
  559.     {
  560.         $this->cachetSignature = $image;
  561.     }
  563.     public function getCachetSignature()
  564.     {
  565.         return $this->cachetSignature;
  566.     }
  567.     /**
  568.      * @return Collection<int, EnteteFacture>
  569.      */
  570.     public function getEnteteFactures(): Collection
  571.     {
  572.         return $this->enteteFactures;
  573.     }
  575.     public function addEnteteFacture(EnteteFacture $enteteFacture): self
  576.     {
  577.         if (!$this->enteteFactures->contains($enteteFacture)) {
  578.             $this->enteteFactures[] = $enteteFacture;
  579.             $enteteFacture->setSite($this);
  580.         }
  582.         return $this;
  583.     }
  585.     public function removeEnteteFacture(EnteteFacture $enteteFacture): self
  586.     {
  587.         if ($this->enteteFactures->removeElement($enteteFacture)) {
  588.             // set the owning side to null (unless already changed)
  589.             if ($enteteFacture->getSite() === $this) {
  590.                 $enteteFacture->setSite(null);
  591.             }
  592.         }
  594.         return $this;
  595.     }
  597.     /**
  598.      * @return Collection<int, EnteteDevis>
  599.      */
  600.     public function getEnteteDevis(): Collection
  601.     {
  602.         return $this->enteteDevis;
  603.     }
  605.     public function addEnteteDevi(EnteteDevis $enteteDevi): self
  606.     {
  607.         if (!$this->enteteDevis->contains($enteteDevi)) {
  608.             $this->enteteDevis[] = $enteteDevi;
  609.             $enteteDevi->setSite($this);
  610.         }
  612.         return $this;
  613.     }
  615.     public function removeEnteteDevi(EnteteDevis $enteteDevi): self
  616.     {
  617.         if ($this->enteteDevis->removeElement($enteteDevi)) {
  618.             // set the owning side to null (unless already changed)
  619.             if ($enteteDevi->getSite() === $this) {
  620.                 $enteteDevi->setSite(null);
  621.             }
  622.         }
  624.         return $this;
  625.     }
  626.     /**
  627.      * @return Collection<int, DemandeDevisEntete>
  628.      */
  629.     public function getDemandeDevisEntetes(): Collection
  630.     {
  631.         return $this->demandeDevisEntetes;
  632.     }
  634.     public function addDemandeDevisEntetes(DemandeDevisEntete $demandeDevisEntetes): self
  635.     {
  636.         if (!$this->demandeDevisEntetes->contains($demandeDevisEntetes)) {
  637.             $this->demandeDevisEntetes[] = $demandeDevisEntetes;
  638.             $demandeDevisEntetes->setSite($this);
  639.         }
  641.         return $this;
  642.     }
  644.     public function removeDemandeDevisEntetes(DemandeDevisEntete $demandeDevisEntetes): self
  645.     {
  646.         if ($this->demandeDevisEntetes->removeElement($demandeDevisEntetes)) {
  647.             // set the owning side to null (unless already changed)
  648.             if ($demandeDevisEntetes->getSite() === $this) {
  649.                 $demandeDevisEntetes->setSite(null);
  650.             }
  651.         }
  653.         return $this;
  654.     }
  656.     public function serialize()
  657.     {
  658.         $this->fichier = base64_encode($this->fichier);
  659.         $this->fichierCachet = base64_encode($this->fichierCachet);
  660.         $this->fichiermap = base64_encode($this->fichiermap);
  661.         $this->fichiCachetSignature = base64_encode($this->fichiCachetSignature);
  662.     }
  664.     public function unserialize($serialized)
  665.     {
  666.         $this->fichier = base64_decode($this->fichier);
  667.         $this->fichierCachet = base64_decode($this->fichierCachet);
  668.         $this->fichiermap = base64_decode($this->fichiermap);
  669.         $this->fichiCachetSignature = base64_decode($this->fichiCachetSignature);
  671.     }
  673.     /**
  674.      * @return Collection<int, DemandePro>
  675.      */
  676.     public function getDemandePros(): Collection
  677.     {
  678.         return $this->demandePros;
  679.     }
  681.     public function addDemandePro(DemandePro $demandePro): self
  682.     {
  683.         if (!$this->demandePros->contains($demandePro)) {
  684.             $this->demandePros[] = $demandePro;
  685.             $demandePro->setSite($this);
  686.         }
  688.         return $this;
  689.     }
  691.     public function removeDemandePro(DemandePro $demandePro): self
  692.     {
  693.         if ($this->demandePros->removeElement($demandePro)) {
  694.             // set the owning side to null (unless already changed)
  695.             if ($demandePro->getSite() === $this) {
  696.                 $demandePro->setSite(null);
  697.             }
  698.         }
  700.         return $this;
  701.     }
  702. }