src/Entity/Client.php line 13

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\ClientRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. #[ORM\Entity(repositoryClass: ClientRepository::class)]
  12. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  13. class Client
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column(length: 255, nullable: true)]
  21.     private ?string $email = null;
  23.     #[ORM\Column(length: 255 , nullable: true)]
  24.     private ?string $nom = null;
  26.     #[ORM\Column(length: 255, nullable: true)]
  27.     private ?string $prenom = null;
  29.     #[ORM\Column(length: 255, unique: true)]
  30.     private ?string $raisonsocial = null;
  32.     #[ORM\Column(length: 255, nullable: true)]
  33.     private ?string $adresse = null;
  35.     #[ORM\Column(length: 255, nullable: true)]
  36.     private ?string $tel = null;
  38.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Intervention::class, cascade: ["remove"])]
  39.     private Collection $intervention;
  41.     #[ORM\ManyToOne(inversedBy: 'clients', cascade: ["remove"])]
  42.     #[ORM\JoinColumn(nullable: true)]
  43.     private ?Fraisdeliv $region = null;
  45.     #[ORM\Column(length: 255, nullable: true)]
  46.     private ?string $photo = null;
  48.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Devis::class, cascade: ["remove"])]
  49.     private Collection $devis;
  51.     #[ORM\Column(length: 255, nullable: true)]
  52.     private ?string $faxclient = null;
  54.     #[ORM\Column(length: 255, nullable: true)]
  55.     private ?string $mfclient = null;
  58.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Gestionmachines::class, cascade: ["remove"])]
  59.     private Collection $gestionmachines;
  61.     #[ORM\Column(nullable: true)]
  62.     private ?bool $exoneres = null;
  64.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Importdirect::class, cascade: ["remove"])]
  65.     private Collection $importdirects;
  67.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Commissions::class, cascade: ["remove"])]
  68.     private Collection $commissions;
  70.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Historiquedemandedevis::class, cascade: ["remove"])]
  71.     private Collection $historiquedemandedevis;
  73.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Historiqueintervention::class, cascade: ["remove"])]
  74.     private Collection $historiqueinterventions;
  76.     #[ORM\OneToMany(mappedBy: 'client', targetEntity: Bondesortie::class)]
  77.     private Collection $bondesorties;
  82.     public function __toString(): string
  83.     {
  84.         return $this->raisonsocial;
  85.     }
  86.     public function __construct()
  87.     {
  88.         $this->intervention = new ArrayCollection();
  89.         $this->devis = new ArrayCollection();
  90.         $this->gestionmachines = new ArrayCollection();
  91.         $this->importdirects = new ArrayCollection();
  92.         $this->commissions = new ArrayCollection();
  93.         $this->historiquedemandedevis = new ArrayCollection();
  94.         $this->historiqueinterventions = new ArrayCollection();
  95.         $this->bondesorties = new ArrayCollection();
  96.     }
  97.     public function getNom(): ?string
  98.     {
  99.         return $this->nom;
  100.     }
  101.     public function getId(): ?int
  102.     {
  103.         return $this->id;
  104.     }
  106.     public function getEmail(): ?string
  107.     {
  108.         return $this->email;
  109.     }
  111.     public function setEmail(?string $email): void
  112.     {
  113.         $this->email = $email;
  114.     }
  120.     public function setNom(string $nom): self
  121.     {
  122.         $this->nom = $nom;
  124.         return $this;
  125.     }
  127.     public function getPrenom(): ?string
  128.     {
  129.         return $this->prenom;
  130.     }
  132.     public function setPrenom(string $prenom): self
  133.     {
  134.         $this->prenom = $prenom;
  136.         return $this;
  137.     }
  139.     public function getRaisonsocial(): ?string
  140.     {
  141.         return $this->raisonsocial;
  142.     }
  144.     public function setRaisonsocial(string $raisonsocial): self
  145.     {
  146.         $this->raisonsocial = $raisonsocial;
  148.         return $this;
  149.     }
  151.     public function getAdresse(): ?string
  152.     {
  153.         return $this->adresse;
  154.     }
  156.     public function setAdresse(string $adresse): self
  157.     {
  158.         $this->adresse = $adresse;
  160.         return $this;
  161.     }
  163.     public function getTel(): ?string
  164.     {
  165.         return $this->tel;
  166.     }
  168.     public function setTel(string $tel): self
  169.     {
  170.         $this->tel = $tel;
  172.         return $this;
  173.     }
  175.     /**
  176.      * @return Collection<int, Intervention>
  177.      */
  178.     public function getIntervention(): Collection
  179.     {
  180.         return $this->intervention;
  181.     }
  183.     public function addIntervention(Intervention $intervention): self
  184.     {
  185.         if (!$this->intervention->contains($intervention)) {
  186.             $this->intervention->add($intervention);
  187.             $intervention->setClient($this);
  188.         }
  190.         return $this;
  191.     }
  193.     public function removeIntervention(Intervention $intervention): self
  194.     {
  195.         if ($this->intervention->removeElement($intervention)) {
  196.             // set the owning side to null (unless already changed)
  197.             if ($intervention->getClient() === $this) {
  198.                 $intervention->setClient(null);
  199.             }
  200.         }
  202.         return $this;
  203.     }
  205.     public function getRegion(): ?Fraisdeliv
  206.     {
  207.         return $this->region;
  208.     }
  210.     public function setRegion(?Fraisdeliv $region): self
  211.     {
  212.         $this->region = $region;
  214.         return $this;
  215.     }
  217.     public function getPhoto(): ?string
  218.     {
  219.         return $this->photo;
  220.     }
  222.     public function setPhoto(string $photo): self
  223.     {
  224.         $this->photo = $photo;
  226.         return $this;
  227.     }
  229.     /**
  230.      * @return Collection<int, Devis>
  231.      */
  232.     public function getDevis(): Collection
  233.     {
  234.         return $this->devis;
  235.     }
  237.     public function addDevi(Devis $devi): self
  238.     {
  239.         if (!$this->devis->contains($devi)) {
  240.             $this->devis->add($devi);
  241.             $devi->setClient($this);
  242.         }
  244.         return $this;
  245.     }
  247.     public function removeDevi(Devis $devi): self
  248.     {
  249.         if ($this->devis->removeElement($devi)) {
  250.             // set the owning side to null (unless already changed)
  251.             if ($devi->getClient() === $this) {
  252.                 $devi->setClient(null);
  253.             }
  254.         }
  256.         return $this;
  257.     }
  259.     public function getFaxclient(): ?string
  260.     {
  261.         return $this->faxclient;
  262.     }
  264.     public function setFaxclient(?string $faxclient): self
  265.     {
  266.         $this->faxclient = $faxclient;
  268.         return $this;
  269.     }
  271.     public function getMfclient(): ?string
  272.     {
  273.         return $this->mfclient;
  274.     }
  276.     public function setMfclient(?string $mfclient): self
  277.     {
  278.         $this->mfclient = $mfclient;
  280.         return $this;
  281.     }
  286.     /**
  287.      * @return Collection<int, Gestionmachines>
  288.      */
  289.     public function getGestionmachines(): Collection
  290.     {
  291.         return $this->gestionmachines;
  292.     }
  294.     public function addGestionmachine(Gestionmachines $gestionmachine): self
  295.     {
  296.         if (!$this->gestionmachines->contains($gestionmachine)) {
  297.             $this->gestionmachines->add($gestionmachine);
  298.             $gestionmachine->setClient($this);
  299.         }
  301.         return $this;
  302.     }
  304.     public function removeGestionmachine(Gestionmachines $gestionmachine): self
  305.     {
  306.         if ($this->gestionmachines->removeElement($gestionmachine)) {
  307.             // set the owning side to null (unless already changed)
  308.             if ($gestionmachine->getClient() === $this) {
  309.                 $gestionmachine->setClient(null);
  310.             }
  311.         }
  313.         return $this;
  314.     }
  315.     public function getExoneres(): ?bool
  316.     {
  317.         return $this->exoneres;
  318.     }
  319.     public function isExoneres(): ?bool
  320.     {
  321.         return $this->exoneres;
  322.     }
  324.     public function setExoneres(?bool $exoneres): self
  325.     {
  326.         $this->exoneres = $exoneres;
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, Importdirect>
  333.      */
  334.     public function getImportdirects(): Collection
  335.     {
  336.         return $this->importdirects;
  337.     }
  339.     public function addImportdirect(Importdirect $importdirect): static
  340.     {
  341.         if (!$this->importdirects->contains($importdirect)) {
  342.             $this->importdirects->add($importdirect);
  343.             $importdirect->setClient($this);
  344.         }
  346.         return $this;
  347.     }
  349.     public function removeImportdirect(Importdirect $importdirect): static
  350.     {
  351.         if ($this->importdirects->removeElement($importdirect)) {
  352.             // set the owning side to null (unless already changed)
  353.             if ($importdirect->getClient() === $this) {
  354.                 $importdirect->setClient(null);
  355.             }
  356.         }
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, Commissions>
  363.      */
  364.     public function getCommissions(): Collection
  365.     {
  366.         return $this->commissions;
  367.     }
  369.     public function addCommission(Commissions $commission): static
  370.     {
  371.         if (!$this->commissions->contains($commission)) {
  372.             $this->commissions->add($commission);
  373.             $commission->setClient($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeCommission(Commissions $commission): static
  380.     {
  381.         if ($this->commissions->removeElement($commission)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($commission->getClient() === $this) {
  384.                 $commission->setClient(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     /**
  392.      * @return Collection<int, Historiquedemandedevis>
  393.      */
  394.     public function getHistoriquedemandedevis(): Collection
  395.     {
  396.         return $this->historiquedemandedevis;
  397.     }
  399.     public function addHistoriquedemandedevi(Historiquedemandedevis $historiquedemandedevi): static
  400.     {
  401.         if (!$this->historiquedemandedevis->contains($historiquedemandedevi)) {
  402.             $this->historiquedemandedevis->add($historiquedemandedevi);
  403.             $historiquedemandedevi->setClient($this);
  404.         }
  406.         return $this;
  407.     }
  409.     public function removeHistoriquedemandedevi(Historiquedemandedevis $historiquedemandedevi): static
  410.     {
  411.         if ($this->historiquedemandedevis->removeElement($historiquedemandedevi)) {
  412.             // set the owning side to null (unless already changed)
  413.             if ($historiquedemandedevi->getClient() === $this) {
  414.                 $historiquedemandedevi->setClient(null);
  415.             }
  416.         }
  418.         return $this;
  419.     }
  421.     /**
  422.      * @return Collection<int, Historiqueintervention>
  423.      */
  424.     public function getHistoriqueinterventions(): Collection
  425.     {
  426.         return $this->historiqueinterventions;
  427.     }
  429.     public function addHistoriqueintervention(Historiqueintervention $historiqueintervention): static
  430.     {
  431.         if (!$this->historiqueinterventions->contains($historiqueintervention)) {
  432.             $this->historiqueinterventions->add($historiqueintervention);
  433.             $historiqueintervention->setClient($this);
  434.         }
  436.         return $this;
  437.     }
  439.     public function removeHistoriqueintervention(Historiqueintervention $historiqueintervention): static
  440.     {
  441.         if ($this->historiqueinterventions->removeElement($historiqueintervention)) {
  442.             // set the owning side to null (unless already changed)
  443.             if ($historiqueintervention->getClient() === $this) {
  444.                 $historiqueintervention->setClient(null);
  445.             }
  446.         }
  448.         return $this;
  449.     }
  451.     /**
  452.      * @return Collection<int, Bondesortie>
  453.      */
  454.     public function getBondesorties(): Collection
  455.     {
  456.         return $this->bondesorties;
  457.     }
  459.     public function addBondesorty(Bondesortie $bondesorty): self
  460.     {
  461.         if (!$this->bondesorties->contains($bondesorty)) {
  462.             $this->bondesorties->add($bondesorty);
  463.             $bondesorty->setClient($this);
  464.         }
  466.         return $this;
  467.     }
  469.     public function removeBondesorty(Bondesortie $bondesorty): self
  470.     {
  471.         if ($this->bondesorties->removeElement($bondesorty)) {
  472.             // set the owning side to null (unless already changed)
  473.             if ($bondesorty->getClient() === $this) {
  474.                 $bondesorty->setClient(null);
  475.             }
  476.         }
  478.         return $this;
  479.     }
  483. }