src/Entity/IctusPharmacie.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use DateTime;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Validator\Constraints as CustomAssert;
  8. use Doctrine\Common\Collections\Collection;
  9. use App\Repository\IctusPharmacieRepository;
  10. use Doctrine\Common\Collections\ArrayCollection;
  11. use Symfony\Component\Validator\Constraints as Assert;
  12. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  14. /**
  15.  * @ORM\Entity(repositoryClass=IctusPharmacieRepository::class)
  16.  * @UniqueEntity(fields = {"pagename"},message ="Page existe déjà existe")
  17.  */
  18. class IctusPharmacie
  19. {
  20.     /**
  21.      * @ORM\Id
  22.      * @ORM\GeneratedValue
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  27.     /**
  28.      * @ORM\Column(type="string", length=255, nullable=true)
  29.      */
  30.     private $uuid;
  32.     /**
  33.      * @ORM\Column(type="string", length=255)
  34.      */
  35.     private $designation;
  37.     /**
  38.      * @ORM\Column(type="string", length=255, nullable=true)
  39.      */
  40.     private $logo;
  42.     /**
  43.      * @ORM\Column(type="string", length=255, nullable=true)
  44.      */
  45.     private $numeroordre;
  47.     /**
  48.      * @ORM\Column(type="string", length=255, nullable=true)
  49.      */
  50.     private $nif;
  52.     /**
  53.      * @ORM\Column(type="string", length=255, nullable=true)
  54.      */
  55.     private $stat;
  57.     /**
  58.      * @ORM\Column(type="boolean", nullable=true)
  59.      */
  60.     private $isValid = false;
  62.     /**
  63.      * @ORM\Column(type="float", nullable=true)
  64.      */
  65.     private $logitude;
  67.     /**
  68.      * @ORM\Column(type="float", nullable=true)
  69.      */
  70.     private $latitude;
  72.     /**
  73.      * @ORM\OneToMany(targetEntity=Stockpharmacie::class, mappedBy="ictuspharmacie")
  74.      */
  75.     private $stockpharmacies;
  77.     /**
  78.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="ictusPharmacie")
  79.      */
  80.     private $users;
  82.     /**
  83.      * @ORM\Column(type="string", length=255, nullable=true)
  84.      */
  85.     private $adresse;
  87.     /**
  88.      * @ORM\ManyToOne(targetEntity=Quartier::class, inversedBy="ictusPharmacies")
  89.      */
  90.     private $quartier;
  92.     /**
  93.      * @ORM\OneToMany(targetEntity=LivraisonPharmacie::class, mappedBy="ictus_pharmacie")
  94.      */
  95.     private $livraisonPharmacies;
  97.     /**
  98.      * @ORM\OneToMany(targetEntity=IctusPaiementPharmacie::class, mappedBy="pharmacie")
  99.      */
  100.     private $ictusPaiementPharmacies;
  102.     /**
  103.      * @ORM\OneToMany(targetEntity=IctusHoraire::class, mappedBy="ictus_pharmacie")
  104.      */
  105.     private $ictusHoraires;
  107.     /**
  108.      * @ORM\OneToMany(targetEntity=IctusCommande::class, mappedBy="pharmacie")
  109.      */
  110.     private $ictusCommandes;
  112.     private $distanceParRapportPatient;
  114.     /**
  115.      * @ORM\Column(type="string", length=255, nullable=true)
  116.      */
  117.     private $photocouverture;
  119.     /**
  120.      * @ORM\Column(type="string", length=255, nullable=true)
  121.      */
  122.     private $pagename;
  124.     /**
  125.      * @ORM\OneToMany(targetEntity=IctoRemboursement::class, mappedBy="demandeur", orphanRemoval=true)
  126.      */
  127.     private $ictoRemboursements;
  129.     /**
  130.      * @ORM\OneToMany(targetEntity=IctoParampov::class, mappedBy="pharmacie", orphanRemoval=true)
  131.      */
  132.     private $ictoParampovs;
  134.     /**
  135.      * @ORM\OneToMany(targetEntity=IctoMouvement::class, mappedBy="pharmacie", orphanRemoval=true)
  136.      */
  137.     private $ictoMouvements;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=AchatIctocoin::class, mappedBy="pharmacie", orphanRemoval=true)
  141.      */
  142.     private $achatIctocoins;
  144.     /**
  145.      * @ORM\OneToMany(targetEntity=IctusPanierSpecial::class, mappedBy="pharmacie", orphanRemoval=true)
  146.      */
  147.     private $ictusPanierSpecials;
  149.     /**
  150.      * @ORM\Column(type="boolean", nullable=true)
  151.      */
  152.     private $isCommandeSpecial;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=CommandeSpecial::class, mappedBy="pharmacie")
  156.      */
  157.     private $commandeSpecials;
  159.     /**
  160.      * @ORM\Column(type="boolean", nullable=true)
  161.      */
  162.     private $isValideAutomatique;
  164.     /**
  165.      * @ORM\Column(type="float", nullable=true)
  166.      */
  167.     private $pourcentageCommandeSpecial;
  169.     /**
  170.      * @ORM\OneToMany(targetEntity=FacturePatient::class, mappedBy="pharmacie", orphanRemoval=true)
  171.      */
  172.     private $facturePatients;
  174.     /**
  175.      * @ORM\Column(type="string", length=255, nullable=true)
  176.      */
  177.     private $rcs;
  179.     /**
  180.      * @ORM\OneToMany(targetEntity=ProductBlackList::class, mappedBy="pharmacie", orphanRemoval=true)
  181.      */
  182.     private $productBlackLists;
  184.     /**
  185.      * @ORM\OneToMany(targetEntity=HistoriqueMaj::class, mappedBy="pharmacie", orphanRemoval=true)
  186.      */
  187.     private $historiqueMajs;
  189.     /**
  190.      * @ORM\ManyToMany(targetEntity=Tierpayant::class, mappedBy="pharmacie")
  191.      */
  192.     private $tierpayants;
  194.     /**
  195.      * @ORM\OneToMany(targetEntity=Parcours::class, mappedBy="pharmacie")
  196.      */
  197.     private $parcours;
  199.     /**
  200.      * @ORM\Column(type="string", length=255, nullable=true)
  201.      */
  202.     private $mailResponsable;
  204.     /**
  205.      * @ORM\OneToMany(targetEntity=FacturePharmacie::class, mappedBy="pharmacie", orphanRemoval=true)
  206.      */
  207.     private $facturePharmacies;
  209.     /**
  210.      * @ORM\OneToMany(targetEntity=Rate::class, mappedBy="pharmacie")
  211.      */
  212.     private $rates;
  214.     /**
  215.      * @ORM\OneToMany(targetEntity=IctusReclamation::class, mappedBy="pharmacie")
  216.      */
  217.     private $ictusReclamations;
  219.     /**
  220.      * @ORM\Column(type="string", length=255, nullable=true)
  221.      */
  222.     private $realDesignation;
  224.     public function __construct()
  225.     {
  226.         $this->stockpharmacies = new ArrayCollection();
  227.         $this->users           = new ArrayCollection();
  228.         $this->uuid            = uniqid((new \DateTime())->format('YmdHis'));
  229.         $this->livraisonPharmacies = new ArrayCollection();
  230.         $this->ictusPaiementPharmacies = new ArrayCollection();
  231.         $this->ictusHoraires = new ArrayCollection();
  232.         $this->ictusCommandes = new ArrayCollection();
  233.         $this->ictoRemboursements = new ArrayCollection();
  234.         $this->ictoParampovs = new ArrayCollection();
  235.         $this->ictoMouvements = new ArrayCollection();
  236.         $this->achatIctocoins = new ArrayCollection();
  237.         $this->ictusPanierSpecials = new ArrayCollection();
  238.         $this->commandeSpecials = new ArrayCollection();
  239.         $this->facturePatients = new ArrayCollection();
  240.         $this->productBlackLists = new ArrayCollection();
  241.         $this->historiqueMajs = new ArrayCollection();
  242.         $this->tierpayants = new ArrayCollection();
  243.         $this->parcours = new ArrayCollection();
  244.         $this->facturePharmacies = new ArrayCollection();
  245.         $this->rates = new ArrayCollection();
  246.         $this->ictusReclamations = new ArrayCollection();
  247.     }
  249.     public function getId(): ?int
  250.     {
  251.         return $this->id;
  252.     }
  254.     public function setId($id) {
  255.         $this->id = $id;
  256.         return $this;
  257.     }
  260.     public function getUuid(): ?string
  261.     {
  262.         return $this->uuid;
  263.     }
  265.     public function setUuid(?string $uuid): self
  266.     {
  267.         $this->uuid = $uuid;
  269.         return $this;
  270.     }
  272.     public function getDesignation(): ?string
  273.     {
  274.         return $this->designation;
  275.     }
  277.     public function setDesignation(string $designation): self
  278.     {
  279.         $this->designation = $designation;
  281.         return $this;
  282.     }
  284.     public function getLogo(): ?string
  285.     {
  286.         return $this->logo;
  287.     }
  289.     public function setLogo(?string $logo): self
  290.     {
  291.         $this->logo = $logo;
  293.         return $this;
  294.     }
  296.     public function getNumeroordre(): ?string
  297.     {
  298.         return $this->numeroordre;
  299.     }
  301.     public function setNumeroordre(?string $numeroordre): self
  302.     {
  303.         $this->numeroordre = $numeroordre;
  305.         return $this;
  306.     }
  308.     public function getNif(): ?string
  309.     {
  310.         return $this->nif;
  311.     }
  313.     public function setNif(?string $nif): self
  314.     {
  315.         $this->nif = $nif;
  317.         return $this;
  318.     }
  320.     public function getStat(): ?string
  321.     {
  322.         return $this->stat;
  323.     }
  325.     public function setStat(?string $stat): self
  326.     {
  327.         $this->stat = $stat;
  329.         return $this;
  330.     }
  332.     public function isIsValid(): ?bool
  333.     {
  334.         return $this->isValid;
  335.     }
  337.     public function setIsValid(?bool $isValid): self
  338.     {
  339.         $this->isValid = $isValid;
  341.         return $this;
  342.     }
  344.     public function getLogitude(): ?float
  345.     {
  346.         return $this->logitude;
  347.     }
  349.     public function setLogitude(?float $logitude): self
  350.     {
  351.         $this->logitude = $logitude;
  353.         return $this;
  354.     }
  356.     public function getLatitude(): ?float
  357.     {
  358.         return $this->latitude;
  359.     }
  361.     public function setLatitude(?float $latitude): self
  362.     {
  363.         $this->latitude = $latitude;
  365.         return $this;
  366.     }
  368.     /**
  369.      * @return Collection<int, Stockpharmacie>
  370.      */
  371.     public function getStockpharmacies(): Collection
  372.     {
  373.         return $this->stockpharmacies;
  374.     }
  376.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  377.     {
  378.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  379.             $this->stockpharmacies[] = $stockpharmacy;
  380.             $stockpharmacy->setIctuspharmacie($this);
  381.         }
  383.         return $this;
  384.     }
  386.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  387.     {
  388.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  389.             // set the owning side to null (unless already changed)
  390.             if ($stockpharmacy->getIctuspharmacie() === $this) {
  391.                 $stockpharmacy->setIctuspharmacie(null);
  392.             }
  393.         }
  395.         return $this;
  396.     }
  398.     /**
  399.      * @return Collection<int, User>
  400.      */
  401.     public function getUsers(): Collection
  402.     {
  403.         return $this->users;
  404.     }
  406.     public function addUser(User $user): self
  407.     {
  408.         if (!$this->users->contains($user)) {
  409.             $this->users[] = $user;
  410.             $user->setIctusPharmacie($this);
  411.         }
  413.         return $this;
  414.     }
  416.     public function removeUser(User $user): self
  417.     {
  418.         if ($this->users->removeElement($user)) {
  419.             // set the owning side to null (unless already changed)
  420.             if ($user->getIctusPharmacie() === $this) {
  421.                 $user->setIctusPharmacie(null);
  422.             }
  423.         }
  425.         return $this;
  426.     }
  428.     public function getAdresse(): ?string
  429.     {
  430.         return $this->adresse;
  431.     }
  433.     public function setAdresse(?string $adresse): self
  434.     {
  435.         $this->adresse = $adresse;
  437.         return $this;
  438.     }
  440.     public function getQuartier(): ?Quartier
  441.     {
  442.         return $this->quartier;
  443.     }
  445.     public function setQuartier(?Quartier $quartier): self
  446.     {
  447.         $this->quartier = $quartier;
  449.         return $this;
  450.     }
  452.     /**
  453.      * @return Collection<int, LivraisonPharmacie>
  454.      */
  455.     public function getLivraisonPharmacies(): Collection
  456.     {
  457.         return $this->livraisonPharmacies;
  458.     }
  460.     public function addLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  461.     {
  462.         if (!$this->livraisonPharmacies->contains($livraisonPharmacy)) {
  463.             $this->livraisonPharmacies[] = $livraisonPharmacy;
  464.             $livraisonPharmacy->setIctusPharmacie($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  471.     {
  472.         if ($this->livraisonPharmacies->removeElement($livraisonPharmacy)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($livraisonPharmacy->getIctusPharmacie() === $this) {
  475.                 $livraisonPharmacy->setIctusPharmacie(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, IctusPaiementPharmacie>
  484.      */
  485.     public function getIctusPaiementPharmacies(): Collection
  486.     {
  487.         return $this->ictusPaiementPharmacies;
  488.     }
  490.     public function addIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  491.     {
  492.         if (!$this->ictusPaiementPharmacies->contains($ictusPaiementPharmacy)) {
  493.             $this->ictusPaiementPharmacies[] = $ictusPaiementPharmacy;
  494.             $ictusPaiementPharmacy->setPharmacie($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  501.     {
  502.         if ($this->ictusPaiementPharmacies->removeElement($ictusPaiementPharmacy)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($ictusPaiementPharmacy->getPharmacie() === $this) {
  505.                 $ictusPaiementPharmacy->setPharmacie(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, IctusHoraire>
  514.      */
  515.     public function getIctusHoraires(): Collection
  516.     {
  517.         return $this->ictusHoraires;
  518.     }
  520.     public function addIctusHoraire(IctusHoraire $ictusHoraire): self
  521.     {
  522.         if (!$this->ictusHoraires->contains($ictusHoraire)) {
  523.             $this->ictusHoraires[] = $ictusHoraire;
  524.             $ictusHoraire->setIctusPharmacie($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeIctusHoraire(IctusHoraire $ictusHoraire): self
  531.     {
  532.         if ($this->ictusHoraires->removeElement($ictusHoraire)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($ictusHoraire->getIctusPharmacie() === $this) {
  535.                 $ictusHoraire->setIctusPharmacie(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     /**
  543.      * @return Collection<int, IctusCommande>
  544.      */
  545.     public function getIctusCommandes(): Collection
  546.     {
  547.         return $this->ictusCommandes;
  548.     }
  550.     public function addIctusCommande(IctusCommande $ictusCommande): self
  551.     {
  552.         if (!$this->ictusCommandes->contains($ictusCommande)) {
  553.             $this->ictusCommandes[] = $ictusCommande;
  554.             $ictusCommande->setPharmacie($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeIctusCommande(IctusCommande $ictusCommande): self
  561.     {
  562.         if ($this->ictusCommandes->removeElement($ictusCommande)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($ictusCommande->getPharmacie() === $this) {
  565.                 $ictusCommande->setPharmacie(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  572.     /**
  573.      * Get the value of distanceParRapportPatient
  574.      */ 
  575.     public function getDistanceParRapportPatient()
  576.     {
  577.         return $this->distanceParRapportPatient;
  578.     }
  580.     /**
  581.      * Set the value of distanceParRapportPatient
  582.      *
  583.      * @return  self
  584.      */ 
  585.     public function setDistanceParRapportPatient($distanceParRapportPatient)
  586.     {
  587.         $this->distanceParRapportPatient = $distanceParRapportPatient;
  589.         return $this;
  590.     }
  592.     public function getPhotocouverture(): ?string
  593.     {
  594.         return $this->photocouverture;
  595.     }
  597.     public function setPhotocouverture(?string $photocouverture): self
  598.     {
  599.         $this->photocouverture = $photocouverture;
  601.         return $this;
  602.     }
  604.     public function getPagename(): ?string
  605.     {
  606.         return $this->pagename;
  607.     }
  609.     public function setPagename(?string $pagename): self
  610.     {
  611.         $this->pagename = $pagename;
  613.         return $this;
  614.     }
  616.     /**
  617.      * @return Collection<int, IctoRemboursement>
  618.      */
  619.     public function getIctoRemboursements(): Collection
  620.     {
  621.         return $this->ictoRemboursements;
  622.     }
  624.     public function addIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  625.     {
  626.         if (!$this->ictoRemboursements->contains($ictoRemboursement)) {
  627.             $this->ictoRemboursements[] = $ictoRemboursement;
  628.             $ictoRemboursement->setDemandeur($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  635.     {
  636.         if ($this->ictoRemboursements->removeElement($ictoRemboursement)) {
  637.             // set the owning side to null (unless already changed)
  638.             if ($ictoRemboursement->getDemandeur() === $this) {
  639.                 $ictoRemboursement->setDemandeur(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection<int, IctoParampov>
  648.      */
  649.     public function getIctoParampovs(): Collection
  650.     {
  651.         return $this->ictoParampovs;
  652.     }
  654.     public function addIctoParampov(IctoParampov $ictoParampov): self
  655.     {
  656.         if (!$this->ictoParampovs->contains($ictoParampov)) {
  657.             $this->ictoParampovs[] = $ictoParampov;
  658.             $ictoParampov->setPharmacie($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removeIctoParampov(IctoParampov $ictoParampov): self
  665.     {
  666.         if ($this->ictoParampovs->removeElement($ictoParampov)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($ictoParampov->getPharmacie() === $this) {
  669.                 $ictoParampov->setPharmacie(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  676.     /**
  677.      * @return Collection<int, IctoMouvement>
  678.      */
  679.     public function getIctoMouvements(): Collection
  680.     {
  681.         return $this->ictoMouvements;
  682.     }
  684.     public function addIctoMouvement(IctoMouvement $ictoMouvement): self
  685.     {
  686.         if (!$this->ictoMouvements->contains($ictoMouvement)) {
  687.             $this->ictoMouvements[] = $ictoMouvement;
  688.             $ictoMouvement->setPharmacie($this);
  689.         }
  691.         return $this;
  692.     }
  694.     public function removeIctoMouvement(IctoMouvement $ictoMouvement): self
  695.     {
  696.         if ($this->ictoMouvements->removeElement($ictoMouvement)) {
  697.             // set the owning side to null (unless already changed)
  698.             if ($ictoMouvement->getPharmacie() === $this) {
  699.                 $ictoMouvement->setPharmacie(null);
  700.             }
  701.         }
  703.         return $this;
  704.     }
  706.     /**
  707.      * @return Collection<int, AchatIctocoin>
  708.      */
  709.     public function getAchatIctocoins(): Collection
  710.     {
  711.         return $this->achatIctocoins;
  712.     }
  714.     public function addAchatIctocoin(AchatIctocoin $achatIctocoin): self
  715.     {
  716.         if (!$this->achatIctocoins->contains($achatIctocoin)) {
  717.             $this->achatIctocoins[] = $achatIctocoin;
  718.             $achatIctocoin->setPharmacie($this);
  719.         }
  721.         return $this;
  722.     }
  724.     public function removeAchatIctocoin(AchatIctocoin $achatIctocoin): self
  725.     {
  726.         if ($this->achatIctocoins->removeElement($achatIctocoin)) {
  727.             // set the owning side to null (unless already changed)
  728.             if ($achatIctocoin->getPharmacie() === $this) {
  729.                 $achatIctocoin->setPharmacie(null);
  730.             }
  731.         }
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return Collection<int, IctusPanierSpecial>
  738.      */
  739.     public function getIctusPanierSpecials(): Collection
  740.     {
  741.         return $this->ictusPanierSpecials;
  742.     }
  744.     public function addIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  745.     {
  746.         if (!$this->ictusPanierSpecials->contains($ictusPanierSpecial)) {
  747.             $this->ictusPanierSpecials[] = $ictusPanierSpecial;
  748.             $ictusPanierSpecial->setPharmacie($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  755.     {
  756.         if ($this->ictusPanierSpecials->removeElement($ictusPanierSpecial)) {
  757.             // set the owning side to null (unless already changed)
  758.             if ($ictusPanierSpecial->getPharmacie() === $this) {
  759.                 $ictusPanierSpecial->setPharmacie(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     public function isIsCommandeSpecial(): ?bool
  767.     {
  768.         return $this->isCommandeSpecial;
  769.     }
  771.     public function setIsCommandeSpecial(?bool $isCommandeSpecial): self
  772.     {
  773.         $this->isCommandeSpecial = $isCommandeSpecial;
  775.         return $this;
  776.     }
  778.     /**
  779.      * @return Collection<int, CommandeSpecial>
  780.      */
  781.     public function getCommandeSpecials(): Collection
  782.     {
  783.         return $this->commandeSpecials;
  784.     }
  786.     public function addCommandeSpecial(CommandeSpecial $commandeSpecial): self
  787.     {
  788.         if (!$this->commandeSpecials->contains($commandeSpecial)) {
  789.             $this->commandeSpecials[] = $commandeSpecial;
  790.             $commandeSpecial->setPharmacie($this);
  791.         }
  793.         return $this;
  794.     }
  796.     public function removeCommandeSpecial(CommandeSpecial $commandeSpecial): self
  797.     {
  798.         if ($this->commandeSpecials->removeElement($commandeSpecial)) {
  799.             // set the owning side to null (unless already changed)
  800.             if ($commandeSpecial->getPharmacie() === $this) {
  801.                 $commandeSpecial->setPharmacie(null);
  802.             }
  803.         }
  805.         return $this;
  806.     }
  808.     public function isIsValideAutomatique(): ?bool
  809.     {
  810.         return $this->isValideAutomatique;
  811.     }
  813.     public function setIsValideAutomatique(?bool $isValideAutomatique): self
  814.     {
  815.         $this->isValideAutomatique = $isValideAutomatique;
  817.         return $this;
  818.     }
  820.     public function getPourcentageCommandeSpecial(): ?float
  821.     {
  822.         return $this->pourcentageCommandeSpecial;
  823.     }
  825.     public function setPourcentageCommandeSpecial(?float $pourcentageCommandeSpecial): self
  826.     {
  827.         $this->pourcentageCommandeSpecial = $pourcentageCommandeSpecial;
  829.         return $this;
  830.     }
  832.     /**
  833.      * @return Collection<int, FacturePatient>
  834.      */
  835.     public function getFacturePatients(): Collection
  836.     {
  837.         return $this->facturePatients;
  838.     }
  840.     public function addFacturePatient(FacturePatient $facturePatient): self
  841.     {
  842.         if (!$this->facturePatients->contains($facturePatient)) {
  843.             $this->facturePatients[] = $facturePatient;
  844.             $facturePatient->setPharmacie($this);
  845.         }
  847.         return $this;
  848.     }
  850.     public function removeFacturePatient(FacturePatient $facturePatient): self
  851.     {
  852.         if ($this->facturePatients->removeElement($facturePatient)) {
  853.             // set the owning side to null (unless already changed)
  854.             if ($facturePatient->getPharmacie() === $this) {
  855.                 $facturePatient->setPharmacie(null);
  856.             }
  857.         }
  859.         return $this;
  860.     }
  862.     public function getRcs(): ?string
  863.     {
  864.         return $this->rcs;
  865.     }
  867.     public function setRcs(?string $rcs): self
  868.     {
  869.         $this->rcs = $rcs;
  871.         return $this;
  872.     }
  874.     /**
  875.      * @return Collection<int, ProductBlackList>
  876.      */
  877.     public function getProductBlackLists(): Collection
  878.     {
  879.         return $this->productBlackLists;
  880.     }
  882.     public function addProductBlackList(ProductBlackList $productBlackList): self
  883.     {
  884.         if (!$this->productBlackLists->contains($productBlackList)) {
  885.             $this->productBlackLists[] = $productBlackList;
  886.             $productBlackList->setPharmacie($this);
  887.         }
  889.         return $this;
  890.     }
  892.     public function removeProductBlackList(ProductBlackList $productBlackList): self
  893.     {
  894.         if ($this->productBlackLists->removeElement($productBlackList)) {
  895.             // set the owning side to null (unless already changed)
  896.             if ($productBlackList->getPharmacie() === $this) {
  897.                 $productBlackList->setPharmacie(null);
  898.             }
  899.         }
  901.         return $this;
  902.     }
  904.     /**
  905.      * @return Collection<int, HistoriqueMaj>
  906.      */
  907.     public function getHistoriqueMajs(): Collection
  908.     {
  909.         return $this->historiqueMajs;
  910.     }
  912.     public function addHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  913.     {
  914.         if (!$this->historiqueMajs->contains($historiqueMaj)) {
  915.             $this->historiqueMajs[] = $historiqueMaj;
  916.             $historiqueMaj->setPharmacie($this);
  917.         }
  919.         return $this;
  920.     }
  922.     public function removeHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  923.     {
  924.         if ($this->historiqueMajs->removeElement($historiqueMaj)) {
  925.             // set the owning side to null (unless already changed)
  926.             if ($historiqueMaj->getPharmacie() === $this) {
  927.                 $historiqueMaj->setPharmacie(null);
  928.             }
  929.         }
  931.         return $this;
  932.     }
  934.     /**
  935.      * @return Collection<int, Tierpayant>
  936.      */
  937.     public function getTierpayants(): Collection
  938.     {
  939.         return $this->tierpayants;
  940.     }
  942.     public function addTierpayant(Tierpayant $tierpayant): self
  943.     {
  944.         if (!$this->tierpayants->contains($tierpayant)) {
  945.             $this->tierpayants[] = $tierpayant;
  946.             $tierpayant->addPharmacie($this);
  947.         }
  949.         return $this;
  950.     }
  952.     public function removeTierpayant(Tierpayant $tierpayant): self
  953.     {
  954.         if ($this->tierpayants->removeElement($tierpayant)) {
  955.             $tierpayant->removePharmacie($this);
  956.         }
  958.         return $this;
  959.     }
  961.     public function getMailResponsable(): ?string
  962.     {
  963.         return $this->mailResponsable;
  964.     }
  966.     public function setMailResponsable(?string $mailResponsable): self
  967.     {
  968.         $this->mailResponsable = $mailResponsable;
  970.         return $this;
  971.     }
  973.     /**
  974.      * @return Collection<int, FacturePharmacie>
  975.      */
  976.     public function getFacturePharmacies(): Collection
  977.     {
  978.         return $this->facturePharmacies;
  979.     }
  981.     public function addFacturePharmacy(FacturePharmacie $facturePharmacy): self
  982.     {
  983.         if (!$this->facturePharmacies->contains($facturePharmacy)) {
  984.             $this->facturePharmacies[] = $facturePharmacy;
  985.             $facturePharmacy->setPharmacie($this);
  986.         }
  988.         return $this;
  989.     }
  991.     public function removeFacturePharmacy(FacturePharmacie $facturePharmacy): self
  992.     {
  993.         if ($this->facturePharmacies->removeElement($facturePharmacy)) {
  994.             // set the owning side to null (unless already changed)
  995.             if ($facturePharmacy->getPharmacie() === $this) {
  996.                 $facturePharmacy->setPharmacie(null);
  997.             }
  998.         }
  1000.         return $this;
  1001.     }
  1003.     /**
  1004.      * @return Collection<int, Rate>
  1005.      */
  1006.     public function getRates(): Collection
  1007.     {
  1008.         return $this->rates;
  1009.     }
  1011.     public function addRate(Rate $rate): self
  1012.     {
  1013.         if (!$this->rates->contains($rate)) {
  1014.             $this->rates[] = $rate;
  1015.             $rate->setPharmacie($this);
  1016.         }
  1018.         return $this;
  1019.     }
  1021.     public function removeRate(Rate $rate): self
  1022.     {
  1023.         if ($this->rates->removeElement($rate)) {
  1024.             // set the owning side to null (unless already changed)
  1025.             if ($rate->getPharmacie() === $this) {
  1026.                 $rate->setPharmacie(null);
  1027.             }
  1028.         }
  1030.         return $this;
  1031.     }
  1033.     /**
  1034.      * @return Collection<int, IctusReclamation>
  1035.      */
  1036.     public function getIctusReclamations(): Collection
  1037.     {
  1038.         return $this->ictusReclamations;
  1039.     }
  1041.     public function addIctusReclamation(IctusReclamation $ictusReclamation): self
  1042.     {
  1043.         if (!$this->ictusReclamations->contains($ictusReclamation)) {
  1044.             $this->ictusReclamations[] = $ictusReclamation;
  1045.             $ictusReclamation->setPharmacie($this);
  1046.         }
  1048.         return $this;
  1049.     }
  1051.     public function removeIctusReclamation(IctusReclamation $ictusReclamation): self
  1052.     {
  1053.         if ($this->ictusReclamations->removeElement($ictusReclamation)) {
  1054.             // set the owning side to null (unless already changed)
  1055.             if ($ictusReclamation->getPharmacie() === $this) {
  1056.                 $ictusReclamation->setPharmacie(null);
  1057.             }
  1058.         }
  1060.         return $this;
  1061.     }
  1063.     public function getRealDesignation(): ?string
  1064.     {
  1065.         return $this->realDesignation;
  1066.     }
  1068.     public function setRealDesignation(?string $realDesignation): self
  1069.     {
  1070.         $this->realDesignation = $realDesignation;
  1072.         return $this;
  1073.     }
  1074. }