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.     /**
  225.      * @ORM\OneToMany(targetEntity=RemiseUserPharmacie::class, mappedBy="pharmacie")
  226.      */
  227.     private $remiseUserPharmacies;
  229.     /**
  230.      * @ORM\ManyToMany(targetEntity=Assurance::class, mappedBy="pharmacie")
  231.      */
  232.     private $assurances;
  234.     public function __construct()
  235.     {
  236.         $this->stockpharmacies = new ArrayCollection();
  237.         $this->users           = new ArrayCollection();
  238.         $this->uuid            = uniqid((new \DateTime())->format('YmdHis'));
  239.         $this->livraisonPharmacies = new ArrayCollection();
  240.         $this->ictusPaiementPharmacies = new ArrayCollection();
  241.         $this->ictusHoraires = new ArrayCollection();
  242.         $this->ictusCommandes = new ArrayCollection();
  243.         $this->ictoRemboursements = new ArrayCollection();
  244.         $this->ictoParampovs = new ArrayCollection();
  245.         $this->ictoMouvements = new ArrayCollection();
  246.         $this->achatIctocoins = new ArrayCollection();
  247.         $this->ictusPanierSpecials = new ArrayCollection();
  248.         $this->commandeSpecials = new ArrayCollection();
  249.         $this->facturePatients = new ArrayCollection();
  250.         $this->productBlackLists = new ArrayCollection();
  251.         $this->historiqueMajs = new ArrayCollection();
  252.         $this->tierpayants = new ArrayCollection();
  253.         $this->parcours = new ArrayCollection();
  254.         $this->facturePharmacies = new ArrayCollection();
  255.         $this->rates = new ArrayCollection();
  256.         $this->ictusReclamations = new ArrayCollection();
  257.         $this->remiseUserPharmacies = new ArrayCollection();
  258.         $this->assurances = new ArrayCollection();
  259.     }
  261.     public function getId(): ?int
  262.     {
  263.         return $this->id;
  264.     }
  266.     public function setId($id)
  267.     {
  268.         $this->id = $id;
  269.         return $this;
  270.     }
  273.     public function getUuid(): ?string
  274.     {
  275.         return $this->uuid;
  276.     }
  278.     public function setUuid(?string $uuid): self
  279.     {
  280.         $this->uuid = $uuid;
  282.         return $this;
  283.     }
  285.     public function getDesignation(): ?string
  286.     {
  287.         return $this->designation;
  288.     }
  290.     public function setDesignation(string $designation): self
  291.     {
  292.         $this->designation = $designation;
  294.         return $this;
  295.     }
  297.     public function getLogo(): ?string
  298.     {
  299.         return $this->logo;
  300.     }
  302.     public function setLogo(?string $logo): self
  303.     {
  304.         $this->logo = $logo;
  306.         return $this;
  307.     }
  309.     public function getNumeroordre(): ?string
  310.     {
  311.         return $this->numeroordre;
  312.     }
  314.     public function setNumeroordre(?string $numeroordre): self
  315.     {
  316.         $this->numeroordre = $numeroordre;
  318.         return $this;
  319.     }
  321.     public function getNif(): ?string
  322.     {
  323.         return $this->nif;
  324.     }
  326.     public function setNif(?string $nif): self
  327.     {
  328.         $this->nif = $nif;
  330.         return $this;
  331.     }
  333.     public function getStat(): ?string
  334.     {
  335.         return $this->stat;
  336.     }
  338.     public function setStat(?string $stat): self
  339.     {
  340.         $this->stat = $stat;
  342.         return $this;
  343.     }
  345.     public function isIsValid(): ?bool
  346.     {
  347.         return $this->isValid;
  348.     }
  350.     public function setIsValid(?bool $isValid): self
  351.     {
  352.         $this->isValid = $isValid;
  354.         return $this;
  355.     }
  357.     public function getLogitude(): ?float
  358.     {
  359.         return $this->logitude;
  360.     }
  362.     public function setLogitude(?float $logitude): self
  363.     {
  364.         $this->logitude = $logitude;
  366.         return $this;
  367.     }
  369.     public function getLatitude(): ?float
  370.     {
  371.         return $this->latitude;
  372.     }
  374.     public function setLatitude(?float $latitude): self
  375.     {
  376.         $this->latitude = $latitude;
  378.         return $this;
  379.     }
  381.     /**
  382.      * @return Collection<int, Stockpharmacie>
  383.      */
  384.     public function getStockpharmacies(): Collection
  385.     {
  386.         return $this->stockpharmacies;
  387.     }
  389.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  390.     {
  391.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  392.             $this->stockpharmacies[] = $stockpharmacy;
  393.             $stockpharmacy->setIctuspharmacie($this);
  394.         }
  396.         return $this;
  397.     }
  399.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  400.     {
  401.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  402.             // set the owning side to null (unless already changed)
  403.             if ($stockpharmacy->getIctuspharmacie() === $this) {
  404.                 $stockpharmacy->setIctuspharmacie(null);
  405.             }
  406.         }
  408.         return $this;
  409.     }
  411.     /**
  412.      * @return Collection<int, User>
  413.      */
  414.     public function getUsers(): Collection
  415.     {
  416.         return $this->users;
  417.     }
  419.     public function addUser(User $user): self
  420.     {
  421.         if (!$this->users->contains($user)) {
  422.             $this->users[] = $user;
  423.             $user->setIctusPharmacie($this);
  424.         }
  426.         return $this;
  427.     }
  429.     public function removeUser(User $user): self
  430.     {
  431.         if ($this->users->removeElement($user)) {
  432.             // set the owning side to null (unless already changed)
  433.             if ($user->getIctusPharmacie() === $this) {
  434.                 $user->setIctusPharmacie(null);
  435.             }
  436.         }
  438.         return $this;
  439.     }
  441.     public function getAdresse(): ?string
  442.     {
  443.         return $this->adresse;
  444.     }
  446.     public function setAdresse(?string $adresse): self
  447.     {
  448.         $this->adresse = $adresse;
  450.         return $this;
  451.     }
  453.     public function getQuartier(): ?Quartier
  454.     {
  455.         return $this->quartier;
  456.     }
  458.     public function setQuartier(?Quartier $quartier): self
  459.     {
  460.         $this->quartier = $quartier;
  462.         return $this;
  463.     }
  465.     /**
  466.      * @return Collection<int, LivraisonPharmacie>
  467.      */
  468.     public function getLivraisonPharmacies(): Collection
  469.     {
  470.         return $this->livraisonPharmacies;
  471.     }
  473.     public function addLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  474.     {
  475.         if (!$this->livraisonPharmacies->contains($livraisonPharmacy)) {
  476.             $this->livraisonPharmacies[] = $livraisonPharmacy;
  477.             $livraisonPharmacy->setIctusPharmacie($this);
  478.         }
  480.         return $this;
  481.     }
  483.     public function removeLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  484.     {
  485.         if ($this->livraisonPharmacies->removeElement($livraisonPharmacy)) {
  486.             // set the owning side to null (unless already changed)
  487.             if ($livraisonPharmacy->getIctusPharmacie() === $this) {
  488.                 $livraisonPharmacy->setIctusPharmacie(null);
  489.             }
  490.         }
  492.         return $this;
  493.     }
  495.     /**
  496.      * @return Collection<int, IctusPaiementPharmacie>
  497.      */
  498.     public function getIctusPaiementPharmacies(): Collection
  499.     {
  500.         return $this->ictusPaiementPharmacies;
  501.     }
  503.     public function addIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  504.     {
  505.         if (!$this->ictusPaiementPharmacies->contains($ictusPaiementPharmacy)) {
  506.             $this->ictusPaiementPharmacies[] = $ictusPaiementPharmacy;
  507.             $ictusPaiementPharmacy->setPharmacie($this);
  508.         }
  510.         return $this;
  511.     }
  513.     public function removeIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  514.     {
  515.         if ($this->ictusPaiementPharmacies->removeElement($ictusPaiementPharmacy)) {
  516.             // set the owning side to null (unless already changed)
  517.             if ($ictusPaiementPharmacy->getPharmacie() === $this) {
  518.                 $ictusPaiementPharmacy->setPharmacie(null);
  519.             }
  520.         }
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection<int, IctusHoraire>
  527.      */
  528.     public function getIctusHoraires(): Collection
  529.     {
  530.         return $this->ictusHoraires;
  531.     }
  533.     public function addIctusHoraire(IctusHoraire $ictusHoraire): self
  534.     {
  535.         if (!$this->ictusHoraires->contains($ictusHoraire)) {
  536.             $this->ictusHoraires[] = $ictusHoraire;
  537.             $ictusHoraire->setIctusPharmacie($this);
  538.         }
  540.         return $this;
  541.     }
  543.     public function removeIctusHoraire(IctusHoraire $ictusHoraire): self
  544.     {
  545.         if ($this->ictusHoraires->removeElement($ictusHoraire)) {
  546.             // set the owning side to null (unless already changed)
  547.             if ($ictusHoraire->getIctusPharmacie() === $this) {
  548.                 $ictusHoraire->setIctusPharmacie(null);
  549.             }
  550.         }
  552.         return $this;
  553.     }
  555.     /**
  556.      * @return Collection<int, IctusCommande>
  557.      */
  558.     public function getIctusCommandes(): Collection
  559.     {
  560.         return $this->ictusCommandes;
  561.     }
  563.     public function addIctusCommande(IctusCommande $ictusCommande): self
  564.     {
  565.         if (!$this->ictusCommandes->contains($ictusCommande)) {
  566.             $this->ictusCommandes[] = $ictusCommande;
  567.             $ictusCommande->setPharmacie($this);
  568.         }
  570.         return $this;
  571.     }
  573.     public function removeIctusCommande(IctusCommande $ictusCommande): self
  574.     {
  575.         if ($this->ictusCommandes->removeElement($ictusCommande)) {
  576.             // set the owning side to null (unless already changed)
  577.             if ($ictusCommande->getPharmacie() === $this) {
  578.                 $ictusCommande->setPharmacie(null);
  579.             }
  580.         }
  582.         return $this;
  583.     }
  585.     /**
  586.      * Get the value of distanceParRapportPatient
  587.      */
  588.     public function getDistanceParRapportPatient()
  589.     {
  590.         return $this->distanceParRapportPatient;
  591.     }
  593.     /**
  594.      * Set the value of distanceParRapportPatient
  595.      *
  596.      * @return  self
  597.      */
  598.     public function setDistanceParRapportPatient($distanceParRapportPatient)
  599.     {
  600.         $this->distanceParRapportPatient = $distanceParRapportPatient;
  602.         return $this;
  603.     }
  605.     public function getPhotocouverture(): ?string
  606.     {
  607.         return $this->photocouverture;
  608.     }
  610.     public function setPhotocouverture(?string $photocouverture): self
  611.     {
  612.         $this->photocouverture = $photocouverture;
  614.         return $this;
  615.     }
  617.     public function getPagename(): ?string
  618.     {
  619.         return $this->pagename;
  620.     }
  622.     public function setPagename(?string $pagename): self
  623.     {
  624.         $this->pagename = $pagename;
  626.         return $this;
  627.     }
  629.     /**
  630.      * @return Collection<int, IctoRemboursement>
  631.      */
  632.     public function getIctoRemboursements(): Collection
  633.     {
  634.         return $this->ictoRemboursements;
  635.     }
  637.     public function addIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  638.     {
  639.         if (!$this->ictoRemboursements->contains($ictoRemboursement)) {
  640.             $this->ictoRemboursements[] = $ictoRemboursement;
  641.             $ictoRemboursement->setDemandeur($this);
  642.         }
  644.         return $this;
  645.     }
  647.     public function removeIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  648.     {
  649.         if ($this->ictoRemboursements->removeElement($ictoRemboursement)) {
  650.             // set the owning side to null (unless already changed)
  651.             if ($ictoRemboursement->getDemandeur() === $this) {
  652.                 $ictoRemboursement->setDemandeur(null);
  653.             }
  654.         }
  656.         return $this;
  657.     }
  659.     /**
  660.      * @return Collection<int, IctoParampov>
  661.      */
  662.     public function getIctoParampovs(): Collection
  663.     {
  664.         return $this->ictoParampovs;
  665.     }
  667.     public function addIctoParampov(IctoParampov $ictoParampov): self
  668.     {
  669.         if (!$this->ictoParampovs->contains($ictoParampov)) {
  670.             $this->ictoParampovs[] = $ictoParampov;
  671.             $ictoParampov->setPharmacie($this);
  672.         }
  674.         return $this;
  675.     }
  677.     public function removeIctoParampov(IctoParampov $ictoParampov): self
  678.     {
  679.         if ($this->ictoParampovs->removeElement($ictoParampov)) {
  680.             // set the owning side to null (unless already changed)
  681.             if ($ictoParampov->getPharmacie() === $this) {
  682.                 $ictoParampov->setPharmacie(null);
  683.             }
  684.         }
  686.         return $this;
  687.     }
  689.     /**
  690.      * @return Collection<int, IctoMouvement>
  691.      */
  692.     public function getIctoMouvements(): Collection
  693.     {
  694.         return $this->ictoMouvements;
  695.     }
  697.     public function addIctoMouvement(IctoMouvement $ictoMouvement): self
  698.     {
  699.         if (!$this->ictoMouvements->contains($ictoMouvement)) {
  700.             $this->ictoMouvements[] = $ictoMouvement;
  701.             $ictoMouvement->setPharmacie($this);
  702.         }
  704.         return $this;
  705.     }
  707.     public function removeIctoMouvement(IctoMouvement $ictoMouvement): self
  708.     {
  709.         if ($this->ictoMouvements->removeElement($ictoMouvement)) {
  710.             // set the owning side to null (unless already changed)
  711.             if ($ictoMouvement->getPharmacie() === $this) {
  712.                 $ictoMouvement->setPharmacie(null);
  713.             }
  714.         }
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return Collection<int, AchatIctocoin>
  721.      */
  722.     public function getAchatIctocoins(): Collection
  723.     {
  724.         return $this->achatIctocoins;
  725.     }
  727.     public function addAchatIctocoin(AchatIctocoin $achatIctocoin): self
  728.     {
  729.         if (!$this->achatIctocoins->contains($achatIctocoin)) {
  730.             $this->achatIctocoins[] = $achatIctocoin;
  731.             $achatIctocoin->setPharmacie($this);
  732.         }
  734.         return $this;
  735.     }
  737.     public function removeAchatIctocoin(AchatIctocoin $achatIctocoin): self
  738.     {
  739.         if ($this->achatIctocoins->removeElement($achatIctocoin)) {
  740.             // set the owning side to null (unless already changed)
  741.             if ($achatIctocoin->getPharmacie() === $this) {
  742.                 $achatIctocoin->setPharmacie(null);
  743.             }
  744.         }
  746.         return $this;
  747.     }
  749.     /**
  750.      * @return Collection<int, IctusPanierSpecial>
  751.      */
  752.     public function getIctusPanierSpecials(): Collection
  753.     {
  754.         return $this->ictusPanierSpecials;
  755.     }
  757.     public function addIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  758.     {
  759.         if (!$this->ictusPanierSpecials->contains($ictusPanierSpecial)) {
  760.             $this->ictusPanierSpecials[] = $ictusPanierSpecial;
  761.             $ictusPanierSpecial->setPharmacie($this);
  762.         }
  764.         return $this;
  765.     }
  767.     public function removeIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  768.     {
  769.         if ($this->ictusPanierSpecials->removeElement($ictusPanierSpecial)) {
  770.             // set the owning side to null (unless already changed)
  771.             if ($ictusPanierSpecial->getPharmacie() === $this) {
  772.                 $ictusPanierSpecial->setPharmacie(null);
  773.             }
  774.         }
  776.         return $this;
  777.     }
  779.     public function isIsCommandeSpecial(): ?bool
  780.     {
  781.         return $this->isCommandeSpecial;
  782.     }
  784.     public function setIsCommandeSpecial(?bool $isCommandeSpecial): self
  785.     {
  786.         $this->isCommandeSpecial = $isCommandeSpecial;
  788.         return $this;
  789.     }
  791.     /**
  792.      * @return Collection<int, CommandeSpecial>
  793.      */
  794.     public function getCommandeSpecials(): Collection
  795.     {
  796.         return $this->commandeSpecials;
  797.     }
  799.     public function addCommandeSpecial(CommandeSpecial $commandeSpecial): self
  800.     {
  801.         if (!$this->commandeSpecials->contains($commandeSpecial)) {
  802.             $this->commandeSpecials[] = $commandeSpecial;
  803.             $commandeSpecial->setPharmacie($this);
  804.         }
  806.         return $this;
  807.     }
  809.     public function removeCommandeSpecial(CommandeSpecial $commandeSpecial): self
  810.     {
  811.         if ($this->commandeSpecials->removeElement($commandeSpecial)) {
  812.             // set the owning side to null (unless already changed)
  813.             if ($commandeSpecial->getPharmacie() === $this) {
  814.                 $commandeSpecial->setPharmacie(null);
  815.             }
  816.         }
  818.         return $this;
  819.     }
  821.     public function isIsValideAutomatique(): ?bool
  822.     {
  823.         return $this->isValideAutomatique;
  824.     }
  826.     public function setIsValideAutomatique(?bool $isValideAutomatique): self
  827.     {
  828.         $this->isValideAutomatique = $isValideAutomatique;
  830.         return $this;
  831.     }
  833.     public function getPourcentageCommandeSpecial(): ?float
  834.     {
  835.         return $this->pourcentageCommandeSpecial;
  836.     }
  838.     public function setPourcentageCommandeSpecial(?float $pourcentageCommandeSpecial): self
  839.     {
  840.         $this->pourcentageCommandeSpecial = $pourcentageCommandeSpecial;
  842.         return $this;
  843.     }
  845.     /**
  846.      * @return Collection<int, FacturePatient>
  847.      */
  848.     public function getFacturePatients(): Collection
  849.     {
  850.         return $this->facturePatients;
  851.     }
  853.     public function addFacturePatient(FacturePatient $facturePatient): self
  854.     {
  855.         if (!$this->facturePatients->contains($facturePatient)) {
  856.             $this->facturePatients[] = $facturePatient;
  857.             $facturePatient->setPharmacie($this);
  858.         }
  860.         return $this;
  861.     }
  863.     public function removeFacturePatient(FacturePatient $facturePatient): self
  864.     {
  865.         if ($this->facturePatients->removeElement($facturePatient)) {
  866.             // set the owning side to null (unless already changed)
  867.             if ($facturePatient->getPharmacie() === $this) {
  868.                 $facturePatient->setPharmacie(null);
  869.             }
  870.         }
  872.         return $this;
  873.     }
  875.     public function getRcs(): ?string
  876.     {
  877.         return $this->rcs;
  878.     }
  880.     public function setRcs(?string $rcs): self
  881.     {
  882.         $this->rcs = $rcs;
  884.         return $this;
  885.     }
  887.     /**
  888.      * @return Collection<int, ProductBlackList>
  889.      */
  890.     public function getProductBlackLists(): Collection
  891.     {
  892.         return $this->productBlackLists;
  893.     }
  895.     public function addProductBlackList(ProductBlackList $productBlackList): self
  896.     {
  897.         if (!$this->productBlackLists->contains($productBlackList)) {
  898.             $this->productBlackLists[] = $productBlackList;
  899.             $productBlackList->setPharmacie($this);
  900.         }
  902.         return $this;
  903.     }
  905.     public function removeProductBlackList(ProductBlackList $productBlackList): self
  906.     {
  907.         if ($this->productBlackLists->removeElement($productBlackList)) {
  908.             // set the owning side to null (unless already changed)
  909.             if ($productBlackList->getPharmacie() === $this) {
  910.                 $productBlackList->setPharmacie(null);
  911.             }
  912.         }
  914.         return $this;
  915.     }
  917.     /**
  918.      * @return Collection<int, HistoriqueMaj>
  919.      */
  920.     public function getHistoriqueMajs(): Collection
  921.     {
  922.         return $this->historiqueMajs;
  923.     }
  925.     public function addHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  926.     {
  927.         if (!$this->historiqueMajs->contains($historiqueMaj)) {
  928.             $this->historiqueMajs[] = $historiqueMaj;
  929.             $historiqueMaj->setPharmacie($this);
  930.         }
  932.         return $this;
  933.     }
  935.     public function removeHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  936.     {
  937.         if ($this->historiqueMajs->removeElement($historiqueMaj)) {
  938.             // set the owning side to null (unless already changed)
  939.             if ($historiqueMaj->getPharmacie() === $this) {
  940.                 $historiqueMaj->setPharmacie(null);
  941.             }
  942.         }
  944.         return $this;
  945.     }
  947.     /**
  948.      * @return Collection<int, Tierpayant>
  949.      */
  950.     public function getTierpayants(): Collection
  951.     {
  952.         return $this->tierpayants;
  953.     }
  955.     public function addTierpayant(Tierpayant $tierpayant): self
  956.     {
  957.         if (!$this->tierpayants->contains($tierpayant)) {
  958.             $this->tierpayants[] = $tierpayant;
  959.             $tierpayant->addPharmacie($this);
  960.         }
  962.         return $this;
  963.     }
  965.     public function removeTierpayant(Tierpayant $tierpayant): self
  966.     {
  967.         if ($this->tierpayants->removeElement($tierpayant)) {
  968.             $tierpayant->removePharmacie($this);
  969.         }
  971.         return $this;
  972.     }
  974.     public function getMailResponsable(): ?string
  975.     {
  976.         return $this->mailResponsable;
  977.     }
  979.     public function setMailResponsable(?string $mailResponsable): self
  980.     {
  981.         $this->mailResponsable = $mailResponsable;
  983.         return $this;
  984.     }
  986.     /**
  987.      * @return Collection<int, FacturePharmacie>
  988.      */
  989.     public function getFacturePharmacies(): Collection
  990.     {
  991.         return $this->facturePharmacies;
  992.     }
  994.     public function addFacturePharmacy(FacturePharmacie $facturePharmacy): self
  995.     {
  996.         if (!$this->facturePharmacies->contains($facturePharmacy)) {
  997.             $this->facturePharmacies[] = $facturePharmacy;
  998.             $facturePharmacy->setPharmacie($this);
  999.         }
  1001.         return $this;
  1002.     }
  1004.     public function removeFacturePharmacy(FacturePharmacie $facturePharmacy): self
  1005.     {
  1006.         if ($this->facturePharmacies->removeElement($facturePharmacy)) {
  1007.             // set the owning side to null (unless already changed)
  1008.             if ($facturePharmacy->getPharmacie() === $this) {
  1009.                 $facturePharmacy->setPharmacie(null);
  1010.             }
  1011.         }
  1013.         return $this;
  1014.     }
  1016.     /**
  1017.      * @return Collection<int, Rate>
  1018.      */
  1019.     public function getRates(): Collection
  1020.     {
  1021.         return $this->rates;
  1022.     }
  1024.     public function addRate(Rate $rate): self
  1025.     {
  1026.         if (!$this->rates->contains($rate)) {
  1027.             $this->rates[] = $rate;
  1028.             $rate->setPharmacie($this);
  1029.         }
  1031.         return $this;
  1032.     }
  1034.     public function removeRate(Rate $rate): self
  1035.     {
  1036.         if ($this->rates->removeElement($rate)) {
  1037.             // set the owning side to null (unless already changed)
  1038.             if ($rate->getPharmacie() === $this) {
  1039.                 $rate->setPharmacie(null);
  1040.             }
  1041.         }
  1043.         return $this;
  1044.     }
  1046.     /**
  1047.      * @return Collection<int, IctusReclamation>
  1048.      */
  1049.     public function getIctusReclamations(): Collection
  1050.     {
  1051.         return $this->ictusReclamations;
  1052.     }
  1054.     public function addIctusReclamation(IctusReclamation $ictusReclamation): self
  1055.     {
  1056.         if (!$this->ictusReclamations->contains($ictusReclamation)) {
  1057.             $this->ictusReclamations[] = $ictusReclamation;
  1058.             $ictusReclamation->setPharmacie($this);
  1059.         }
  1061.         return $this;
  1062.     }
  1064.     public function removeIctusReclamation(IctusReclamation $ictusReclamation): self
  1065.     {
  1066.         if ($this->ictusReclamations->removeElement($ictusReclamation)) {
  1067.             // set the owning side to null (unless already changed)
  1068.             if ($ictusReclamation->getPharmacie() === $this) {
  1069.                 $ictusReclamation->setPharmacie(null);
  1070.             }
  1071.         }
  1073.         return $this;
  1074.     }
  1076.     public function getRealDesignation(): ?string
  1077.     {
  1078.         return $this->realDesignation;
  1079.     }
  1081.     public function setRealDesignation(?string $realDesignation): self
  1082.     {
  1083.         $this->realDesignation = $realDesignation;
  1085.         return $this;
  1086.     }
  1088.     /**
  1089.      * @return Collection<int, RemiseUserPharmacie>
  1090.      */
  1091.     public function getRemiseUserPharmacies(): Collection
  1092.     {
  1093.         return $this->remiseUserPharmacies;
  1094.     }
  1096.     public function addRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  1097.     {
  1098.         if (!$this->remiseUserPharmacies->contains($remiseUserPharmacy)) {
  1099.             $this->remiseUserPharmacies[] = $remiseUserPharmacy;
  1100.             $remiseUserPharmacy->setPharmacie($this);
  1101.         }
  1103.         return $this;
  1104.     }
  1106.     public function removeRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  1107.     {
  1108.         if ($this->remiseUserPharmacies->removeElement($remiseUserPharmacy)) {
  1109.             // set the owning side to null (unless already changed)
  1110.             if ($remiseUserPharmacy->getPharmacie() === $this) {
  1111.                 $remiseUserPharmacy->setPharmacie(null);
  1112.             }
  1113.         }
  1115.         return $this;
  1116.     }
  1118.     /**
  1119.      * @param float $userLatitude
  1120.      * @param float $userLongitude
  1121.      */
  1122.     public function getDistance(float $userLatitude, float $userLongitude): ?float
  1123.     {
  1124.         $rayonDeLaTerre = 6371071.03;
  1125.         if ($this->latitude === null || $this->logitude === null) {
  1126.             return null;
  1127.         }
  1128.         $lat1 = deg2rad($userLatitude);
  1129.         $lon1 = deg2rad($userLongitude);
  1130.         $lat2 = deg2rad($this->latitude);
  1131.         $lon2 = deg2rad($this->logitude);
  1132.         $deltaLat = $lat2 - $lat1;
  1133.         $deltaLon = $lon2 - $lon1;
  1134.         $a = sin($deltaLat / 2) ** 2 + cos($lat1) * cos($lat2) * sin($deltaLon / 2) ** 2;
  1135.         $c = 2 * asin(sqrt($a));
  1136.         return $rayonDeLaTerre * $c;
  1137.     }
  1139.     public function checkHorraire(): ?array
  1140.     {
  1141.         $dateSemaine = ['Monday' => 1, 'Tuesday' => 2, 'Wednesday' => 3, 'Thursday' => 4, 'Friday' => 5, 'Saturday' => 6, 'Sunday' => 7];
  1142.         $result['classHoraire'] = "";
  1143.         $result['textHoraire'] = "";
  1144.         $result['descHoraire'] = "";
  1145.         $dateTimeNow = new DateTime();
  1146.         $dateTimeNow->modify('+2 hours');
  1147.         if (count($this->getIctusHoraires()) > 0) {
  1148.             $jour = $dateSemaine[date("l", strtotime($dateTimeNow->format('Y-m-d')))];
  1149.             $time = $dateTimeNow->format('H:i:s');
  1150.             $horaireNow = $this->verifHoraireByTime($jour, $time);
  1151.             if ($horaireNow) {
  1152.                 $heureDebut = new \DateTime($time);
  1153.                 $heureFin = new \DateTime($horaireNow->getFin());
  1154.                 $diff = $heureDebut->diff($heureFin);
  1155.                 $result['classHoraire'] = "bg-success text-white";
  1156.                 $result['textHoraire'] = 'Ouverte';
  1157.                 $result['descHoraire'] = 'sera fermée dans ' . $diff->format('%Hh %Imn');
  1158.             } else {
  1159.                 $result['classHoraire'] = "bg-danger text-white";
  1160.                 $result['textHoraire'] = 'Fermée';
  1161.                 $horaireOtherOwnDay = $this->getOtherHoraireOwnDay($jour, $time);
  1162.                 if ($horaireOtherOwnDay) {
  1163.                     $heureDebut = new \DateTime($time);
  1164.                     $heureFin = new \DateTime($horaireOtherOwnDay->getDebut());
  1165.                     $diff = $heureDebut->diff($heureFin);
  1166.                     $result['descHoraire'] = 'sera ouverte dans ' . $diff->format('%Hh %Imn');
  1167.                 } else {
  1168.                     $horaireOtherDay = $this->getOtherHoraireNextDay($jour);
  1169.                     if ($horaireOtherDay) {
  1170.                         $diffDay = (int)$horaireOtherDay[0]->getJour() - $jour;
  1171.                         $dateDebut = new \DateTime($dateTimeNow->format('Y-m-d H:i:s'));
  1172.                         $dateFin = new \DateTime(date('Y-m-d ' . $horaireOtherDay[0]->getDebut(), strtotime(' + ' . $diffDay . ' days')));
  1173.                         $diff = $dateDebut->diff($dateFin);
  1174.                         $delais = "";
  1175.                         if ((int)$diff->format('%d') == 0) {
  1176.                             $delais = $diff->format('%Hh %Imn');
  1177.                         } else {
  1178.                             $delais = $diff->format('%dj');
  1179.                         }
  1180.                         $result['descHoraire'] = 'sera ouverte dans ' . $delais;
  1181.                     } else {
  1182.                         $horaireDebusSemaine = $this->getFirstHoraire($jour);
  1183.                         if ($horaireDebusSemaine) {
  1184.                             $diffDay = (int)$horaireDebusSemaine->getJour() + (7 - $jour);
  1185.                             $dateDebut = new \DateTime($dateTimeNow->format('Y-m-d H:i:s'));
  1186.                             $dateFin = new \DateTime(date('Y-m-d ' . $horaireDebusSemaine->getDebut(), strtotime(' + ' . $diffDay . ' days')));
  1187.                             $diff = $dateDebut->diff($dateFin);
  1188.                             $delais = "";
  1189.                             if ((int)$diff->format('%d') == 0) {
  1190.                                 $delais = $diff->format('%Hh %Imn');
  1191.                             } else {
  1192.                                 $delais = $diff->format('%dj');
  1193.                             }
  1194.                             $result['descHoraire'] = 'sera ouverte dans ' . $delais;
  1195.                         }
  1196.                     }
  1197.                 }
  1198.             }
  1199.         } else {
  1200.             $result = null;
  1201.         }
  1202.         return $result;
  1203.     }
  1205.     private function verifHoraireByTime($jour, $time): ?IctusHoraire
  1206.     {
  1207.         foreach ($this->getIctusHoraires() as $horaire) {
  1208.             if (
  1209.                 $horaire->getJour() === $jour &&
  1210.                 $horaire->getDebut() <= $time &&
  1211.                 $horaire->getFin() > $time
  1212.             ) {
  1213.                 return $horaire;
  1214.             }
  1215.         }
  1216.         return null;
  1217.     }
  1219.     private function getOtherHoraireOwnDay($jour, $time): ?IctusHoraire
  1220.     {
  1221.         foreach ($this->getIctusHoraires() as $horaire) {
  1222.             if (
  1223.                 $horaire->getJour() === $jour &&
  1224.                 $horaire->getFin() > $time
  1225.             ) {
  1226.                 return $horaire;
  1227.             }
  1228.         }
  1229.         return null;
  1230.     }
  1232.     private function getOtherHoraireNextDay($jour): ?IctusHoraire
  1233.     {
  1234.         $resultats = [];
  1236.         foreach ($this->getIctusHoraires() as $horaire) {
  1237.             if ($horaire->getJour() > $jour) {
  1238.                 $resultats[] = $horaire;
  1239.             }
  1240.         }
  1241.         usort($resultats, function ($a, $b) {
  1242.             return $a->getDebut() <=> $b->getDebut();
  1243.         });
  1244.         return $resultats[0] ?? null;
  1245.     }
  1247.     private function getFirstHoraire(): ?IctusHoraire
  1248.     {
  1249.         $horaires = $this->getIctusHoraires()->toArray();
  1250.         if (empty($horaires)) {
  1251.             return null;
  1252.         }
  1253.         usort($horaires, function ($a, $b) {
  1254.             $cmpJour = $a->getJour() <=> $b->getJour();
  1255.             return $cmpJour !== 0 ? $cmpJour : ($a->getDebut() <=> $b->getDebut());
  1256.         });
  1257.         return $horaires[0] ?? null;
  1258.     }
  1260.     /**
  1261.      * @return Collection<int, Assurance>
  1262.      */
  1263.     public function getAssurances(): Collection
  1264.     {
  1265.         return $this->assurances;
  1266.     }
  1268.     public function addAssurance(Assurance $assurance): self
  1269.     {
  1270.         if (!$this->assurances->contains($assurance)) {
  1271.             $this->assurances[] = $assurance;
  1272.             $assurance->addPharmacie($this);
  1273.         }
  1275.         return $this;
  1276.     }
  1278.     public function removeAssurance(Assurance $assurance): self
  1279.     {
  1280.         if ($this->assurances->removeElement($assurance)) {
  1281.             $assurance->removePharmacie($this);
  1282.         }
  1284.         return $this;
  1285.     }
  1286. }