src/Entity/Formation.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\FormationRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Validator\Constraints as Assert;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  14. /**
  15.  * @ORM\Entity(repositoryClass=FormationRepository::class)
  16.  * @UniqueEntity(fields={"wording"},message="Ce nom est déjà utilisé." )
  17.  * @Vich\Uploadable
  18.  */
  19. class Formation
  20. {
  21.     /**
  22.      * @ORM\Id
  23.      * @ORM\GeneratedValue
  24.      * @ORM\Column(type="integer")
  25.      */
  26.     private $id;
  28.     /**
  29.      * @ORM\Column(type="string", length=255)
  30.      */
  31.     private $wording;
  33.     /**
  34.      * @ORM\Column(type="text", nullable=true)
  35.      */
  36.     private $long_wording;
  38.     /**
  39.      * @ORM\Column(type="text", nullable=true)
  40.      */
  41.     private $description;
  43.     /**
  44.      * @ORM\Column(type="float", nullable=true)
  45.      */
  46.     private $duration;
  48.     /**
  49.      * @ORM\Column(type="string", length=10, nullable=true)
  50.      */
  51.     private $color;
  53.     /**
  54.      * @ORM\Column(type="integer")
  55.      */
  56.     private $max_student;
  58.     /**
  59.      * @ORM\Column(type="float")
  60.      */
  61.     private $price;
  63.     /**
  64.      * @ORM\OneToMany(targetEntity=Session::class, mappedBy="formation")
  65.      */
  66.     private $sessions;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=JustifForm::class, mappedBy="formation",cascade={"persist","remove"})
  70.      */
  71.     private $justifForms;
  73.     /**
  74.      * @ORM\ManyToOne(targetEntity=Demande::class, inversedBy="formation",cascade={"persist"})
  75.      */
  76.     private $demande;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Demande::class, mappedBy="positionnement")
  80.      */
  81.     private $positionnement;
  83.     /**
  84.      * @Doctrine\ORM\Mapping\Column(type="string", length=255, nullable=true)
  85.      */
  86.     private $image;
  88.     /**
  89.      * @Vich\UploadableField(mapping="logo_formation", fileNameProperty="image")
  90.      */
  91.     private $fichier; 
  93.     /**
  94.      * @ORM\Column(type="datetime_immutable", nullable=true)
  95.      */
  96.     private $updateAt;
  98.     /**
  99.      * @ORM\ManyToOne(targetEntity=CategorieFormation::class, inversedBy="formations")
  100.      */
  101.     private $categorieformation;
  103.     /**
  104.      * @ORM\Column(type="boolean", nullable=true)
  105.      */
  106.     private $certificat;
  108.     /**
  109.      * @ORM\Column(type="boolean", nullable=true)
  110.      */
  111.     private $attestation;
  113.     /**
  114.      * @ORM\Column(type="boolean", nullable=true)
  115.      */
  116.     private $diplome;
  118.     /**
  119.      * @ORM\Column(type="boolean", nullable=true)
  120.      */
  121.     private $carte;
  123.     /**
  124.      * @ORM\Column(type="text", nullable=true)
  125.      */
  126.     private $objectif;
  128.     /**
  129.      * @ORM\Column(type="text", nullable=true)
  130.      */
  131.     private $wordingdiplome;
  133.     /**
  134.      * @ORM\Column(type="boolean", nullable=true)
  135.      */
  136.     private $formateur;
  138.     /**
  139.      * @ORM\Column(type="boolean", nullable=true)
  140.      */
  141.     private $longformation;
  143.     /**
  144.      * @ORM\OneToMany(targetEntity=OptionCategorieInscrit::class, mappedBy="formation", cascade={"persist", "remove"})
  145.      */
  146.     private $optionCategorieInscrits;
  148.      /**
  149.      * @ORM\Column(type="boolean", nullable=true)
  150.      */
  151.     private $online;
  152.     /**
  153.      * @ORM\Column(type="text", nullable=true)
  154.      */
  155.     private $publicVise;
  156.     /**
  157.      * @ORM\Column(type="text", nullable=true)
  158.      */
  159.     private $competenceVise;
  160.     /**
  161.      * @ORM\Column(type="text", nullable=true)
  162.      */
  163.     private $modaliteEvaluation;
  164.     /**
  165.      * @ORM\Column(type="string", length=255, nullable=true)
  166.      */
  167.     private $lieu;
  168.     /**
  169.      * @ORM\Column(type="text", length=255, nullable=true)
  170.      */
  171.     private $DelaiAcces;
  172.     /**
  173.      * @ORM\Column(type="text", length=255, nullable=true)
  174.      */
  175.     private $TauxReussite;
  176.     /**
  177.      * @ORM\Column(type="text", nullable=true)
  178.      */
  179.     private $Prerequis;
  180.     /**
  181.      * @ORM\Column(type="text", nullable=true)
  182.      */
  183.     private $NiveauSortie;
  184.     /**
  185.      * @ORM\Column(type="text", nullable=true)
  186.      */
  187.     private $contenu;
  188.     /**
  189.      * @ORM\Column(type="text", nullable=true)
  190.      */
  191.     private $Debouche;
  192.     /**
  193.      * @ORM\Column(type="text", nullable=true)
  194.      */
  195.     private $methodeApprentissage;
  196.     /**
  197.      * @ORM\ManyToMany(targetEntity=DemandeDevisSite::class, mappedBy="formation")
  198.      */
  199.     private $demandeDevisSites;
  200.     /**
  201.      * @ORM\OneToMany(targetEntity=StagaireDemandeDevis::class, mappedBy="Formation")
  202.      */
  203.     private $stagaireDemandeDevis;
  204.      /**
  205.      * @ORM\Column(type="boolean", nullable=true)
  206.      */
  207.     private $evaluation;
  209.     /**
  210.      * @ORM\ManyToMany(targetEntity=ModuleSession::class, cascade={"persist"})
  211.      */
  212.     private $modules;
  214.     /**
  215.      * @ORM\OneToMany(targetEntity=DemandeDevisLigne::class, mappedBy="formation")
  216.      */
  217.     private $demandeDevisLignes;
  219.     /**
  220.      * @ORM\Column(type="integer", nullable=true)
  221.      */
  222.     private $elearning;
  224.     /**
  225.      * @ORM\Column(type="integer", nullable=true)
  226.      */
  227.     private $thinkificId;
  229.     /**
  230.      * @ORM\Column(type="integer", nullable=true)
  231.      */
  232.     private $thinkificQcmId;
  234.     
  235.     /**
  236.      * @ORM\ManyToMany(targetEntity=ChecklistClotureSession::class, inversedBy="formations")
  237.      */
  238.     private $requis;
  240.     /**
  241.      * @ORM\OneToMany(targetEntity=FormationDocument::class, mappedBy="formation")
  242.      */
  243.     private $document; 
  245.     /**
  246.      * @ORM\Column(type="string", length=255)
  247.      */
  248.     private $imageimage; 
  250.     /**
  251.      * @Vich\UploadableField(mapping="image_formation", fileNameProperty="imageimage")
  252.     */
  253.     private $picture;
  255.     /**
  256.      * @ORM\ManyToMany(targetEntity=FormationMenu::class, inversedBy="formations")
  257.      */
  258.     private $menu;
  260.     /**
  261.      * @ORM\Column(type="boolean", nullable=true)
  262.      */
  263.     private $initiale;
  265.     /**
  266.      * @ORM\OneToMany(targetEntity=LigneConvention::class, mappedBy="Formation")
  267.      */
  268.     private $ligneConventions;
  270.     /**
  271.      * @ORM\Column(type="string", length=255, nullable=true)
  272.      */
  273.     private $livretStagiaire; 
  275.     /**
  276.      * @Vich\UploadableField(mapping="livret_stagiaire", fileNameProperty="livretStagiaire")
  277.      */
  278.     private $fichierLivret;
  280.     /**
  281.      * @ORM\Column(type="boolean", nullable=true)
  282.      */
  283.     private $ispublish;
  285.     /**
  286.      * @ORM\OneToMany(targetEntity="App\Entity\PlanDeFormation", mappedBy="formation", cascade={"persist", "remove"})
  287.      */
  288.     private $planDeFormations;
  290.     ///**
  291.     // * @ORM\Column(type="boolean", nullable=true)
  292.     // */
  293.     //private $certificatMedical;
  295.     /**
  296.      * @ORM\OneToMany(targetEntity=DemandePro::class, mappedBy="formation")
  297.      */
  298.     private $demandePros;
  300.     public function __construct()
  301.     {
  302.         $this->sessions = new ArrayCollection();
  303.         $this->justifForms = new ArrayCollection();
  304.         $this->positionnement = new ArrayCollection();
  305.         $this->optionCategorieInscrits = new ArrayCollection();
  306.         $this->demandeDevisSites = new ArrayCollection();
  307.         $this->stagaireDemandeDevis = new ArrayCollection();
  308.         $this->modules = new ArrayCollection();
  309.         $this->demandeDevisLignes = new ArrayCollection();
  310.         
  311.         $this->requis = new ArrayCollection();
  312.         $this->document = new ArrayCollection();
  313.         $this->menu = new ArrayCollection();
  314.         $this->ligneConventions = new ArrayCollection();
  316.         $this->planDeFormations = new ArrayCollection();
  317.         $this->demandePros = new ArrayCollection(); 
  318.     
  319.     }
  321.     public function __toString()
  322.     {
  323.         return $this->getWording(); 
  324.     }
  326.     public function getId(): ?int
  327.     {
  328.         return $this->id;
  329.     }
  331.     public function getWording(): ?string
  332.     {
  333.         return $this->wording;
  334.     }
  336.     public function setWording(string $wording): self
  337.     {
  338.         $this->wording = $wording;
  340.         return $this;
  341.     }
  343.     public function isOnline(): ?bool
  344.     {
  345.         return $this->online;
  346.     }
  347.     public function setOnline(?bool $online): self
  348.     {
  349.         $this->online = $online;
  350.         return $this;
  351.     }
  352.     public function getPublicVise(): ?string
  353.     {
  354.         return $this->publicVise;
  355.     }
  356.     public function setPublicVise(?string $publicVise): self
  357.     {
  358.         $this->publicVise = $publicVise;
  359.         return $this;
  360.     }
  361.     public function getCompetenceVise(): ?string
  362.     {
  363.         return $this->competenceVise;
  364.     }
  365.     public function setCompetenceVise(?string $competenceVise): self
  366.     {
  367.         $this->competenceVise = $competenceVise;
  368.         return $this;
  369.     }
  370.     public function getModaliteEvaluation(): ?string
  371.     {
  372.         return $this->modaliteEvaluation;
  373.     }
  374.     public function setModaliteEvaluation(?string $modaliteEvaluation): self
  375.     {
  376.         $this->modaliteEvaluation = $modaliteEvaluation;
  377.         return $this;
  378.     }
  379.     public function getLieu(): ?string
  380.     {
  381.         return $this->lieu;
  382.     }
  383.     public function setLieu(?string $lieu): self
  384.     {
  385.         $this->lieu = $lieu;
  386.         return $this;
  387.     }
  388.     public function getDelaiAcces(): ?string
  389.     {
  390.         return $this->DelaiAcces;
  391.     }
  392.     public function setDelaiAcces(?string $DelaiAcces): self
  393.     {
  394.         $this->DelaiAcces = $DelaiAcces;
  395.         return $this;
  396.     }
  397.     public function getTauxReussite(): ?string
  398.     {
  399.         return $this->TauxReussite;
  400.     }
  401.     public function setTauxReussite(?string $TauxReussite): self
  402.     {
  403.         $this->TauxReussite = $TauxReussite;
  404.         return $this;
  405.     }
  406.     public function getPrerequis(): ?string
  407.     {
  408.         return $this->Prerequis;
  409.     }
  410.     public function setPrerequis(?string $Prerequis): self
  411.     {
  412.         $this->Prerequis = $Prerequis;
  413.         return $this;
  414.     }
  415.     public function getNiveauSortie(): ?string
  416.     {
  417.         return $this->NiveauSortie;
  418.     }
  419.     public function setNiveauSortie(?string $NiveauSortie): self
  420.     {
  421.         $this->NiveauSortie = $NiveauSortie;
  422.         return $this;
  423.     }
  424.     public function getContenu(): ?string
  425.     {
  426.         return $this->contenu;
  427.     }
  428.     public function setContenu(?string $contenu): self
  429.     {
  430.         $this->contenu = $contenu;
  431.         return $this;
  432.     }
  433.     public function getDebouche(): ?string
  434.     {
  435.         return $this->Debouche;
  436.     }
  437.     public function setDebouche(?string $Debouche): self
  438.     {
  439.         $this->Debouche = $Debouche;
  440.         return $this;
  441.     }
  442.     public function getMethodeApprentissage(): ?string
  443.     {
  444.         return $this->methodeApprentissage;
  445.     }
  446.     public function setMethodeApprentissage(?string $methodeApprentissage): self
  447.     {
  448.         $this->methodeApprentissage = $methodeApprentissage;
  449.         return $this;
  450.     }
  451.     /**
  452.      * @return Collection<int, DemandeDevisSite>
  453.      */
  454.     public function getDemandeDevisSites(): Collection
  455.     {
  456.         return $this->demandeDevisSites;
  457.     }
  458.     public function addDemandeDevisSite(DemandeDevisSite $demandeDevisSite): self
  459.     {
  460.         if (!$this->demandeDevisSites->contains($demandeDevisSite)) {
  461.             $this->demandeDevisSites[] = $demandeDevisSite;
  462.             $demandeDevisSite->addFormation($this);
  463.         }
  464.         return $this;
  465.     }
  466.     public function removeDemandeDevisSite(DemandeDevisSite $demandeDevisSite): self
  467.     {
  468.         if ($this->demandeDevisSites->removeElement($demandeDevisSite)) {
  469.             $demandeDevisSite->removeFormation($this);
  470.         }
  471.         return $this;
  472.     }
  473.     /**
  474.      * @return Collection<int, StagaireDemandeDevis>
  475.      */
  476.     public function getStagaireDemandeDevis(): Collection
  477.     {
  478.         return $this->stagaireDemandeDevis;
  479.     }
  480.     public function addStagaireDemandeDevi(StagaireDemandeDevis $stagaireDemandeDevi): self
  481.     {
  482.         if (!$this->stagaireDemandeDevis->contains($stagaireDemandeDevi)) {
  483.             $this->stagaireDemandeDevis[] = $stagaireDemandeDevi;
  484.             $stagaireDemandeDevi->setFormation($this);
  485.         }
  486.         return $this;
  487.     }
  488.     public function removeStagaireDemandeDevi(StagaireDemandeDevis $stagaireDemandeDevi): self
  489.     {
  490.         if ($this->stagaireDemandeDevis->removeElement($stagaireDemandeDevi)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($stagaireDemandeDevi->getFormation() === $this) {
  493.                 $stagaireDemandeDevi->setFormation(null);
  494.             }
  495.         }
  496.         return $this;
  497.     }
  499.     public function getLongWording(): ?string
  500.     {
  501.         return $this->long_wording;
  502.     }
  504.     public function setLongWording(?string $long_wording): self
  505.     {
  506.         $this->long_wording = $long_wording;
  508.         return $this;
  509.     }
  511.     public function getDescription(): ?string
  512.     {
  513.         return $this->description;
  514.     }
  516.     public function setDescription(?string $description): self
  517.     {
  518.         $this->description = $description;
  520.         return $this;
  521.     }
  523.     public function getDuration(): ?float
  524.     {
  525.         return $this->duration;
  526.     }
  528.     public function setDuration(?float $duration): self
  529.     {
  530.         $this->duration = $duration;
  532.         return $this;
  533.     }
  535.     public function getColor(): ?string
  536.     {
  537.         return $this->color;
  538.     }
  540.     public function setColor(?string $color): self
  541.     {
  542.         $this->color = $color;
  544.         return $this;
  545.     }
  547.     public function getMaxStudent(): ?int
  548.     {
  549.         return $this->max_student;
  550.     }
  552.     public function setMaxStudent(int $max_student): self
  553.     {
  554.         $this->max_student = $max_student;
  556.         return $this;
  557.     }
  559.     public function getPrice(): ?float
  560.     {
  561.         return $this->price;
  562.     }
  564.     public function setPrice(float $price): self
  565.     {
  566.         $this->price = $price;
  568.         return $this;
  569.     }
  571.     /**
  572.      * @return Collection<int, Session>
  573.      */
  574.     public function getSessions(): Collection
  575.     {
  576.         return $this->sessions;
  577.     }
  579.     public function addSession(Session $session): self
  580.     {
  581.         if (!$this->sessions->contains($session)) {
  582.             $this->sessions[] = $session;
  583.             $session->setFormation($this);
  584.         }
  586.         return $this;
  587.     }
  589.     public function removeSession(Session $session): self
  590.     {
  591.         if ($this->sessions->removeElement($session)) {
  592.             // set the owning side to null (unless already changed)
  593.             if ($session->getFormation() === $this) {
  594.                 $session->setFormation(null);
  595.             }
  596.         }
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return Collection<int, JustifForm>
  603.      */
  604.     public function getJustifForms(): Collection
  605.     {
  606.         return $this->justifForms;
  607.     }
  609.     public function addJustifForm(JustifForm $justifForm): self
  610.     {
  611.         if (!$this->justifForms->contains($justifForm)) {
  612.             $this->justifForms[] = $justifForm;
  613.             $justifForm->setFormation($this);
  614.         }
  616.         return $this;
  617.     }
  619.     public function removeJustifForm(JustifForm $justifForm): self
  620.     {
  621.         if ($this->justifForms->removeElement($justifForm)) {
  622.             // set the owning side to null (unless already changed)
  623.             if ($justifForm->getFormation() === $this) {
  624.                 $justifForm->setFormation(null);
  625.             }
  626.         }
  628.         return $this;
  629.     }
  631.     public function getDemande(): ?Demande
  632.     {
  633.         return $this->demande;
  634.     }
  636.     public function setDemande(?Demande $demande): self
  637.     {
  638.         $this->demande = $demande;
  640.         return $this;
  641.     }
  643.     /**
  644.      * @return Collection<int, Demande>
  645.      */
  646.     public function getPositionnement(): Collection
  647.     {
  648.         return $this->positionnement;
  649.     }
  651.     public function addPositionnement(Demande $positionnement): self
  652.     {
  653.         if (!$this->positionnement->contains($positionnement)) {
  654.             $this->positionnement[] = $positionnement;
  655.             $positionnement->setPositionnement($this);
  656.         }
  658.         return $this;
  659.     }
  661.     public function removePositionnement(Demande $positionnement): self
  662.     {
  663.         if ($this->positionnement->removeElement($positionnement)) {
  664.             // set the owning side to null (unless already changed)
  665.             if ($positionnement->getPositionnement() === $this) {
  666.                 $positionnement->setPositionnement(null);
  667.             }
  668.         }
  670.         return $this;
  671.     }
  673.     public function setFichier(?File $image = null)
  674.     {
  675.         $this->fichier = $image;
  677.         if ($image) {
  678.             $this->updateAt = new \DateTimeImmutable();
  679.         }
  681.     }
  683.     public function getFichier()
  684.     {
  685.         return $this->fichier;
  686.     }
  687.     public function setImage($image)
  688.     {
  689.         $this->image = $image;
  690.     }
  692.     public function getImage()
  693.     {
  694.         return $this->image;
  695.     }
  697.     public function getUpdateAt(): ?\DateTimeImmutable
  698.     {
  699.         return $this->updateAt;
  700.     }
  702.     public function setUpdateAt(?\DateTimeImmutable $updateAt): self
  703.     {
  704.         $this->updateAt = $updateAt;
  706.         return $this;
  707.     }
  709.     public function getCategorieformation(): ?CategorieFormation
  710.     {
  711.         return $this->categorieformation;
  712.     }
  714.     public function setCategorieformation(?CategorieFormation $categorieformation): self
  715.     {
  716.         $this->categorieformation = $categorieformation;
  718.         return $this;
  719.     }
  721.     public function isCertificat(): ?bool
  722.     {
  723.         return $this->certificat;
  724.     }
  726.     public function setCertificat(?bool $certificat): self
  727.     {
  728.         $this->certificat = $certificat;
  730.         return $this;
  731.     }
  733.     public function isAttestation(): ?bool
  734.     {
  735.         return $this->attestation;
  736.     }
  738.     public function setAttestation(?bool $attestation): self
  739.     {
  740.         $this->attestation = $attestation;
  742.         return $this;
  743.     }
  745.     public function isDiplome(): ?bool
  746.     {
  747.         return $this->diplome;
  748.     }
  750.     public function setDiplome(?bool $diplome): self
  751.     {
  752.         $this->diplome = $diplome;
  754.         return $this;
  755.     }
  757.     public function isCarte(): ?bool
  758.     {
  759.         return $this->carte;
  760.     }
  762.     public function setCarte(?bool $carte): self
  763.     {
  764.         $this->carte = $carte;
  766.         return $this;
  767.     }
  769.     public function getObjectif(): ?string
  770.     {
  771.         return $this->objectif;
  772.     }
  774.     public function setObjectif(?string $objectif): self
  775.     {
  776.         $this->objectif = $objectif;
  778.         return $this;
  779.     }
  781.     public function getWordingdiplome(): ?string
  782.     {
  783.         return $this->wordingdiplome;
  784.     }
  786.     public function setWordingdiplome(?string $wordingdiplome): self
  787.     {
  788.         $this->wordingdiplome = $wordingdiplome;
  790.         return $this;
  791.     }
  793.     public function isFormateur(): ?bool
  794.     {
  795.         return $this->formateur;
  796.     }
  798.     public function setFormateur(?bool $formateur): self
  799.     {
  800.         $this->formateur = $formateur;
  802.         return $this;
  803.     }
  805.     public function isLongformation(): ?bool
  806.     {
  807.         return $this->longformation;
  808.     }
  810.     public function setLongformation(?bool $longformation): self
  811.     {
  812.         $this->longformation = $longformation;
  814.         return $this;
  815.     }
  817.     /**
  818.      * @return Collection<int, OptionCategorieInscrit>
  819.      */
  820.     public function getOptionCategorieInscrits(): Collection
  821.     {
  822.         return $this->optionCategorieInscrits;
  823.     }
  825.     public function addOptionCategorieInscrit(OptionCategorieInscrit $optionCategorieInscrit): self
  826.     {
  827.         if (!$this->optionCategorieInscrits->contains($optionCategorieInscrit)) {
  828.             $this->optionCategorieInscrits[] = $optionCategorieInscrit;
  829.             $optionCategorieInscrit->setFormation($this);
  830.         }
  832.         return $this;
  833.     }
  835.     public function removeOptionCategorieInscrit(OptionCategorieInscrit $optionCategorieInscrit): self
  836.     {
  837.         if ($this->optionCategorieInscrits->removeElement($optionCategorieInscrit)) {
  838.             // set the owning side to null (unless already changed)
  839.             if ($optionCategorieInscrit->getFormation() === $this) {
  840.                 $optionCategorieInscrit->setFormation(null);
  841.             }
  842.         }
  844.         return $this;
  845.     }
  846.     public function isEvaluation(): ?bool
  847.     {
  848.         return $this->evaluation;
  849.     }
  851.     public function setEvaluation(?bool $online): self
  852.     {
  853.         $this->evaluation = $online;
  855.         return $this;
  856.     }
  857.      /**
  858.      * @return Collection<int, ModuleSession>
  859.      */
  860.     public function getModules(): Collection
  861.     {
  862.         return $this->modules;
  863.     }
  865.     public function addModule(ModuleSession $module): self
  866.     {
  867.         if (!$this->modules->contains($module)) {
  868.             $this->modules[] = $module;
  869.         }
  871.         return $this;
  872.     }
  874.     public function removeModule(ModuleSession $module): self
  875.     {
  876.         $this->modules->removeElement($module);
  878.         return $this;
  879.     }
  881.     /**
  882.      * @return Collection<int, DemandeDevisLigne>
  883.      */
  884.     public function getDemandeDevisLignes(): Collection
  885.     {
  886.         return $this->demandeDevisLignes;
  887.     }
  889.     public function addDemandeDevisLigne(DemandeDevisLigne $demandeDevisLigne): self
  890.     {
  891.         if (!$this->demandeDevisLignes->contains($demandeDevisLigne)) {
  892.             $this->demandeDevisLignes[] = $demandeDevisLigne;
  893.             $demandeDevisLigne->setFormation($this);
  894.         }
  896.         return $this;
  897.     }
  899.     public function removeDemandeDevisLigne(DemandeDevisLigne $demandeDevisLigne): self
  900.     {
  901.         if ($this->demandeDevisLignes->removeElement($demandeDevisLigne)) {
  902.             // set the owning side to null (unless already changed)
  903.             if ($demandeDevisLigne->getFormation() === $this) {
  904.                 $demandeDevisLigne->setFormation(null);
  905.             }
  906.         }
  908.         return $this;
  909.     }
  911.     public function getElearning(): ?int
  912.     {
  913.         return $this->elearning;
  914.     }
  916.     public function setElearning(?int $elearning): self
  917.     {
  918.         $this->elearning = $elearning;
  920.         return $this;
  921.     }
  923.     public function getThinkificId(): ?int
  924.     {
  925.         return $this->thinkificId;
  926.     }
  928.     public function setThinkificId(?int $thinkificId): self
  929.     {
  930.         $this->thinkificId = $thinkificId;
  932.         return $this;
  933.     }
  935.     public function getThinkificQcmId(): ?int
  936.     {
  937.         return $this->thinkificQcmId;
  938.     }
  940.     public function setThinkificQcmId(?int $thinkificQcmId): self
  941.     {
  942.         $this->thinkificQcmId = $thinkificQcmId;
  944.         return $this;
  945.     }
  947.    
  949.    
  951.     /**
  952.      * @return Collection<int, ChecklistClotureSession>
  953.      */
  954.     public function getRequis(): Collection
  955.     {
  956.         return $this->requis;
  957.     }
  959.     public function addRequi(ChecklistClotureSession $requi): self
  960.     {
  961.         if (!$this->requis->contains($requi)) {
  962.             $this->requis[] = $requi;
  963.         }
  965.         return $this;
  966.     }
  968.     public function removeRequi(ChecklistClotureSession $requi): self
  969.     {
  970.         $this->requis->removeElement($requi);
  972.         return $this;
  973.     }
  975.     /**
  976.      * @return Collection<int, FormationDocument>
  977.      */
  978.     public function getDocument(): Collection
  979.     {
  980.         return $this->document;
  981.     }
  983.     public function addDocument(FormationDocument $document): self
  984.     {
  985.         if (!$this->document->contains($document)) {
  986.             $this->document[] = $document;
  987.             $document->setFormation($this);
  988.         }
  990.         return $this;
  991.     }
  993.     public function removeDocument(FormationDocument $document): self
  994.     {
  995.         if ($this->document->removeElement($document)) {
  996.             // set the owning side to null (unless already changed)
  997.             if ($document->getFormation() === $this) {
  998.                 $document->setFormation(null);
  999.             }
  1000.         }
  1002.         return $this;
  1003.     }
  1005.     public function getImageimage(): ?string
  1006.     {
  1007.         return $this->imageimage;
  1008.     }
  1010.     public function setImageimage(?string $imageimage): self
  1011.     {
  1012.         $this->imageimage = $imageimage;
  1014.         return $this;
  1015.     }  
  1016.     public function setPicture(?File $imageimage = null): self
  1017.     {
  1018.         $this->picture = $imageimage;
  1020.         if ($imageimage) {
  1021.             $this->updateAt = new \DateTimeImmutable();
  1022.         }
  1023.         return $this; 
  1024.     }
  1026.     public function getPicture()
  1027.     {
  1028.         return $this->picture;
  1029.     }
  1031.     /**
  1032.      * @return Collection<int, FormationMenu>
  1033.      */
  1034.     public function getMenu(): Collection
  1035.     {
  1036.         return $this->menu;
  1037.     }
  1039.     public function addMenu(FormationMenu $menu): self
  1040.     {
  1041.         if (!$this->menu->contains($menu)) { 
  1042.             $this->menu[] = $menu;
  1043.         }
  1045.         return $this;
  1046.     }
  1048.     public function removeMenu(FormationMenu $menu): self
  1049.     {
  1050.         $this->menu->removeElement($menu);
  1052.         return $this;
  1053.     }
  1055.     public function isInitiale(): ?bool
  1056.     {
  1057.         return $this->initiale;
  1058.     }
  1060.     public function setInitiale(?bool $initiale): self
  1061.     {
  1062.         $this->initiale = $initiale;
  1064.         return $this;
  1065.     }
  1067.     /**
  1068.      * @return Collection<int, LigneConvention>
  1069.      */
  1070.     public function getLigneConventions(): Collection
  1071.     {
  1072.         return $this->ligneConventions;
  1073.     }
  1075.     public function addLigneConvention(LigneConvention $ligneConvention): self
  1076.     {
  1077.         if (!$this->ligneConventions->contains($ligneConvention)) {
  1078.             $this->ligneConventions[] = $ligneConvention;
  1079.             $ligneConvention->setFormation($this);
  1080.         }
  1082.         return $this;
  1083.     }
  1085.     public function removeLigneConvention(LigneConvention $ligneConvention): self
  1086.     {
  1087.         if ($this->ligneConventions->removeElement($ligneConvention)) {
  1088.             // set the owning side to null (unless already changed)
  1089.             if ($ligneConvention->getFormation() === $this) {
  1090.                 $ligneConvention->setFormation(null);
  1091.             }
  1092.         }
  1094.         return $this;
  1095.     }
  1097.     public function getLivretStagiaire(): ?string
  1098.     {
  1099.         return $this->livretStagiaire;
  1100.     }
  1102.     public function setLivretStagiaire(?string $livretStagiaire): self
  1103.     {
  1104.         $this->livretStagiaire = $livretStagiaire;
  1106.         return $this;
  1107.     }   
  1109.     public function getFichierLivret()
  1110.     {
  1111.         return $this->fichierLivret;
  1112.     } 
  1114.     public function setFichierLivret(?File $livretStagiaire = null)
  1115.     {
  1116.         $this->fichierLivret = $livretStagiaire;
  1118.         if ($livretStagiaire) {
  1119.             $this->updateAt = new \DateTimeImmutable();
  1120.         }
  1122.     }
  1124.     public function isPublish(): ?bool
  1125.     {
  1126.         return $this->ispublish;
  1127.     }
  1129.     public function setIsPublish(?bool $ispublish): self
  1130.     {
  1131.         $this->ispublish = $ispublish;
  1133.         return $this;
  1134.     }
  1136.     /**
  1137.      * @return Collection|PlanDeFormation[]
  1138.      */
  1139.     public function getPlanDeFormations(): Collection
  1140.     {
  1141.         return $this->planDeFormations;
  1142.     }
  1144.     public function addPlanDeFormation(PlanDeFormation $planDeFormation): self
  1145.     {
  1146.         // if (!$this->planDeFormations->contains($planDeFormation)) {
  1147.         //     $this->planDeFormations[] = $planDeFormation;
  1148.         // }
  1149.         if (!$this->planDeFormations->contains($planDeFormation)) {
  1150.             $this->planDeFormations[] = $planDeFormation;
  1151.             $planDeFormation->setFormation($this);
  1152.         }
  1154.         return $this;
  1155.     }
  1157.     public function removePlanDeFormation(PlanDeFormation $planDeFormation): self
  1158.     {
  1159.         if ($this->planDeFormations->removeElement($planDeFormation)) {
  1160.             if ($planDeFormation->getFormation() === $this) {
  1161.                 $planDeFormation->setFormation(null);
  1162.             }
  1163.         }
  1165.         return $this;
  1166.     }
  1168.     // public function isCertificatMedical(): ?bool
  1169.     // {
  1170.     //     return $this->certificatMedical;
  1171.     // }
  1173.     // public function setCertificatMedical(?bool $certificatMedical): self
  1174.     // {
  1175.     //     $this->certificatMedical = $certificatMedical;
  1177.     //     return $this;
  1178.     // }
  1180.     /**
  1181.      * @return Collection<int, DemandePro>
  1182.      */
  1183.     public function getDemandePros(): Collection
  1184.     {
  1185.         return $this->demandePros;
  1186.     }
  1188.     public function addDemandePro(DemandePro $demandePro): self
  1189.     {
  1190.         if (!$this->demandePros->contains($demandePro)) {
  1191.             $this->demandePros[] = $demandePro;
  1192.             $demandePro->setFormation($this);
  1193.         }
  1195.         return $this;
  1196.     }
  1198.     public function removeDemandePro(DemandePro $demandePro): self
  1199.     {
  1200.         if ($this->demandePros->removeElement($demandePro)) {
  1201.             // set the owning side to null (unless already changed)
  1202.             if ($demandePro->getFormation() === $this) {
  1203.                 $demandePro->setFormation(null);
  1204.             }
  1205.         }
  1207.         return $this;
  1208.     }
  1210.    
  1211. }