src/Entity/Periode.php line 12

Open in your IDE?
  1. <?php
  2. namespace App\Entity;
  3. use App\Repository\PeriodeRepository;
  4. use Doctrine\Common\Collections\ArrayCollection;
  5. use Doctrine\Common\Collections\Collection;
  6. use Doctrine\DBAL\Types\Types;
  7. use Doctrine\ORM\Mapping as ORM;
  8. #[ORM\Entity(repositoryClassPeriodeRepository::class)]
  9. class Periode
  10. {
  11.     #[ORM\Id]
  12.     #[ORM\GeneratedValue]
  13.     #[ORM\Column]
  14.     private ?int $id null;
  15.     #[ORM\Column(length255nullabletrue)]
  16.     private ?string $code null;
  17.     #[ORM\Column(length255nullabletrue)]
  18.     private ?string $abreviation null;
  19.     #[ORM\Column(typeTypes::DATE_MUTABLEnullabletrue)]
  20.     private ?\DateTimeInterface $date null;
  21.     #[ORM\OneToMany(mappedBy'periode'targetEntityPArretTravailLg::class)]
  22.     private Collection $arretTravailLgs;
  23.     #[ORM\OneToMany(mappedBy'periode'targetEntityLElementEcheance::class)]
  24.     private Collection $elementEcheances;
  25.     #[ORM\OneToMany(mappedBy'periode'targetEntityTbulletin::class)]
  26.     private Collection $bulletins;
  27.     #[ORM\OneToMany(mappedBy'periode'targetEntityPPrelevementLg::class)]
  28.     private Collection $prelevementLgs;
  29.     #[ORM\OneToMany(mappedBy'periode'targetEntityProbleme::class)]
  30.     private Collection $problemes;
  31.     #[ORM\OneToMany(mappedBy'periode'targetEntityPBordereau::class)]
  32.     private Collection $bordereaus;
  33.     #[ORM\Column(nullabletrue)]
  34.     private ?bool $isValider false;
  35.     #[ORM\Column(nullabletrue)]
  36.     private ?bool $isIntegrer false;
  37.     #[ORM\OneToMany(mappedBy'periode'targetEntitySyntheseRemunarationCab::class)]
  38.     private Collection $syntheseRemunarationCabs;
  39.     public function __construct()
  40.     {
  41.         $this->arretTravailLgs = new ArrayCollection();
  42.         $this->elementEcheances = new ArrayCollection();
  43.         $this->bulletins = new ArrayCollection();
  44.         $this->prelevementLgs = new ArrayCollection();
  45.         $this->problemes = new ArrayCollection();
  46.         $this->bordereaus = new ArrayCollection();
  47.         $this->syntheseRemunarationCabs = new ArrayCollection();
  48.     }
  49.     public function getId(): ?int
  50.     {
  51.         return $this->id;
  52.     }
  53.     public function getCode(): ?string
  54.     {
  55.         return $this->code;
  56.     }
  57.     public function setCode(?string $code): self
  58.     {
  59.         $this->code $code;
  60.         return $this;
  61.     }
  62.     public function getAbreviation(): ?string
  63.     {
  64.         return $this->abreviation;
  65.     }
  66.     public function setAbreviation(?string $abreviation): self
  67.     {
  68.         $this->abreviation $abreviation;
  69.         return $this;
  70.     }
  71.     public function getDate(): ?\DateTimeInterface
  72.     {
  73.         return $this->date;
  74.     }
  75.     public function setDate(?\DateTimeInterface $date): self
  76.     {
  77.         $this->date $date;
  78.         return $this;
  79.     }
  80.     /**
  81.      * @return Collection<int, PArretTravailLg>
  82.      */
  83.     public function getArretTravailLgs(): Collection
  84.     {
  85.         return $this->arretTravailLgs;
  86.     }
  87.     public function addArretTravailLg(PArretTravailLg $arretTravailLg): self
  88.     {
  89.         if (!$this->arretTravailLgs->contains($arretTravailLg)) {
  90.             $this->arretTravailLgs->add($arretTravailLg);
  91.             $arretTravailLg->setPeriode($this);
  92.         }
  93.         return $this;
  94.     }
  95.     public function removeArretTravailLg(PArretTravailLg $arretTravailLg): self
  96.     {
  97.         if ($this->arretTravailLgs->removeElement($arretTravailLg)) {
  98.             // set the owning side to null (unless already changed)
  99.             if ($arretTravailLg->getPeriode() === $this) {
  100.                 $arretTravailLg->setPeriode(null);
  101.             }
  102.         }
  103.         return $this;
  104.     }
  105.     /**
  106.      * @return Collection<int, LElementEcheance>
  107.      */
  108.     public function getElementEcheances(): Collection
  109.     {
  110.         return $this->elementEcheances;
  111.     }
  112.     public function addElementEcheance(LElementEcheance $elementEcheance): self
  113.     {
  114.         if (!$this->elementEcheances->contains($elementEcheance)) {
  115.             $this->elementEcheances->add($elementEcheance);
  116.             $elementEcheance->setPeriode($this);
  117.         }
  118.         return $this;
  119.     }
  120.     public function removeElementEcheance(LElementEcheance $elementEcheance): self
  121.     {
  122.         if ($this->elementEcheances->removeElement($elementEcheance)) {
  123.             // set the owning side to null (unless already changed)
  124.             if ($elementEcheance->getPeriode() === $this) {
  125.                 $elementEcheance->setPeriode(null);
  126.             }
  127.         }
  128.         return $this;
  129.     }
  130.     /**
  131.      * @return Collection<int, Tbulletin>
  132.      */
  133.     public function getBulletins(): Collection
  134.     {
  135.         return $this->bulletins;
  136.     }
  137.     public function addBulletin(Tbulletin $bulletin): self
  138.     {
  139.         if (!$this->bulletins->contains($bulletin)) {
  140.             $this->bulletins->add($bulletin);
  141.             $bulletin->setPeriode($this);
  142.         }
  143.         return $this;
  144.     }
  145.     public function removeBulletin(Tbulletin $bulletin): self
  146.     {
  147.         if ($this->bulletins->removeElement($bulletin)) {
  148.             // set the owning side to null (unless already changed)
  149.             if ($bulletin->getPeriode() === $this) {
  150.                 $bulletin->setPeriode(null);
  151.             }
  152.         }
  153.         return $this;
  154.     }
  155.    
  156.     /**
  157.      * @return Collection<int, PPrelevementLg>
  158.      */
  159.     public function getPrelevementLgs(): Collection
  160.     {
  161.         return $this->prelevementLgs;
  162.     }
  163.     public function addPrelevementLg(PPrelevementLg $prelevementLg): self
  164.     {
  165.         if (!$this->prelevementLgs->contains($prelevementLg)) {
  166.             $this->prelevementLgs->add($prelevementLg);
  167.             $prelevementLg->setPeriode($this);
  168.         }
  169.         return $this;
  170.     }
  171.     public function removePrelevementLg(PPrelevementLg $prelevementLg): self
  172.     {
  173.         if ($this->prelevementLgs->removeElement($prelevementLg)) {
  174.             // set the owning side to null (unless already changed)
  175.             if ($prelevementLg->getPeriode() === $this) {
  176.                 $prelevementLg->setPeriode(null);
  177.             }
  178.         }
  179.         return $this;
  180.     }
  181.     /**
  182.      * @return Collection<int, Probleme>
  183.      */
  184.     public function getProblemes(): Collection
  185.     {
  186.         return $this->problemes;
  187.     }
  188.     public function addProbleme(Probleme $probleme): self
  189.     {
  190.         if (!$this->problemes->contains($probleme)) {
  191.             $this->problemes->add($probleme);
  192.             $probleme->setPeriode($this);
  193.         }
  194.         return $this;
  195.     }
  196.     public function removeProbleme(Probleme $probleme): self
  197.     {
  198.         if ($this->problemes->removeElement($probleme)) {
  199.             // set the owning side to null (unless already changed)
  200.             if ($probleme->getPeriode() === $this) {
  201.                 $probleme->setPeriode(null);
  202.             }
  203.         }
  204.         return $this;
  205.     }
  206.     /**
  207.      * @return Collection<int, PBordereau>
  208.      */
  209.     public function getBordereaus(): Collection
  210.     {
  211.         return $this->bordereaus;
  212.     }
  213.     public function addBordereau(PBordereau $bordereau): self
  214.     {
  215.         if (!$this->bordereaus->contains($bordereau)) {
  216.             $this->bordereaus->add($bordereau);
  217.             $bordereau->setPeriode($this);
  218.         }
  219.         return $this;
  220.     }
  221.     public function removeBordereau(PBordereau $bordereau): self
  222.     {
  223.         if ($this->bordereaus->removeElement($bordereau)) {
  224.             // set the owning side to null (unless already changed)
  225.             if ($bordereau->getPeriode() === $this) {
  226.                 $bordereau->setPeriode(null);
  227.             }
  228.         }
  229.         return $this;
  230.     }
  231.     public function isValider(): ?bool
  232.     {
  233.         return $this->isValider;
  234.     }
  235.     public function setIsValider(?bool $isValider): static
  236.     {
  237.         $this->isValider $isValider;
  238.         return $this;
  239.     }
  240.     public function isIntegrer(): ?bool
  241.     {
  242.         return $this->isIntegrer;
  243.     }
  244.     public function setIsIntegrer(?bool $isIntegrer): static
  245.     {
  246.         $this->isIntegrer $isIntegrer;
  247.         return $this;
  248.     }
  249.     /**
  250.      * @return Collection<int, SyntheseRemunarationCab>
  251.      */
  252.     public function getSyntheseRemunarationCabs(): Collection
  253.     {
  254.         return $this->syntheseRemunarationCabs;
  255.     }
  256.     public function addSyntheseRemunarationCab(SyntheseRemunarationCab $syntheseRemunarationCab): static
  257.     {
  258.         if (!$this->syntheseRemunarationCabs->contains($syntheseRemunarationCab)) {
  259.             $this->syntheseRemunarationCabs->add($syntheseRemunarationCab);
  260.             $syntheseRemunarationCab->setPeriode($this);
  261.         }
  262.         return $this;
  263.     }
  264.     public function removeSyntheseRemunarationCab(SyntheseRemunarationCab $syntheseRemunarationCab): static
  265.     {
  266.         if ($this->syntheseRemunarationCabs->removeElement($syntheseRemunarationCab)) {
  267.             // set the owning side to null (unless already changed)
  268.             if ($syntheseRemunarationCab->getPeriode() === $this) {
  269.                 $syntheseRemunarationCab->setPeriode(null);
  270.             }
  271.         }
  272.         return $this;
  273.     }
  274. }