src/Entity/Examens.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 Examens
  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"})
  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")
  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;
  218.     public function __construct()
  219.     {
  220.         $this->sessions = new ArrayCollection();
  221.         $this->justifForms = new ArrayCollection();
  222.         $this->positionnement = new ArrayCollection();
  223.         $this->optionCategorieInscrits = new ArrayCollection();
  224.         $this->demandeDevisSites = new ArrayCollection();
  225.         $this->stagaireDemandeDevis = new ArrayCollection();
  226.         $this->modules = new ArrayCollection();
  227.         $this->demandeDevisLignes = new ArrayCollection();
  228.     }
  230.     public function __toString()
  231.     {
  232.         return $this->getWording(); 
  233.     }
  235.     public function getId(): ?int
  236.     {
  237.         return $this->id;
  238.     }
  240.     public function getWording(): ?string
  241.     {
  242.         return $this->wording;
  243.     }
  245.     public function setWording(string $wording): self
  246.     {
  247.         $this->wording = $wording;
  249.         return $this;
  250.     }
  252.     public function isOnline(): ?bool
  253.     {
  254.         return $this->online;
  255.     }
  256.     public function setOnline(?bool $online): self
  257.     {
  258.         $this->online = $online;
  259.         return $this;
  260.     }
  261.     public function getPublicVise(): ?string
  262.     {
  263.         return $this->publicVise;
  264.     }
  265.     public function setPublicVise(?string $publicVise): self
  266.     {
  267.         $this->publicVise = $publicVise;
  268.         return $this;
  269.     }
  270.     public function getCompetenceVise(): ?string
  271.     {
  272.         return $this->competenceVise;
  273.     }
  274.     public function setCompetenceVise(?string $competenceVise): self
  275.     {
  276.         $this->competenceVise = $competenceVise;
  277.         return $this;
  278.     }
  279.     public function getModaliteEvaluation(): ?string
  280.     {
  281.         return $this->modaliteEvaluation;
  282.     }
  283.     public function setModaliteEvaluation(?string $modaliteEvaluation): self
  284.     {
  285.         $this->modaliteEvaluation = $modaliteEvaluation;
  286.         return $this;
  287.     }
  288.     public function getLieu(): ?string
  289.     {
  290.         return $this->lieu;
  291.     }
  292.     public function setLieu(?string $lieu): self
  293.     {
  294.         $this->lieu = $lieu;
  295.         return $this;
  296.     }
  297.     public function getDelaiAcces(): ?string
  298.     {
  299.         return $this->DelaiAcces;
  300.     }
  301.     public function setDelaiAcces(?string $DelaiAcces): self
  302.     {
  303.         $this->DelaiAcces = $DelaiAcces;
  304.         return $this;
  305.     }
  306.     public function getTauxReussite(): ?string
  307.     {
  308.         return $this->TauxReussite;
  309.     }
  310.     public function setTauxReussite(?string $TauxReussite): self
  311.     {
  312.         $this->TauxReussite = $TauxReussite;
  313.         return $this;
  314.     }
  315.     public function getPrerequis(): ?string
  316.     {
  317.         return $this->Prerequis;
  318.     }
  319.     public function setPrerequis(?string $Prerequis): self
  320.     {
  321.         $this->Prerequis = $Prerequis;
  322.         return $this;
  323.     }
  324.     public function getNiveauSortie(): ?string
  325.     {
  326.         return $this->NiveauSortie;
  327.     }
  328.     public function setNiveauSortie(?string $NiveauSortie): self
  329.     {
  330.         $this->NiveauSortie = $NiveauSortie;
  331.         return $this;
  332.     }
  333.     public function getContenu(): ?string
  334.     {
  335.         return $this->contenu;
  336.     }
  337.     public function setContenu(?string $contenu): self
  338.     {
  339.         $this->contenu = $contenu;
  340.         return $this;
  341.     }
  342.     public function getDebouche(): ?string
  343.     {
  344.         return $this->Debouche;
  345.     }
  346.     public function setDebouche(?string $Debouche): self
  347.     {
  348.         $this->Debouche = $Debouche;
  349.         return $this;
  350.     }
  351.     public function getMethodeApprentissage(): ?string
  352.     {
  353.         return $this->methodeApprentissage;
  354.     }
  355.     public function setMethodeApprentissage(?string $methodeApprentissage): self
  356.     {
  357.         $this->methodeApprentissage = $methodeApprentissage;
  358.         return $this;
  359.     }
  360.     /**
  361.      * @return Collection<int, DemandeDevisSite>
  362.      */
  363.     public function getDemandeDevisSites(): Collection
  364.     {
  365.         return $this->demandeDevisSites;
  366.     }
  367.     public function addDemandeDevisSite(DemandeDevisSite $demandeDevisSite): self
  368.     {
  369.         if (!$this->demandeDevisSites->contains($demandeDevisSite)) {
  370.             $this->demandeDevisSites[] = $demandeDevisSite;
  371.             $demandeDevisSite->addFormation($this);
  372.         }
  373.         return $this;
  374.     }
  375.     public function removeDemandeDevisSite(DemandeDevisSite $demandeDevisSite): self
  376.     {
  377.         if ($this->demandeDevisSites->removeElement($demandeDevisSite)) {
  378.             $demandeDevisSite->removeFormation($this);
  379.         }
  380.         return $this;
  381.     }
  382.     /**
  383.      * @return Collection<int, StagaireDemandeDevis>
  384.      */
  385.     public function getStagaireDemandeDevis(): Collection
  386.     {
  387.         return $this->stagaireDemandeDevis;
  388.     }
  389.     public function addStagaireDemandeDevi(StagaireDemandeDevis $stagaireDemandeDevi): self
  390.     {
  391.         if (!$this->stagaireDemandeDevis->contains($stagaireDemandeDevi)) {
  392.             $this->stagaireDemandeDevis[] = $stagaireDemandeDevi;
  393.             $stagaireDemandeDevi->setFormation($this);
  394.         }
  395.         return $this;
  396.     }
  397.     public function removeStagaireDemandeDevi(StagaireDemandeDevis $stagaireDemandeDevi): self
  398.     {
  399.         if ($this->stagaireDemandeDevis->removeElement($stagaireDemandeDevi)) {
  400.             // set the owning side to null (unless already changed)
  401.             if ($stagaireDemandeDevi->getFormation() === $this) {
  402.                 $stagaireDemandeDevi->setFormation(null);
  403.             }
  404.         }
  405.         return $this;
  406.     }
  408.     public function getLongWording(): ?string
  409.     {
  410.         return $this->long_wording;
  411.     }
  413.     public function setLongWording(?string $long_wording): self
  414.     {
  415.         $this->long_wording = $long_wording;
  417.         return $this;
  418.     }
  420.     public function getDescription(): ?string
  421.     {
  422.         return $this->description;
  423.     }
  425.     public function setDescription(?string $description): self
  426.     {
  427.         $this->description = $description;
  429.         return $this;
  430.     }
  432.     public function getDuration(): ?float
  433.     {
  434.         return $this->duration;
  435.     }
  437.     public function setDuration(?float $duration): self
  438.     {
  439.         $this->duration = $duration;
  441.         return $this;
  442.     }
  444.     public function getColor(): ?string
  445.     {
  446.         return $this->color;
  447.     }
  449.     public function setColor(?string $color): self
  450.     {
  451.         $this->color = $color;
  453.         return $this;
  454.     }
  456.     public function getMaxStudent(): ?int
  457.     {
  458.         return $this->max_student;
  459.     }
  461.     public function setMaxStudent(int $max_student): self
  462.     {
  463.         $this->max_student = $max_student;
  465.         return $this;
  466.     }
  468.     public function getPrice(): ?float
  469.     {
  470.         return $this->price;
  471.     }
  473.     public function setPrice(float $price): self
  474.     {
  475.         $this->price = $price;
  477.         return $this;
  478.     }
  480.     /**
  481.      * @return Collection<int, Session>
  482.      */
  483.     public function getSessions(): Collection
  484.     {
  485.         return $this->sessions;
  486.     }
  488.     public function addSession(Session $session): self
  489.     {
  490.         if (!$this->sessions->contains($session)) {
  491.             $this->sessions[] = $session;
  492.             $session->setFormation($this);
  493.         }
  495.         return $this;
  496.     }
  498.     public function removeSession(Session $session): self
  499.     {
  500.         if ($this->sessions->removeElement($session)) {
  501.             // set the owning side to null (unless already changed)
  502.             if ($session->getFormation() === $this) {
  503.                 $session->setFormation(null);
  504.             }
  505.         }
  507.         return $this;
  508.     }
  510.     /**
  511.      * @return Collection<int, JustifForm>
  512.      */
  513.     public function getJustifForms(): Collection
  514.     {
  515.         return $this->justifForms;
  516.     }
  518.     public function addJustifForm(JustifForm $justifForm): self
  519.     {
  520.         if (!$this->justifForms->contains($justifForm)) {
  521.             $this->justifForms[] = $justifForm;
  522.             $justifForm->setFormation($this);
  523.         }
  525.         return $this;
  526.     }
  528.     public function removeJustifForm(JustifForm $justifForm): self
  529.     {
  530.         if ($this->justifForms->removeElement($justifForm)) {
  531.             // set the owning side to null (unless already changed)
  532.             if ($justifForm->getFormation() === $this) {
  533.                 $justifForm->setFormation(null);
  534.             }
  535.         }
  537.         return $this;
  538.     }
  540.     public function getDemande(): ?Demande
  541.     {
  542.         return $this->demande;
  543.     }
  545.     public function setDemande(?Demande $demande): self
  546.     {
  547.         $this->demande = $demande;
  549.         return $this;
  550.     }
  552.     /**
  553.      * @return Collection<int, Demande>
  554.      */
  555.     public function getPositionnement(): Collection
  556.     {
  557.         return $this->positionnement;
  558.     }
  560.     public function addPositionnement(Demande $positionnement): self
  561.     {
  562.         if (!$this->positionnement->contains($positionnement)) {
  563.             $this->positionnement[] = $positionnement;
  564.             $positionnement->setPositionnement($this);
  565.         }
  567.         return $this;
  568.     }
  570.     public function removePositionnement(Demande $positionnement): self
  571.     {
  572.         if ($this->positionnement->removeElement($positionnement)) {
  573.             // set the owning side to null (unless already changed)
  574.             if ($positionnement->getPositionnement() === $this) {
  575.                 $positionnement->setPositionnement(null);
  576.             }
  577.         }
  579.         return $this;
  580.     }
  582.     public function setFichier(?File $image = null)
  583.     {
  584.         $this->fichier = $image;
  586.         if ($image) {
  587.             $this->updateAt = new \DateTimeImmutable();
  588.         }
  590.     }
  592.     public function getFichier()
  593.     {
  594.         return $this->fichier;
  595.     }
  596.     public function setImage($image)
  597.     {
  598.         $this->image = $image;
  599.     }
  601.     public function getImage()
  602.     {
  603.         return $this->image;
  604.     }
  606.     public function getUpdateAt(): ?\DateTimeImmutable
  607.     {
  608.         return $this->updateAt;
  609.     }
  611.     public function setUpdateAt(?\DateTimeImmutable $updateAt): self
  612.     {
  613.         $this->updateAt = $updateAt;
  615.         return $this;
  616.     }
  618.     public function getCategorieformation(): ?CategorieFormation
  619.     {
  620.         return $this->categorieformation;
  621.     }
  623.     public function setCategorieformation(?CategorieFormation $categorieformation): self
  624.     {
  625.         $this->categorieformation = $categorieformation;
  627.         return $this;
  628.     }
  630.     public function isCertificat(): ?bool
  631.     {
  632.         return $this->certificat;
  633.     }
  635.     public function setCertificat(?bool $certificat): self
  636.     {
  637.         $this->certificat = $certificat;
  639.         return $this;
  640.     }
  642.     public function isAttestation(): ?bool
  643.     {
  644.         return $this->attestation;
  645.     }
  647.     public function setAttestation(?bool $attestation): self
  648.     {
  649.         $this->attestation = $attestation;
  651.         return $this;
  652.     }
  654.     public function isDiplome(): ?bool
  655.     {
  656.         return $this->diplome;
  657.     }
  659.     public function setDiplome(?bool $diplome): self
  660.     {
  661.         $this->diplome = $diplome;
  663.         return $this;
  664.     }
  666.     public function isCarte(): ?bool
  667.     {
  668.         return $this->carte;
  669.     }
  671.     public function setCarte(?bool $carte): self
  672.     {
  673.         $this->carte = $carte;
  675.         return $this;
  676.     }
  678.     public function getObjectif(): ?string
  679.     {
  680.         return $this->objectif;
  681.     }
  683.     public function setObjectif(?string $objectif): self
  684.     {
  685.         $this->objectif = $objectif;
  687.         return $this;
  688.     }
  690.     public function getWordingdiplome(): ?string
  691.     {
  692.         return $this->wordingdiplome;
  693.     }
  695.     public function setWordingdiplome(?string $wordingdiplome): self
  696.     {
  697.         $this->wordingdiplome = $wordingdiplome;
  699.         return $this;
  700.     }
  702.     public function isFormateur(): ?bool
  703.     {
  704.         return $this->formateur;
  705.     }
  707.     public function setFormateur(?bool $formateur): self
  708.     {
  709.         $this->formateur = $formateur;
  711.         return $this;
  712.     }
  714.     public function isLongformation(): ?bool
  715.     {
  716.         return $this->longformation;
  717.     }
  719.     public function setLongformation(?bool $longformation): self
  720.     {
  721.         $this->longformation = $longformation;
  723.         return $this;
  724.     }
  726.     /**
  727.      * @return Collection<int, OptionCategorieInscrit>
  728.      */
  729.     public function getOptionCategorieInscrits(): Collection
  730.     {
  731.         return $this->optionCategorieInscrits;
  732.     }
  734.     public function addOptionCategorieInscrit(OptionCategorieInscrit $optionCategorieInscrit): self
  735.     {
  736.         if (!$this->optionCategorieInscrits->contains($optionCategorieInscrit)) {
  737.             $this->optionCategorieInscrits[] = $optionCategorieInscrit;
  738.             $optionCategorieInscrit->setFormation($this);
  739.         }
  741.         return $this;
  742.     }
  744.     public function removeOptionCategorieInscrit(OptionCategorieInscrit $optionCategorieInscrit): self
  745.     {
  746.         if ($this->optionCategorieInscrits->removeElement($optionCategorieInscrit)) {
  747.             // set the owning side to null (unless already changed)
  748.             if ($optionCategorieInscrit->getFormation() === $this) {
  749.                 $optionCategorieInscrit->setFormation(null);
  750.             }
  751.         }
  753.         return $this;
  754.     }
  755.     public function isEvaluation(): ?bool
  756.     {
  757.         return $this->evaluation;
  758.     }
  760.     public function setEvaluation(?bool $online): self
  761.     {
  762.         $this->evaluation = $online;
  764.         return $this;
  765.     }
  766.      /**
  767.      * @return Collection<int, ModuleSession>
  768.      */
  769.     public function getModules(): Collection
  770.     {
  771.         return $this->modules;
  772.     }
  774.     public function addModule(ModuleSession $module): self
  775.     {
  776.         if (!$this->modules->contains($module)) {
  777.             $this->modules[] = $module;
  778.         }
  780.         return $this;
  781.     }
  783.     public function removeModule(ModuleSession $module): self
  784.     {
  785.         $this->modules->removeElement($module);
  787.         return $this;
  788.     }
  790.     /**
  791.      * @return Collection<int, DemandeDevisLigne>
  792.      */
  793.     public function getDemandeDevisLignes(): Collection
  794.     {
  795.         return $this->demandeDevisLignes;
  796.     }
  798.     public function addDemandeDevisLigne(DemandeDevisLigne $demandeDevisLigne): self
  799.     {
  800.         if (!$this->demandeDevisLignes->contains($demandeDevisLigne)) {
  801.             $this->demandeDevisLignes[] = $demandeDevisLigne;
  802.             $demandeDevisLigne->setFormation($this);
  803.         }
  805.         return $this;
  806.     }
  808.     public function removeDemandeDevisLigne(DemandeDevisLigne $demandeDevisLigne): self
  809.     {
  810.         if ($this->demandeDevisLignes->removeElement($demandeDevisLigne)) {
  811.             // set the owning side to null (unless already changed)
  812.             if ($demandeDevisLigne->getFormation() === $this) {
  813.                 $demandeDevisLigne->setFormation(null);
  814.             }
  815.         }
  817.         return $this;
  818.     }
  819. }