src/Entity/Zone.php line 13

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\ZoneRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\ORM\Mapping as ORM;
  7. /**
  8.  * @ORM\Entity(repositoryClass=ZoneRepository::class)
  9.  */
  10. class Zone
  11. {
  12.     /**
  13.      * @ORM\Id
  14.      * @ORM\GeneratedValue
  15.      * @ORM\Column(type="integer")
  16.      */
  17.     private $id;
  18.     /**
  19.      * @ORM\Column(type="string", length=255)
  20.      */
  21.     private $nom;
  22.     /**
  23.      * @ORM\Column(type="float", nullable="true")
  24.      */
  25.     private $caisseBoisMontantBouteilleSix;
  26.     /**
  27.      * @ORM\Column(type="float", nullable="true")
  28.      */
  29.     private $caisseBoisMontantBouteillesDouze;
  30.     /**
  31.      * @ORM\OneToMany(targetEntity=Pays::class, mappedBy="zone")
  32.      */
  33.     private $pays;
  34.     /**
  35.      * @ORM\OneToMany(targetEntity=TypeTarifs::class, mappedBy="zone")
  36.      */
  37.     private $typeTarifs;
  38.     /**
  39.      * @ORM\OneToMany(targetEntity=QuantiteBouteille::class, mappedBy="zone")
  40.      * @ORM\OrderBy({"ordre" = "ASC"})
  41.      */
  42.     private $quantitesBouteilles;
  43.     /**
  44.      * @ORM\OneToMany(targetEntity=Frais::class, mappedBy="zone")
  45.      */
  46.     private $frais;
  47.     /**
  48.      * @ORM\ManyToOne(targetEntity=Annee::class, inversedBy="zones")
  49.      */
  50.     private $annee;
  51.     /**
  52.      * @ORM\Column(type="boolean", nullable=true)
  53.      */
  54.     private $isUsa;
  55.     /**
  56.      * @ORM\Column(type="boolean", nullable=true)
  57.      */
  58.     private $assujettiTva;
  59.     /**
  60.      * @ORM\OneToMany(targetEntity=Information::class, mappedBy="zone", orphanRemoval=true)
  61.      * @ORM\OrderBy({"ordre" = "ASC"})
  62.      */
  63.     private $information;
  64.     public function __construct()
  65.     {
  66.         $this->pays = new ArrayCollection();
  67.         $this->typeTarifs = new ArrayCollection();
  68.         $this->quantitesBouteilles = new ArrayCollection();
  69.         $this->frais = new ArrayCollection();
  70.         $this->information = new ArrayCollection();
  71.     }
  72.     public function getId(): ?int
  73.     {
  74.         return $this->id;
  75.     }
  76.     public function getNom(): ?string
  77.     {
  78.         return $this->nom;
  79.     }
  80.     public function setNom(string $nom): self
  81.     {
  82.         $this->nom $nom;
  83.         return $this;
  84.     }
  85.     public function getCaisseBoisMontantBouteilleSix(): ?float
  86.     {
  87.         return $this->caisseBoisMontantBouteilleSix;
  88.     }
  89.     public function setCaisseBoisMontantBouteilleSix(float $caisseBoisMontantBouteilleSix): self
  90.     {
  91.         $this->caisseBoisMontantBouteilleSix $caisseBoisMontantBouteilleSix;
  92.         return $this;
  93.     }
  94.     public function getCaisseBoisMontantBouteillesDouze(): ?float
  95.     {
  96.         return $this->caisseBoisMontantBouteillesDouze;
  97.     }
  98.     public function setCaisseBoisMontantBouteillesDouze(float $caisseBoisMontantBouteillesDouze): self
  99.     {
  100.         $this->caisseBoisMontantBouteillesDouze $caisseBoisMontantBouteillesDouze;
  101.         return $this;
  102.     }
  103.     /**
  104.      * @return Collection<int, Pays>
  105.      */
  106.     public function getPays(): Collection
  107.     {
  108.         // Permet de retourner par ordre alphabétique
  109.         $paysArray $this->pays->toArray();
  110.         usort($paysArray, function($a$b) {
  111.             return strcmp($a->getNom(), $b->getNom());
  112.         });
  113.     
  114.         return new ArrayCollection($paysArray);        
  115.     }
  116.     public function addPay(Pays $pay): self
  117.     {
  118.         if (!$this->pays->contains($pay)) {
  119.             $this->pays[] = $pay;
  120.             $pay->setZone($this);
  121.         }
  122.         return $this;
  123.     }
  124.     public function removePay(Pays $pay): self
  125.     {
  126.         if ($this->pays->removeElement($pay)) {
  127.             // set the owning side to null (unless already changed)
  128.             if ($pay->getZone() === $this) {
  129.                 $pay->setZone(null);
  130.             }
  131.         }
  132.         return $this;
  133.     }
  134.     /**
  135.      * @return Collection<int, TypeTarifs>
  136.      */
  137.     public function getTypeTarifs(): Collection
  138.     {
  139.         return $this->typeTarifs;
  140.     }
  141.     public function addTypeTarif(TypeTarifs $typeTarif): self
  142.     {
  143.         if (!$this->typeTarifs->contains($typeTarif)) {
  144.             $this->typeTarifs[] = $typeTarif;
  145.             $typeTarif->setZone($this);
  146.         }
  147.         return $this;
  148.     }
  149.     public function removeTypeTarif(TypeTarifs $typeTarif): self
  150.     {
  151.         if ($this->typeTarifs->removeElement($typeTarif)) {
  152.             // set the owning side to null (unless already changed)
  153.             if ($typeTarif->getZone() === $this) {
  154.                 $typeTarif->setZone(null);
  155.             }
  156.         }
  157.         return $this;
  158.     }
  159.     /**
  160.      * @return Collection<int, QuantiteBouteille>
  161.      */
  162.     public function getQuantitesBouteilles(): Collection
  163.     {
  164.         return $this->quantitesBouteilles;
  165.     }
  166.     public function addQuantitesBouteille(QuantiteBouteille $quantitesBouteille): self
  167.     {
  168.         if (!$this->quantitesBouteilles->contains($quantitesBouteille)) {
  169.             $this->quantitesBouteilles[] = $quantitesBouteille;
  170.             $quantitesBouteille->setZone($this);
  171.         }
  172.         return $this;
  173.     }
  174.     public function removeQuantitesBouteille(QuantiteBouteille $quantitesBouteille): self
  175.     {
  176.         if ($this->quantitesBouteilles->removeElement($quantitesBouteille)) {
  177.             // set the owning side to null (unless already changed)
  178.             if ($quantitesBouteille->getZone() === $this) {
  179.                 $quantitesBouteille->setZone(null);
  180.             }
  181.         }
  182.         return $this;
  183.     }
  184.     /**
  185.      * @return Collection<int, Frais>
  186.      */
  187.     public function getFrais(): Collection
  188.     {
  189.         return $this->frais;
  190.     }
  191.     public function addFrai(Frais $frai): self
  192.     {
  193.         if (!$this->frais->contains($frai)) {
  194.             $this->frais[] = $frai;
  195.             $frai->setZone($this);
  196.         }
  197.         return $this;
  198.     }
  199.     public function removeFrai(Frais $frai): self
  200.     {
  201.         if ($this->frais->removeElement($frai)) {
  202.             // set the owning side to null (unless already changed)
  203.             if ($frai->getZone() === $this) {
  204.                 $frai->setZone(null);
  205.             }
  206.         }
  207.         return $this;
  208.     }
  209.     public function getAnnee(): ?Annee
  210.     {
  211.         return $this->annee;
  212.     }
  213.     public function setAnnee(?Annee $annee): self
  214.     {
  215.         $this->annee $annee;
  216.         return $this;
  217.     }
  218.     public function isIsUsa(): ?bool
  219.     {
  220.         return $this->isUsa;
  221.     }
  222.     public function setIsUsa(?bool $isUsa): self
  223.     {
  224.         $this->isUsa $isUsa;
  225.         return $this;
  226.     }
  227.     public function isAssujettiTva(): ?bool
  228.     {
  229.         return $this->assujettiTva;
  230.     }
  231.     public function setAssujettiTva(?bool $assujettiTva): self
  232.     {
  233.         $this->assujettiTva $assujettiTva;
  234.         return $this;
  235.     }
  236.     /**
  237.      * @return Collection<int, Information>
  238.      */
  239.     public function getInformation(): Collection
  240.     {
  241.         return $this->information;
  242.     }
  243.     public function addInformation(Information $information): self
  244.     {
  245.         if (!$this->information->contains($information)) {
  246.             $this->information[] = $information;
  247.             $information->setZone($this);
  248.         }
  249.         return $this;
  250.     }
  251.     public function removeInformation(Information $information): self
  252.     {
  253.         if ($this->information->removeElement($information)) {
  254.             // set the owning side to null (unless already changed)
  255.             if ($information->getZone() === $this) {
  256.                 $information->setZone(null);
  257.             }
  258.         }
  259.         return $this;
  260.     }
  261. }