src/Entity/Fournisseur.php line 14

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\FournisseurRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. #[ORM\Entity(repositoryClass: FournisseurRepository::class)]
  13. #[UniqueEntity(fields: ['email'], message: 'Il existe déjà un compte avec cet email')]
  14. class Fournisseur
  15. {
  16.     #[ORM\Id]
  17.     #[ORM\GeneratedValue]
  18.     #[ORM\Column]
  19.     private ?int $id = null;
  21.     #[ORM\Column(length: 255, unique: true)]
  22.     private ?string $email = null;
  24.     #[ORM\Column(length: 255)]
  25.     private ?string $nom = null;
  27.     #[ORM\Column(length: 255)]
  28.     private ?string $prenom = null;
  32.     #[ORM\Column(length: 255)]
  33.     private ?string $tel = null;
  35.     #[ORM\Column(length: 255)]
  36.     private ?string $raisonsocial = null;
  40.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Ficheoffre::class, cascade: ["remove"])]
  41.     private Collection $ficheoffres;
  43.     #[ORM\Column(length: 255, nullable: true)]
  44.     private ?string $devise = null;
  46.     #[ORM\Column(type: Types::TEXT, nullable: true)]
  47.     private ?string $adresse = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $fax = null;
  52.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Aiguilles::class, cascade: ["remove"])]
  53.     private Collection $aiguilles;
  55.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Platines::class, cascade: ["remove"])]
  56.     private Collection $platines;
  58.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Courroie::class, cascade: ["remove"])]
  59.     private Collection $courroie;
  61.     #[ORM\Column(length: 255, nullable: true)]
  62.     private ?string $mf = null;
  64.     #[ORM\Column(length: 255, nullable: true)]
  65.     private ?string $rc = null;
  67.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Famillesdarticles::class, cascade: ["remove"])]
  68.     private Collection $famillesdarticles;
  70.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Archivearticle::class, cascade: ["remove"])]
  71.     private Collection $archivearticles;
  73.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Importdirect::class, cascade: ["remove"])]
  74.     private Collection $importdirects;
  76.     #[ORM\ManyToMany(targetEntity: Banque::class, inversedBy: 'fournisseurs')]
  77.     private Collection $banque;
  79.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Devis::class)]
  80.     private Collection $devis;
  84.     #[ORM\OneToMany(mappedBy: 'fournisseur', targetEntity: Ficheachatnf::class)]
  85.     private Collection $ficheachatnfs;
  90.     public function __construct()
  91.     {
  92.         $this->ficheoffres = new ArrayCollection();
  93.         $this->aiguilles = new ArrayCollection();
  94.         $this->platines = new ArrayCollection();
  95.         $this->courroie = new ArrayCollection();
  96.         $this->famillesdarticles = new ArrayCollection();
  97.         $this->archivearticles = new ArrayCollection();
  98.         $this->importdirects = new ArrayCollection();
  99.         $this->banque = new ArrayCollection();
  100.         $this->devis = new ArrayCollection();
  101.         $this->ficheachatnfs = new ArrayCollection();
  104.     }
  106.     public function getId(): ?int
  107.     {
  108.         return $this->id;
  109.     }
  111.     public function getEmail(): ?string
  112.     {
  113.         return $this->email;
  114.     }
  116.     public function setEmail(string $email): self
  117.     {
  118.         $this->email = $email;
  120.         return $this;
  121.     }
  123.     public function getNom(): ?string
  124.     {
  125.         return $this->nom;
  126.     }
  128.     public function setNom(string $nom): self
  129.     {
  130.         $this->nom = $nom;
  132.         return $this;
  133.     }
  135.     public function getPrenom(): ?string
  136.     {
  137.         return $this->prenom;
  138.     }
  140.     public function setPrenom(string $prenom): self
  141.     {
  142.         $this->prenom = $prenom;
  144.         return $this;
  145.     }
  148.     public function getTel(): ?string
  149.     {
  150.         return $this->tel;
  151.     }
  153.     public function setTel(string $tel): self
  154.     {
  155.         $this->tel = $tel;
  157.         return $this;
  158.     }
  160.     public function getRaisonsocial(): ?string
  161.     {
  162.         return $this->raisonsocial;
  163.     }
  165.     public function setRaisonsocial(string $raisonsocial): self
  166.     {
  167.         $this->raisonsocial = $raisonsocial;
  169.         return $this;
  170.     }
  173.     /**
  174.      * @return Collection<int, Ficheoffre>
  175.      */
  176.     public function getFicheoffres(): Collection
  177.     {
  178.         return $this->ficheoffres;
  179.     }
  181.     public function getDevise(): ?string
  182.     {
  183.         return $this->devise;
  184.     }
  186.     public function setDevise(?string $devise): self
  187.     {
  188.         $this->devise = $devise;
  190.         return $this;
  191.     }
  193.     public function getAdresse(): ?string
  194.     {
  195.         return $this->adresse;
  196.     }
  198.     public function setAdresse(?string $adresse): self
  199.     {
  200.         $this->adresse = $adresse;
  202.         return $this;
  203.     }
  205.     public function getFax(): ?string
  206.     {
  207.         return $this->fax;
  208.     }
  210.     public function setFax(?string $fax): self
  211.     {
  212.         $this->fax = $fax;
  214.         return $this;
  215.     }
  217.     /**
  218.      * @return Collection<int, Aiguilles>
  219.      */
  220.     public function getAiguilles(): Collection
  221.     {
  222.         return $this->aiguilles;
  223.     }
  225.     public function addAiguille(Aiguilles $aiguille): self
  226.     {
  227.         if (!$this->aiguilles->contains($aiguille)) {
  228.             $this->aiguilles->add($aiguille);
  229.             $aiguille->setFournisseur($this);
  230.         }
  232.         return $this;
  233.     }
  235.     public function removeAiguille(Aiguilles $aiguille): self
  236.     {
  237.         if ($this->aiguilles->removeElement($aiguille)) {
  238.             // set the owning side to null (unless already changed)
  239.             if ($aiguille->getFournisseur() === $this) {
  240.                 $aiguille->setFournisseur(null);
  241.             }
  242.         }
  244.         return $this;
  245.     }
  247.     /**
  248.      * @return Collection<int, Platines>
  249.      */
  250.     public function getPlatines(): Collection
  251.     {
  252.         return $this->platines;
  253.     }
  255.     public function addPlatine(Platines $platine): self
  256.     {
  257.         if (!$this->platines->contains($platine)) {
  258.             $this->platines->add($platine);
  259.             $platine->setFournisseur($this);
  260.         }
  262.         return $this;
  263.     }
  265.     public function removePlatine(Platines $platine): self
  266.     {
  267.         if ($this->platines->removeElement($platine)) {
  268.             // set the owning side to null (unless already changed)
  269.             if ($platine->getFournisseur() === $this) {
  270.                 $platine->setFournisseur(null);
  271.             }
  272.         }
  274.         return $this;
  275.     }
  277.     /**
  278.      * @return Collection<int, Courroie>
  279.      */
  280.     public function getCourroie(): Collection
  281.     {
  282.         return $this->courroie;
  283.     }
  285.     public function addCourroie(Courroie $courroie): self
  286.     {
  287.         if (!$this->courroie->contains($courroie)) {
  288.             $this->courroie->add($courroie);
  289.             $courroie->setFournisseur($this);
  290.         }
  292.         return $this;
  293.     }
  295.     public function removeCourroie(Courroie $courroie): self
  296.     {
  297.         if ($this->courroie->removeElement($courroie)) {
  298.             // set the owning side to null (unless already changed)
  299.             if ($courroie->getFournisseur() === $this) {
  300.                 $courroie->setFournisseur(null);
  301.             }
  302.         }
  304.         return $this;
  305.     }
  307.     public function getMf(): ?string
  308.     {
  309.         return $this->mf;
  310.     }
  312.     public function setMf(?string $mf): self
  313.     {
  314.         $this->mf = $mf;
  316.         return $this;
  317.     }
  319.     public function getRc(): ?string
  320.     {
  321.         return $this->rc;
  322.     }
  324.     public function setRc(?string $rc): self
  325.     {
  326.         $this->rc = $rc;
  328.         return $this;
  329.     }
  331.     /**
  332.      * @return Collection<int, Famillesdarticles>
  333.      */
  334.     public function getFamillesdarticles(): Collection
  335.     {
  336.         return $this->famillesdarticles;
  337.     }
  339.     public function addFamillesdarticle(Famillesdarticles $famillesdarticle): self
  340.     {
  341.         if (!$this->famillesdarticles->contains($famillesdarticle)) {
  342.             $this->famillesdarticles->add($famillesdarticle);
  343.             $famillesdarticle->setFournisseur($this);
  344.         }
  346.         return $this;
  347.     }
  349.     public function removeFamillesdarticle(Famillesdarticles $famillesdarticle): self
  350.     {
  351.         if ($this->famillesdarticles->removeElement($famillesdarticle)) {
  352.             // set the owning side to null (unless already changed)
  353.             if ($famillesdarticle->getFournisseur() === $this) {
  354.                 $famillesdarticle->setFournisseur(null);
  355.             }
  356.         }
  358.         return $this;
  359.     }
  361.     /**
  362.      * @return Collection<int, Archivearticle>
  363.      */
  364.     public function getArchivearticles(): Collection
  365.     {
  366.         return $this->archivearticles;
  367.     }
  369.     public function addArchivearticle(Archivearticle $archivearticle): static
  370.     {
  371.         if (!$this->archivearticles->contains($archivearticle)) {
  372.             $this->archivearticles->add($archivearticle);
  373.             $archivearticle->setFournisseur($this);
  374.         }
  376.         return $this;
  377.     }
  379.     public function removeArchivearticle(Archivearticle $archivearticle): static
  380.     {
  381.         if ($this->archivearticles->removeElement($archivearticle)) {
  382.             // set the owning side to null (unless already changed)
  383.             if ($archivearticle->getFournisseur() === $this) {
  384.                 $archivearticle->setFournisseur(null);
  385.             }
  386.         }
  388.         return $this;
  389.     }
  391.     /**
  392.      * @return Collection<int, Importdirect>
  393.      */
  394.     public function getImportdirects(): Collection
  395.     {
  396.         return $this->importdirects;
  397.     }
  399.     public function addImportdirect(Importdirect $importdirect): static
  400.     {
  401.         if (!$this->importdirects->contains($importdirect)) {
  402.             $this->importdirects->add($importdirect);
  403.             $importdirect->setFournisseur($this);
  404.         }
  406.         return $this;
  407.     }
  409.     public function removeImportdirect(Importdirect $importdirect): static
  410.     {
  411.         if ($this->importdirects->removeElement($importdirect)) {
  412.             // set the owning side to null (unless already changed)
  413.             if ($importdirect->getFournisseur() === $this) {
  414.                 $importdirect->setFournisseur(null);
  415.             }
  416.         }
  418.         return $this;
  419.     }
  421.     /**
  422.      * @return Collection<int, Banque>
  423.      */
  424.     public function getBanque(): Collection
  425.     {
  426.         return $this->banque;
  427.     }
  429.     public function addBanque(Banque $banque): static
  430.     {
  431.         if (!$this->banque->contains($banque)) {
  432.             $this->banque->add($banque);
  433.         }
  435.         return $this;
  436.     }
  438.     public function removeBanque(Banque $banque): static
  439.     {
  440.         $this->banque->removeElement($banque);
  442.         return $this;
  443.     }
  445.     /**
  446.      * @return Collection<int, Devis>
  447.      */
  448.     public function getDevis(): Collection
  449.     {
  450.         return $this->devis;
  451.     }
  453.     public function addDevi(Devis $devi): static
  454.     {
  455.         if (!$this->devis->contains($devi)) {
  456.             $this->devis->add($devi);
  457.             $devi->setFournisseur($this);
  458.         }
  460.         return $this;
  461.     }
  463.     public function removeDevi(Devis $devi): static
  464.     {
  465.         if ($this->devis->removeElement($devi)) {
  466.             // set the owning side to null (unless already changed)
  467.             if ($devi->getFournisseur() === $this) {
  468.                 $devi->setFournisseur(null);
  469.             }
  470.         }
  472.         return $this;
  473.     }
  477.     /**
  478.      * @return Collection<int, Ficheachatnf>
  479.      */
  480.     public function getFicheachatnfs(): Collection
  481.     {
  482.         return $this->ficheachatnfs;
  483.     }
  485.     public function addFicheachatnf(Ficheachatnf $ficheachatnf): self
  486.     {
  487.         if (!$this->ficheachatnfs->contains($ficheachatnf)) {
  488.             $this->ficheachatnfs->add($ficheachatnf);
  489.             $ficheachatnf->setFournisseur($this);
  490.         }
  492.         return $this;
  493.     }
  495.     public function removeFicheachatnf(Ficheachatnf $ficheachatnf): self
  496.     {
  497.         if ($this->ficheachatnfs->removeElement($ficheachatnf)) {
  498.             // set the owning side to null (unless already changed)
  499.             if ($ficheachatnf->getFournisseur() === $this) {
  500.                 $ficheachatnf->setFournisseur(null);
  501.             }
  502.         }
  504.         return $this;
  505.     }
  507. }