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.     /**
  235.      * @ORM\OneToMany(targetEntity=CertCertificat::class, mappedBy="pharmacie", orphanRemoval=true)
  236.      */
  237.     private $certCertificats;
  239.     public function __construct()
  240.     {
  241.         $this->stockpharmacies = new ArrayCollection();
  242.         $this->users           = new ArrayCollection();
  243.         $this->uuid            = uniqid((new \DateTime())->format('YmdHis'));
  244.         $this->livraisonPharmacies = new ArrayCollection();
  245.         $this->ictusPaiementPharmacies = new ArrayCollection();
  246.         $this->ictusHoraires = new ArrayCollection();
  247.         $this->ictusCommandes = new ArrayCollection();
  248.         $this->ictoRemboursements = new ArrayCollection();
  249.         $this->ictoParampovs = new ArrayCollection();
  250.         $this->ictoMouvements = new ArrayCollection();
  251.         $this->achatIctocoins = new ArrayCollection();
  252.         $this->ictusPanierSpecials = new ArrayCollection();
  253.         $this->commandeSpecials = new ArrayCollection();
  254.         $this->facturePatients = new ArrayCollection();
  255.         $this->productBlackLists = new ArrayCollection();
  256.         $this->historiqueMajs = new ArrayCollection();
  257.         $this->tierpayants = new ArrayCollection();
  258.         $this->parcours = new ArrayCollection();
  259.         $this->facturePharmacies = new ArrayCollection();
  260.         $this->rates = new ArrayCollection();
  261.         $this->ictusReclamations = new ArrayCollection();
  262.         $this->remiseUserPharmacies = new ArrayCollection();
  263.         $this->assurances = new ArrayCollection();
  264.         $this->certCertificats = new ArrayCollection();
  265.     }
  267.     public function getId(): ?int
  268.     {
  269.         return $this->id;
  270.     }
  272.     public function setId($id)
  273.     {
  274.         $this->id = $id;
  275.         return $this;
  276.     }
  279.     public function getUuid(): ?string
  280.     {
  281.         return $this->uuid;
  282.     }
  284.     public function setUuid(?string $uuid): self
  285.     {
  286.         $this->uuid = $uuid;
  288.         return $this;
  289.     }
  291.     public function getDesignation(): ?string
  292.     {
  293.         return $this->designation;
  294.     }
  296.     public function setDesignation(string $designation): self
  297.     {
  298.         $this->designation = $designation;
  300.         return $this;
  301.     }
  303.     public function getLogo(): ?string
  304.     {
  305.         return $this->logo;
  306.     }
  308.     public function setLogo(?string $logo): self
  309.     {
  310.         $this->logo = $logo;
  312.         return $this;
  313.     }
  315.     public function getNumeroordre(): ?string
  316.     {
  317.         return $this->numeroordre;
  318.     }
  320.     public function setNumeroordre(?string $numeroordre): self
  321.     {
  322.         $this->numeroordre = $numeroordre;
  324.         return $this;
  325.     }
  327.     public function getNif(): ?string
  328.     {
  329.         return $this->nif;
  330.     }
  332.     public function setNif(?string $nif): self
  333.     {
  334.         $this->nif = $nif;
  336.         return $this;
  337.     }
  339.     public function getStat(): ?string
  340.     {
  341.         return $this->stat;
  342.     }
  344.     public function setStat(?string $stat): self
  345.     {
  346.         $this->stat = $stat;
  348.         return $this;
  349.     }
  351.     public function isIsValid(): ?bool
  352.     {
  353.         return $this->isValid;
  354.     }
  356.     public function setIsValid(?bool $isValid): self
  357.     {
  358.         $this->isValid = $isValid;
  360.         return $this;
  361.     }
  363.     public function getLogitude(): ?float
  364.     {
  365.         return $this->logitude;
  366.     }
  368.     public function setLogitude(?float $logitude): self
  369.     {
  370.         $this->logitude = $logitude;
  372.         return $this;
  373.     }
  375.     public function getLatitude(): ?float
  376.     {
  377.         return $this->latitude;
  378.     }
  380.     public function setLatitude(?float $latitude): self
  381.     {
  382.         $this->latitude = $latitude;
  384.         return $this;
  385.     }
  387.     /**
  388.      * @return Collection<int, Stockpharmacie>
  389.      */
  390.     public function getStockpharmacies(): Collection
  391.     {
  392.         return $this->stockpharmacies;
  393.     }
  395.     public function addStockpharmacy(Stockpharmacie $stockpharmacy): self
  396.     {
  397.         if (!$this->stockpharmacies->contains($stockpharmacy)) {
  398.             $this->stockpharmacies[] = $stockpharmacy;
  399.             $stockpharmacy->setIctuspharmacie($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeStockpharmacy(Stockpharmacie $stockpharmacy): self
  406.     {
  407.         if ($this->stockpharmacies->removeElement($stockpharmacy)) {
  408.             // set the owning side to null (unless already changed)
  409.             if ($stockpharmacy->getIctuspharmacie() === $this) {
  410.                 $stockpharmacy->setIctuspharmacie(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection<int, User>
  419.      */
  420.     public function getUsers(): Collection
  421.     {
  422.         return $this->users;
  423.     }
  425.     public function addUser(User $user): self
  426.     {
  427.         if (!$this->users->contains($user)) {
  428.             $this->users[] = $user;
  429.             $user->setIctusPharmacie($this);
  430.         }
  432.         return $this;
  433.     }
  435.     public function removeUser(User $user): self
  436.     {
  437.         if ($this->users->removeElement($user)) {
  438.             // set the owning side to null (unless already changed)
  439.             if ($user->getIctusPharmacie() === $this) {
  440.                 $user->setIctusPharmacie(null);
  441.             }
  442.         }
  444.         return $this;
  445.     }
  447.     public function getAdresse(): ?string
  448.     {
  449.         return $this->adresse;
  450.     }
  452.     public function setAdresse(?string $adresse): self
  453.     {
  454.         $this->adresse = $adresse;
  456.         return $this;
  457.     }
  459.     public function getQuartier(): ?Quartier
  460.     {
  461.         return $this->quartier;
  462.     }
  464.     public function setQuartier(?Quartier $quartier): self
  465.     {
  466.         $this->quartier = $quartier;
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection<int, LivraisonPharmacie>
  473.      */
  474.     public function getLivraisonPharmacies(): Collection
  475.     {
  476.         return $this->livraisonPharmacies;
  477.     }
  479.     public function addLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  480.     {
  481.         if (!$this->livraisonPharmacies->contains($livraisonPharmacy)) {
  482.             $this->livraisonPharmacies[] = $livraisonPharmacy;
  483.             $livraisonPharmacy->setIctusPharmacie($this);
  484.         }
  486.         return $this;
  487.     }
  489.     public function removeLivraisonPharmacy(LivraisonPharmacie $livraisonPharmacy): self
  490.     {
  491.         if ($this->livraisonPharmacies->removeElement($livraisonPharmacy)) {
  492.             // set the owning side to null (unless already changed)
  493.             if ($livraisonPharmacy->getIctusPharmacie() === $this) {
  494.                 $livraisonPharmacy->setIctusPharmacie(null);
  495.             }
  496.         }
  498.         return $this;
  499.     }
  501.     /**
  502.      * @return Collection<int, IctusPaiementPharmacie>
  503.      */
  504.     public function getIctusPaiementPharmacies(): Collection
  505.     {
  506.         return $this->ictusPaiementPharmacies;
  507.     }
  509.     public function addIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  510.     {
  511.         if (!$this->ictusPaiementPharmacies->contains($ictusPaiementPharmacy)) {
  512.             $this->ictusPaiementPharmacies[] = $ictusPaiementPharmacy;
  513.             $ictusPaiementPharmacy->setPharmacie($this);
  514.         }
  516.         return $this;
  517.     }
  519.     public function removeIctusPaiementPharmacy(IctusPaiementPharmacie $ictusPaiementPharmacy): self
  520.     {
  521.         if ($this->ictusPaiementPharmacies->removeElement($ictusPaiementPharmacy)) {
  522.             // set the owning side to null (unless already changed)
  523.             if ($ictusPaiementPharmacy->getPharmacie() === $this) {
  524.                 $ictusPaiementPharmacy->setPharmacie(null);
  525.             }
  526.         }
  528.         return $this;
  529.     }
  531.     /**
  532.      * @return Collection<int, IctusHoraire>
  533.      */
  534.     public function getIctusHoraires(): Collection
  535.     {
  536.         return $this->ictusHoraires;
  537.     }
  539.     public function addIctusHoraire(IctusHoraire $ictusHoraire): self
  540.     {
  541.         if (!$this->ictusHoraires->contains($ictusHoraire)) {
  542.             $this->ictusHoraires[] = $ictusHoraire;
  543.             $ictusHoraire->setIctusPharmacie($this);
  544.         }
  546.         return $this;
  547.     }
  549.     public function removeIctusHoraire(IctusHoraire $ictusHoraire): self
  550.     {
  551.         if ($this->ictusHoraires->removeElement($ictusHoraire)) {
  552.             // set the owning side to null (unless already changed)
  553.             if ($ictusHoraire->getIctusPharmacie() === $this) {
  554.                 $ictusHoraire->setIctusPharmacie(null);
  555.             }
  556.         }
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection<int, IctusCommande>
  563.      */
  564.     public function getIctusCommandes(): Collection
  565.     {
  566.         return $this->ictusCommandes;
  567.     }
  569.     public function addIctusCommande(IctusCommande $ictusCommande): self
  570.     {
  571.         if (!$this->ictusCommandes->contains($ictusCommande)) {
  572.             $this->ictusCommandes[] = $ictusCommande;
  573.             $ictusCommande->setPharmacie($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeIctusCommande(IctusCommande $ictusCommande): self
  580.     {
  581.         if ($this->ictusCommandes->removeElement($ictusCommande)) {
  582.             // set the owning side to null (unless already changed)
  583.             if ($ictusCommande->getPharmacie() === $this) {
  584.                 $ictusCommande->setPharmacie(null);
  585.             }
  586.         }
  588.         return $this;
  589.     }
  591.     /**
  592.      * Get the value of distanceParRapportPatient
  593.      */
  594.     public function getDistanceParRapportPatient()
  595.     {
  596.         return $this->distanceParRapportPatient;
  597.     }
  599.     /**
  600.      * Set the value of distanceParRapportPatient
  601.      *
  602.      * @return  self
  603.      */
  604.     public function setDistanceParRapportPatient($distanceParRapportPatient)
  605.     {
  606.         $this->distanceParRapportPatient = $distanceParRapportPatient;
  608.         return $this;
  609.     }
  611.     public function getPhotocouverture(): ?string
  612.     {
  613.         return $this->photocouverture;
  614.     }
  616.     public function setPhotocouverture(?string $photocouverture): self
  617.     {
  618.         $this->photocouverture = $photocouverture;
  620.         return $this;
  621.     }
  623.     public function getPagename(): ?string
  624.     {
  625.         return $this->pagename;
  626.     }
  628.     public function setPagename(?string $pagename): self
  629.     {
  630.         $this->pagename = $pagename;
  632.         return $this;
  633.     }
  635.     /**
  636.      * @return Collection<int, IctoRemboursement>
  637.      */
  638.     public function getIctoRemboursements(): Collection
  639.     {
  640.         return $this->ictoRemboursements;
  641.     }
  643.     public function addIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  644.     {
  645.         if (!$this->ictoRemboursements->contains($ictoRemboursement)) {
  646.             $this->ictoRemboursements[] = $ictoRemboursement;
  647.             $ictoRemboursement->setDemandeur($this);
  648.         }
  650.         return $this;
  651.     }
  653.     public function removeIctoRemboursement(IctoRemboursement $ictoRemboursement): self
  654.     {
  655.         if ($this->ictoRemboursements->removeElement($ictoRemboursement)) {
  656.             // set the owning side to null (unless already changed)
  657.             if ($ictoRemboursement->getDemandeur() === $this) {
  658.                 $ictoRemboursement->setDemandeur(null);
  659.             }
  660.         }
  662.         return $this;
  663.     }
  665.     /**
  666.      * @return Collection<int, IctoParampov>
  667.      */
  668.     public function getIctoParampovs(): Collection
  669.     {
  670.         return $this->ictoParampovs;
  671.     }
  673.     public function addIctoParampov(IctoParampov $ictoParampov): self
  674.     {
  675.         if (!$this->ictoParampovs->contains($ictoParampov)) {
  676.             $this->ictoParampovs[] = $ictoParampov;
  677.             $ictoParampov->setPharmacie($this);
  678.         }
  680.         return $this;
  681.     }
  683.     public function removeIctoParampov(IctoParampov $ictoParampov): self
  684.     {
  685.         if ($this->ictoParampovs->removeElement($ictoParampov)) {
  686.             // set the owning side to null (unless already changed)
  687.             if ($ictoParampov->getPharmacie() === $this) {
  688.                 $ictoParampov->setPharmacie(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     /**
  696.      * @return Collection<int, IctoMouvement>
  697.      */
  698.     public function getIctoMouvements(): Collection
  699.     {
  700.         return $this->ictoMouvements;
  701.     }
  703.     public function addIctoMouvement(IctoMouvement $ictoMouvement): self
  704.     {
  705.         if (!$this->ictoMouvements->contains($ictoMouvement)) {
  706.             $this->ictoMouvements[] = $ictoMouvement;
  707.             $ictoMouvement->setPharmacie($this);
  708.         }
  710.         return $this;
  711.     }
  713.     public function removeIctoMouvement(IctoMouvement $ictoMouvement): self
  714.     {
  715.         if ($this->ictoMouvements->removeElement($ictoMouvement)) {
  716.             // set the owning side to null (unless already changed)
  717.             if ($ictoMouvement->getPharmacie() === $this) {
  718.                 $ictoMouvement->setPharmacie(null);
  719.             }
  720.         }
  722.         return $this;
  723.     }
  725.     /**
  726.      * @return Collection<int, AchatIctocoin>
  727.      */
  728.     public function getAchatIctocoins(): Collection
  729.     {
  730.         return $this->achatIctocoins;
  731.     }
  733.     public function addAchatIctocoin(AchatIctocoin $achatIctocoin): self
  734.     {
  735.         if (!$this->achatIctocoins->contains($achatIctocoin)) {
  736.             $this->achatIctocoins[] = $achatIctocoin;
  737.             $achatIctocoin->setPharmacie($this);
  738.         }
  740.         return $this;
  741.     }
  743.     public function removeAchatIctocoin(AchatIctocoin $achatIctocoin): self
  744.     {
  745.         if ($this->achatIctocoins->removeElement($achatIctocoin)) {
  746.             // set the owning side to null (unless already changed)
  747.             if ($achatIctocoin->getPharmacie() === $this) {
  748.                 $achatIctocoin->setPharmacie(null);
  749.             }
  750.         }
  752.         return $this;
  753.     }
  755.     /**
  756.      * @return Collection<int, IctusPanierSpecial>
  757.      */
  758.     public function getIctusPanierSpecials(): Collection
  759.     {
  760.         return $this->ictusPanierSpecials;
  761.     }
  763.     public function addIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  764.     {
  765.         if (!$this->ictusPanierSpecials->contains($ictusPanierSpecial)) {
  766.             $this->ictusPanierSpecials[] = $ictusPanierSpecial;
  767.             $ictusPanierSpecial->setPharmacie($this);
  768.         }
  770.         return $this;
  771.     }
  773.     public function removeIctusPanierSpecial(IctusPanierSpecial $ictusPanierSpecial): self
  774.     {
  775.         if ($this->ictusPanierSpecials->removeElement($ictusPanierSpecial)) {
  776.             // set the owning side to null (unless already changed)
  777.             if ($ictusPanierSpecial->getPharmacie() === $this) {
  778.                 $ictusPanierSpecial->setPharmacie(null);
  779.             }
  780.         }
  782.         return $this;
  783.     }
  785.     public function isIsCommandeSpecial(): ?bool
  786.     {
  787.         return $this->isCommandeSpecial;
  788.     }
  790.     public function setIsCommandeSpecial(?bool $isCommandeSpecial): self
  791.     {
  792.         $this->isCommandeSpecial = $isCommandeSpecial;
  794.         return $this;
  795.     }
  797.     /**
  798.      * @return Collection<int, CommandeSpecial>
  799.      */
  800.     public function getCommandeSpecials(): Collection
  801.     {
  802.         return $this->commandeSpecials;
  803.     }
  805.     public function addCommandeSpecial(CommandeSpecial $commandeSpecial): self
  806.     {
  807.         if (!$this->commandeSpecials->contains($commandeSpecial)) {
  808.             $this->commandeSpecials[] = $commandeSpecial;
  809.             $commandeSpecial->setPharmacie($this);
  810.         }
  812.         return $this;
  813.     }
  815.     public function removeCommandeSpecial(CommandeSpecial $commandeSpecial): self
  816.     {
  817.         if ($this->commandeSpecials->removeElement($commandeSpecial)) {
  818.             // set the owning side to null (unless already changed)
  819.             if ($commandeSpecial->getPharmacie() === $this) {
  820.                 $commandeSpecial->setPharmacie(null);
  821.             }
  822.         }
  824.         return $this;
  825.     }
  827.     public function isIsValideAutomatique(): ?bool
  828.     {
  829.         return $this->isValideAutomatique;
  830.     }
  832.     public function setIsValideAutomatique(?bool $isValideAutomatique): self
  833.     {
  834.         $this->isValideAutomatique = $isValideAutomatique;
  836.         return $this;
  837.     }
  839.     public function getPourcentageCommandeSpecial(): ?float
  840.     {
  841.         return $this->pourcentageCommandeSpecial;
  842.     }
  844.     public function setPourcentageCommandeSpecial(?float $pourcentageCommandeSpecial): self
  845.     {
  846.         $this->pourcentageCommandeSpecial = $pourcentageCommandeSpecial;
  848.         return $this;
  849.     }
  851.     /**
  852.      * @return Collection<int, FacturePatient>
  853.      */
  854.     public function getFacturePatients(): Collection
  855.     {
  856.         return $this->facturePatients;
  857.     }
  859.     public function addFacturePatient(FacturePatient $facturePatient): self
  860.     {
  861.         if (!$this->facturePatients->contains($facturePatient)) {
  862.             $this->facturePatients[] = $facturePatient;
  863.             $facturePatient->setPharmacie($this);
  864.         }
  866.         return $this;
  867.     }
  869.     public function removeFacturePatient(FacturePatient $facturePatient): self
  870.     {
  871.         if ($this->facturePatients->removeElement($facturePatient)) {
  872.             // set the owning side to null (unless already changed)
  873.             if ($facturePatient->getPharmacie() === $this) {
  874.                 $facturePatient->setPharmacie(null);
  875.             }
  876.         }
  878.         return $this;
  879.     }
  881.     public function getRcs(): ?string
  882.     {
  883.         return $this->rcs;
  884.     }
  886.     public function setRcs(?string $rcs): self
  887.     {
  888.         $this->rcs = $rcs;
  890.         return $this;
  891.     }
  893.     /**
  894.      * @return Collection<int, ProductBlackList>
  895.      */
  896.     public function getProductBlackLists(): Collection
  897.     {
  898.         return $this->productBlackLists;
  899.     }
  901.     public function addProductBlackList(ProductBlackList $productBlackList): self
  902.     {
  903.         if (!$this->productBlackLists->contains($productBlackList)) {
  904.             $this->productBlackLists[] = $productBlackList;
  905.             $productBlackList->setPharmacie($this);
  906.         }
  908.         return $this;
  909.     }
  911.     public function removeProductBlackList(ProductBlackList $productBlackList): self
  912.     {
  913.         if ($this->productBlackLists->removeElement($productBlackList)) {
  914.             // set the owning side to null (unless already changed)
  915.             if ($productBlackList->getPharmacie() === $this) {
  916.                 $productBlackList->setPharmacie(null);
  917.             }
  918.         }
  920.         return $this;
  921.     }
  923.     /**
  924.      * @return Collection<int, HistoriqueMaj>
  925.      */
  926.     public function getHistoriqueMajs(): Collection
  927.     {
  928.         return $this->historiqueMajs;
  929.     }
  931.     public function addHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  932.     {
  933.         if (!$this->historiqueMajs->contains($historiqueMaj)) {
  934.             $this->historiqueMajs[] = $historiqueMaj;
  935.             $historiqueMaj->setPharmacie($this);
  936.         }
  938.         return $this;
  939.     }
  941.     public function removeHistoriqueMaj(HistoriqueMaj $historiqueMaj): self
  942.     {
  943.         if ($this->historiqueMajs->removeElement($historiqueMaj)) {
  944.             // set the owning side to null (unless already changed)
  945.             if ($historiqueMaj->getPharmacie() === $this) {
  946.                 $historiqueMaj->setPharmacie(null);
  947.             }
  948.         }
  950.         return $this;
  951.     }
  953.     /**
  954.      * @return Collection<int, Tierpayant>
  955.      */
  956.     public function getTierpayants(): Collection
  957.     {
  958.         return $this->tierpayants;
  959.     }
  961.     public function addTierpayant(Tierpayant $tierpayant): self
  962.     {
  963.         if (!$this->tierpayants->contains($tierpayant)) {
  964.             $this->tierpayants[] = $tierpayant;
  965.             $tierpayant->addPharmacie($this);
  966.         }
  968.         return $this;
  969.     }
  971.     public function removeTierpayant(Tierpayant $tierpayant): self
  972.     {
  973.         if ($this->tierpayants->removeElement($tierpayant)) {
  974.             $tierpayant->removePharmacie($this);
  975.         }
  977.         return $this;
  978.     }
  980.     public function getMailResponsable(): ?string
  981.     {
  982.         return $this->mailResponsable;
  983.     }
  985.     public function setMailResponsable(?string $mailResponsable): self
  986.     {
  987.         $this->mailResponsable = $mailResponsable;
  989.         return $this;
  990.     }
  992.     /**
  993.      * @return Collection<int, FacturePharmacie>
  994.      */
  995.     public function getFacturePharmacies(): Collection
  996.     {
  997.         return $this->facturePharmacies;
  998.     }
  1000.     public function addFacturePharmacy(FacturePharmacie $facturePharmacy): self
  1001.     {
  1002.         if (!$this->facturePharmacies->contains($facturePharmacy)) {
  1003.             $this->facturePharmacies[] = $facturePharmacy;
  1004.             $facturePharmacy->setPharmacie($this);
  1005.         }
  1007.         return $this;
  1008.     }
  1010.     public function removeFacturePharmacy(FacturePharmacie $facturePharmacy): self
  1011.     {
  1012.         if ($this->facturePharmacies->removeElement($facturePharmacy)) {
  1013.             // set the owning side to null (unless already changed)
  1014.             if ($facturePharmacy->getPharmacie() === $this) {
  1015.                 $facturePharmacy->setPharmacie(null);
  1016.             }
  1017.         }
  1019.         return $this;
  1020.     }
  1022.     /**
  1023.      * @return Collection<int, Rate>
  1024.      */
  1025.     public function getRates(): Collection
  1026.     {
  1027.         return $this->rates;
  1028.     }
  1030.     public function addRate(Rate $rate): self
  1031.     {
  1032.         if (!$this->rates->contains($rate)) {
  1033.             $this->rates[] = $rate;
  1034.             $rate->setPharmacie($this);
  1035.         }
  1037.         return $this;
  1038.     }
  1040.     public function removeRate(Rate $rate): self
  1041.     {
  1042.         if ($this->rates->removeElement($rate)) {
  1043.             // set the owning side to null (unless already changed)
  1044.             if ($rate->getPharmacie() === $this) {
  1045.                 $rate->setPharmacie(null);
  1046.             }
  1047.         }
  1049.         return $this;
  1050.     }
  1052.     /**
  1053.      * @return Collection<int, IctusReclamation>
  1054.      */
  1055.     public function getIctusReclamations(): Collection
  1056.     {
  1057.         return $this->ictusReclamations;
  1058.     }
  1060.     public function addIctusReclamation(IctusReclamation $ictusReclamation): self
  1061.     {
  1062.         if (!$this->ictusReclamations->contains($ictusReclamation)) {
  1063.             $this->ictusReclamations[] = $ictusReclamation;
  1064.             $ictusReclamation->setPharmacie($this);
  1065.         }
  1067.         return $this;
  1068.     }
  1070.     public function removeIctusReclamation(IctusReclamation $ictusReclamation): self
  1071.     {
  1072.         if ($this->ictusReclamations->removeElement($ictusReclamation)) {
  1073.             // set the owning side to null (unless already changed)
  1074.             if ($ictusReclamation->getPharmacie() === $this) {
  1075.                 $ictusReclamation->setPharmacie(null);
  1076.             }
  1077.         }
  1079.         return $this;
  1080.     }
  1082.     public function getRealDesignation(): ?string
  1083.     {
  1084.         return $this->realDesignation;
  1085.     }
  1087.     public function setRealDesignation(?string $realDesignation): self
  1088.     {
  1089.         $this->realDesignation = $realDesignation;
  1091.         return $this;
  1092.     }
  1094.     /**
  1095.      * @return Collection<int, RemiseUserPharmacie>
  1096.      */
  1097.     public function getRemiseUserPharmacies(): Collection
  1098.     {
  1099.         return $this->remiseUserPharmacies;
  1100.     }
  1102.     public function addRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  1103.     {
  1104.         if (!$this->remiseUserPharmacies->contains($remiseUserPharmacy)) {
  1105.             $this->remiseUserPharmacies[] = $remiseUserPharmacy;
  1106.             $remiseUserPharmacy->setPharmacie($this);
  1107.         }
  1109.         return $this;
  1110.     }
  1112.     public function removeRemiseUserPharmacy(RemiseUserPharmacie $remiseUserPharmacy): self
  1113.     {
  1114.         if ($this->remiseUserPharmacies->removeElement($remiseUserPharmacy)) {
  1115.             // set the owning side to null (unless already changed)
  1116.             if ($remiseUserPharmacy->getPharmacie() === $this) {
  1117.                 $remiseUserPharmacy->setPharmacie(null);
  1118.             }
  1119.         }
  1121.         return $this;
  1122.     }
  1124.     /**
  1125.      * @param float $userLatitude
  1126.      * @param float $userLongitude
  1127.      */
  1128.     public function getDistance(float $userLatitude, float $userLongitude): ?float
  1129.     {
  1130.         $rayonDeLaTerre = 6371071.03;
  1131.         if ($this->latitude === null || $this->logitude === null) {
  1132.             return null;
  1133.         }
  1134.         $lat1 = deg2rad($userLatitude);
  1135.         $lon1 = deg2rad($userLongitude);
  1136.         $lat2 = deg2rad($this->latitude);
  1137.         $lon2 = deg2rad($this->logitude);
  1138.         $deltaLat = $lat2 - $lat1;
  1139.         $deltaLon = $lon2 - $lon1;
  1140.         $a = sin($deltaLat / 2) ** 2 + cos($lat1) * cos($lat2) * sin($deltaLon / 2) ** 2;
  1141.         $c = 2 * asin(sqrt($a));
  1142.         return $rayonDeLaTerre * $c;
  1143.     }
  1145.     public function checkHorraire(): ?array
  1146.     {
  1147.         $dateSemaine = ['Monday' => 1, 'Tuesday' => 2, 'Wednesday' => 3, 'Thursday' => 4, 'Friday' => 5, 'Saturday' => 6, 'Sunday' => 7];
  1148.         $result['classHoraire'] = "";
  1149.         $result['textHoraire'] = "";
  1150.         $result['descHoraire'] = "";
  1151.         $dateTimeNow = new DateTime();
  1152.         $dateTimeNow->modify('+2 hours');
  1153.         if (count($this->getIctusHoraires()) > 0) {
  1154.             $jour = $dateSemaine[date("l", strtotime($dateTimeNow->format('Y-m-d')))];
  1155.             $time = $dateTimeNow->format('H:i:s');
  1156.             $horaireNow = $this->verifHoraireByTime($jour, $time);
  1157.             if ($horaireNow) {
  1158.                 $heureDebut = new \DateTime($time);
  1159.                 $heureFin = new \DateTime($horaireNow->getFin());
  1160.                 $diff = $heureDebut->diff($heureFin);
  1161.                 $result['classHoraire'] = "bg-success text-white";
  1162.                 $result['textHoraire'] = 'Ouverte';
  1163.                 $result['descHoraire'] = 'sera fermée dans ' . $diff->format('%Hh %Imn');
  1164.             } else {
  1165.                 $result['classHoraire'] = "bg-danger text-white";
  1166.                 $result['textHoraire'] = 'Fermée';
  1167.                 $horaireOtherOwnDay = $this->getOtherHoraireOwnDay($jour, $time);
  1168.                 if ($horaireOtherOwnDay) {
  1169.                     $heureDebut = new \DateTime($time);
  1170.                     $heureFin = new \DateTime($horaireOtherOwnDay->getDebut());
  1171.                     $diff = $heureDebut->diff($heureFin);
  1172.                     $result['descHoraire'] = 'sera ouverte dans ' . $diff->format('%Hh %Imn');
  1173.                 } else {
  1174.                     $horaireOtherDay = $this->getOtherHoraireNextDay($jour);
  1175.                     if ($horaireOtherDay) {
  1176.                         $diffDay = (int)$horaireOtherDay[0]->getJour() - $jour;
  1177.                         $dateDebut = new \DateTime($dateTimeNow->format('Y-m-d H:i:s'));
  1178.                         $dateFin = new \DateTime(date('Y-m-d ' . $horaireOtherDay[0]->getDebut(), strtotime(' + ' . $diffDay . ' days')));
  1179.                         $diff = $dateDebut->diff($dateFin);
  1180.                         $delais = "";
  1181.                         if ((int)$diff->format('%d') == 0) {
  1182.                             $delais = $diff->format('%Hh %Imn');
  1183.                         } else {
  1184.                             $delais = $diff->format('%dj');
  1185.                         }
  1186.                         $result['descHoraire'] = 'sera ouverte dans ' . $delais;
  1187.                     } else {
  1188.                         $horaireDebusSemaine = $this->getFirstHoraire($jour);
  1189.                         if ($horaireDebusSemaine) {
  1190.                             $diffDay = (int)$horaireDebusSemaine->getJour() + (7 - $jour);
  1191.                             $dateDebut = new \DateTime($dateTimeNow->format('Y-m-d H:i:s'));
  1192.                             $dateFin = new \DateTime(date('Y-m-d ' . $horaireDebusSemaine->getDebut(), strtotime(' + ' . $diffDay . ' days')));
  1193.                             $diff = $dateDebut->diff($dateFin);
  1194.                             $delais = "";
  1195.                             if ((int)$diff->format('%d') == 0) {
  1196.                                 $delais = $diff->format('%Hh %Imn');
  1197.                             } else {
  1198.                                 $delais = $diff->format('%dj');
  1199.                             }
  1200.                             $result['descHoraire'] = 'sera ouverte dans ' . $delais;
  1201.                         }
  1202.                     }
  1203.                 }
  1204.             }
  1205.         } else {
  1206.             $result = null;
  1207.         }
  1208.         return $result;
  1209.     }
  1211.     private function verifHoraireByTime($jour, $time): ?IctusHoraire
  1212.     {
  1213.         foreach ($this->getIctusHoraires() as $horaire) {
  1214.             if (
  1215.                 $horaire->getJour() === $jour &&
  1216.                 $horaire->getDebut() <= $time &&
  1217.                 $horaire->getFin() > $time
  1218.             ) {
  1219.                 return $horaire;
  1220.             }
  1221.         }
  1222.         return null;
  1223.     }
  1225.     private function getOtherHoraireOwnDay($jour, $time): ?IctusHoraire
  1226.     {
  1227.         foreach ($this->getIctusHoraires() as $horaire) {
  1228.             if (
  1229.                 $horaire->getJour() === $jour &&
  1230.                 $horaire->getFin() > $time
  1231.             ) {
  1232.                 return $horaire;
  1233.             }
  1234.         }
  1235.         return null;
  1236.     }
  1238.     private function getOtherHoraireNextDay($jour): ?IctusHoraire
  1239.     {
  1240.         $resultats = [];
  1242.         foreach ($this->getIctusHoraires() as $horaire) {
  1243.             if ($horaire->getJour() > $jour) {
  1244.                 $resultats[] = $horaire;
  1245.             }
  1246.         }
  1247.         usort($resultats, function ($a, $b) {
  1248.             return $a->getDebut() <=> $b->getDebut();
  1249.         });
  1250.         return $resultats[0] ?? null;
  1251.     }
  1253.     private function getFirstHoraire(): ?IctusHoraire
  1254.     {
  1255.         $horaires = $this->getIctusHoraires()->toArray();
  1256.         if (empty($horaires)) {
  1257.             return null;
  1258.         }
  1259.         usort($horaires, function ($a, $b) {
  1260.             $cmpJour = $a->getJour() <=> $b->getJour();
  1261.             return $cmpJour !== 0 ? $cmpJour : ($a->getDebut() <=> $b->getDebut());
  1262.         });
  1263.         return $horaires[0] ?? null;
  1264.     }
  1266.     /**
  1267.      * @return Collection<int, Assurance>
  1268.      */
  1269.     public function getAssurances(): Collection
  1270.     {
  1271.         return $this->assurances;
  1272.     }
  1274.     public function addAssurance(Assurance $assurance): self
  1275.     {
  1276.         if (!$this->assurances->contains($assurance)) {
  1277.             $this->assurances[] = $assurance;
  1278.             $assurance->addPharmacie($this);
  1279.         }
  1281.         return $this;
  1282.     }
  1284.     public function removeAssurance(Assurance $assurance): self
  1285.     {
  1286.         if ($this->assurances->removeElement($assurance)) {
  1287.             $assurance->removePharmacie($this);
  1288.         }
  1290.         return $this;
  1291.     }
  1293.     /**
  1294.      * @return Collection<int, CertCertificat>
  1295.      */
  1296.     public function getCertCertificats(): Collection
  1297.     {
  1298.         return $this->certCertificats;
  1299.     }
  1301.     public function addCertCertificat(CertCertificat $certCertificat): self
  1302.     {
  1303.         if (!$this->certCertificats->contains($certCertificat)) {
  1304.             $this->certCertificats[] = $certCertificat;
  1305.             $certCertificat->setPharmacie($this);
  1306.         }
  1308.         return $this;
  1309.     }
  1311.     public function removeCertCertificat(CertCertificat $certCertificat): self
  1312.     {
  1313.         if ($this->certCertificats->removeElement($certCertificat)) {
  1314.             // set the owning side to null (unless already changed)
  1315.             if ($certCertificat->getPharmacie() === $this) {
  1316.                 $certCertificat->setPharmacie(null);
  1317.             }
  1318.         }
  1320.         return $this;
  1321.     }
  1322. }