src/Entity/Gestiform/Users/Formateur.php line 25

  1. <?php
  3. namespace App\Entity\Gestiform\Users;
  5. use App\Entity\Gestiform\Admin\Entretien\Entretien;
  6. use DateTime;
  7. use JsonException;
  8. use App\Entity\Common\Adresse;
  9. use App\Entity\Common\Upload;
  10. use App\Entity\Gestiform\Admin\MasterListe\Masterlistelg;
  11. use App\Entity\Gestiform\Formations\Catalogue\Parcours\Parcours;
  12. use App\Entity\Gestiform\Formations\Dossier\HistoriqueComment;
  13. use App\Entity\Gestiform\Formations\Entreprise\Contrat;
  14. use App\Entity\Gestiform\Formations\Entreprise\Entreprise;
  15. use App\Entity\Gestiform\Formations\Entreprise\FormateurEntreprise;
  16. use App\Entity\Gestiform\Formations\Formateur\FormateurModule;
  17. use App\Entity\Gestiform\Formations\Session\FormateurEvent;
  18. use App\Entity\Gestiform\Formations\Session\Planning\ApprenantLivrable;
  19. use App\Entity\Gestiform\Formations\Session\Planning\LignePrestation;
  20. use App\Repository\Gestiform\Users\FormateurRepository;
  21. use Doctrine\Common\Collections\ArrayCollection;
  22. use Doctrine\Common\Collections\Collection;
  23. use Doctrine\ORM\Mapping as ORM;
  25. #[ORM\Entity(repositoryClass: FormateurRepository::class)]
  26. class Formateur extends Personne
  27. {
  29.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  30.     private ?string $prefecture = null;
  32.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  33.     private ?string $numeroActivite = null;
  35.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  36.     private ?string $numeroActivite2 = null;
  38.     #[ORM\Column(type: 'string', nullable: true)]
  39.     private ?string $listeCompetences = null;
  41.     #[ORM\Column(type: 'datetime', nullable: true)]
  42.     private ?DateTime $debutHabilitation = null;
  44.     #[ORM\Column(type: 'datetime', nullable: true)]
  45.     private ?DateTime $finHabilitation = null;
  48.     #[ORM\Column(type: 'boolean', nullable: true)]
  49.     private ?bool $juryUniquement = null;
  51.     #[ORM\JoinColumn(nullable: true)]
  52.     #[ORM\ManyToOne(targetEntity: Masterlistelg::class)]
  53.     private ?Masterlistelg $statut = null;
  55.     #[ORM\OneToMany(targetEntity: FormateurModule::class, mappedBy: 'formateur', cascade: ['persist'])]
  56.     private Collection $formateurModules;
  59.     #[ORM\ManyToMany(targetEntity: Parcours::class, inversedBy: 'formateurs')]
  60.     #[ORM\JoinTable(name: 'formateur_parcours')]
  61.     private Collection $parcoursRNCP;
  64.     #[ORM\OneToMany(targetEntity: FormateurEntreprise::class, mappedBy: 'formateur', cascade: ['persist'])]
  65.     private Collection $formateurEntreprises;
  67.     #[ORM\ManyToMany(targetEntity: Contrat::class, mappedBy: 'formateurs', cascade: ['persist'])]
  68.     private Collection $contrats;
  70.     #[ORM\ManyToMany(targetEntity: LignePrestation::class, mappedBy: 'formateurs', cascade: ['all'])]
  71.     private Collection $lignePrestations;
  73.     #[ORM\OneToMany(targetEntity: FormateurEvent::class, mappedBy: 'formateur', cascade: ['all'])]
  74.     private Collection $formateurEvents;
  76.     #[ORM\Column(type: 'text', nullable: true)]
  77.     private ?string $missionProposee = null;
  79.     #[ORM\OneToMany(targetEntity: ApprenantLivrable::class, mappedBy: 'formateur', cascade: ['persist'])]
  80.     private Collection $apprenantLivrables;
  82.     #[ORM\OneToMany(targetEntity: HistoriqueComment::class, mappedBy: 'formateur', cascade: ['all'])]
  83.     private Collection $historiqueComments;
  87.     public function __construct()
  88.     {
  89.         parent::__construct();
  90.         $this->formateurModules = new ArrayCollection();
  91.         $this->formateurEntreprises = new ArrayCollection();
  92.         $this->formateurEvents = new ArrayCollection();
  93.         $this->contrats = new ArrayCollection();
  94.         $this->lignePrestations = new ArrayCollection();
  95.         $this->apprenantLivrables = new ArrayCollection();
  96.         $this->historiqueComments = new ArrayCollection();
  97.         $this->parcoursRNCP = new ArrayCollection();
  98.     }
  100.     public function getJuryUniquement(): ?bool
  101.     {
  102.         return $this->juryUniquement;
  103.     }
  105.     public function setJuryUniquement(?bool $juryUniquement): self
  106.     {
  107.         $this->juryUniquement = $juryUniquement;
  108.         return $this;
  109.     }
  111.     public function getListeCompetences(): ?string
  112.     {
  113.         return $this->listeCompetences;
  114.     }
  116.     public function setListeCompetences(?string $listeCompetences): self
  117.     {
  118.         $this->listeCompetences = $listeCompetences;
  119.         return $this;
  120.     }
  123.     public function getStatut(): ?Masterlistelg
  124.     {
  125.         return $this->statut;
  126.     }
  128.     public function setStatut(?Masterlistelg $statut): self
  129.     {
  130.         $this->statut = $statut;
  131.         return $this;
  132.     }
  134.     /**
  135.      * @return Collection<int, FormateurModule>
  136.      */
  137.     public function getFormateurModules(): Collection
  138.     {
  139.         return $this->formateurModules;
  140.     }
  142.     public function addFormateurModule(FormateurModule $formateurModule): self
  143.     {
  144.         if (!$this->formateurModules->contains($formateurModule)) {
  145.             $this->formateurModules->add($formateurModule);
  146.             $formateurModule->setFormateur($this);
  147.         }
  149.         return $this;
  150.     }
  152.     public function removeFormateurModule(FormateurModule $formateurModule): self
  153.     {
  154.         // set the owning side to null (unless already changed)
  155.         if ($this->formateurModules->removeElement($formateurModule) && $formateurModule->getFormateur() === $this) {
  156.             $formateurModule->setFormateur(null);
  157.         }
  159.         return $this;
  160.     }
  162.     /**
  163.      * @return Collection<int, FormateurEntreprise>
  164.      */
  165.     public function getFormateurEntreprises(): Collection
  166.     {
  167.         return $this->formateurEntreprises;
  168.     }
  170.     public function addFormateurEntreprise(FormateurEntreprise $formateurEntreprise): self
  171.     {
  172.         if (!$this->formateurEntreprises->contains($formateurEntreprise)) {
  173.             $this->formateurEntreprises->add($formateurEntreprise);
  174.             $formateurEntreprise->setFormateur($this);
  175.         }
  177.         return $this;
  178.     }
  180.     public function removeFormateurEntreprise(FormateurEntreprise $formateurEntreprise): self
  181.     {
  182.         // set the owning side to null (unless already changed)
  183.         if ($this->formateurEntreprises->removeElement($formateurEntreprise) && $formateurEntreprise->getFormateur() === $this) {
  184.             $formateurEntreprise->setFormateur(null);
  185.         }
  187.         return $this;
  188.     }
  191.     public function getEntreprise(): ?Entreprise
  192.     {
  193.         $formateurEntreprises = $this->getFormateurEntreprises();
  195.         if ($formateurEntreprises->isEmpty()) {
  196.             return null;
  197.         }
  199.         $firstRelation = $formateurEntreprises->first();
  201.         return $firstRelation ? $firstRelation->getEntreprise() : null;
  202.     }
  204.     public function getPrefecture(): ?string
  205.     {
  206.         return $this->prefecture;
  207.     }
  209.     public function setPrefecture(?string $prefecture): self
  210.     {
  211.         $this->prefecture = $prefecture;
  212.         return $this;
  213.     }
  215.     public function getNumeroActivite(): ?string
  216.     {
  217.         return $this->numeroActivite;
  218.     }
  220.     public function setNumeroActivite(?string $numeroActivite): self
  221.     {
  222.         $this->numeroActivite = $numeroActivite;
  223.         return $this;
  224.     }
  225.     public function getNumeroActivite2(): ?string
  226.     {
  227.         return $this->numeroActivite2;
  228.     }
  230.     public function setNumeroActivite2(?string $numeroActivite2): Formateur
  231.     {
  232.         $this->numeroActivite2 = $numeroActivite2;
  233.         return $this;
  234.     }
  235.     /**
  236.      * @return Collection<int, FormateurEvent>
  237.      */
  238.     public function getFormateurEvents(): Collection
  239.     {
  240.         return $this->formateurEvents;
  241.     }
  243.     public function addFormateurEvent(FormateurEvent $formateurEvent): self
  244.     {
  245.         if (!$this->formateurEvents->contains($formateurEvent)) {
  246.             $this->formateurEvents->add($formateurEvent);
  247.             $formateurEvent->setFormateur($this);
  248.         }
  250.         return $this;
  251.     }
  253.     public function removeFormateurEvent(FormateurEvent $formateurEvent): self
  254.     {
  255.         // set the owning side to null (unless already changed)
  256.         if ($this->formateurEvents->removeElement($formateurEvent) && $formateurEvent->getFormateur() === $this) {
  257.             $formateurEvent->setFormateur(null);
  258.         }
  260.         return $this;
  261.     }
  263.     public function getMissionProposee()
  264.     {
  265.         if ($this->missionProposee === null) {
  266.             return [];
  267.         }
  268.         return json_decode($this->missionProposee, true, 512, JSON_THROW_ON_ERROR);
  269.     }
  271.     /**
  272.      * @throws JsonException
  273.      */
  274.     public function addMissionProposee(string $id, string $title, $state = null, $sevent = []): self
  275.     {
  276.         $missionProposee = [];
  277.         if (!empty($this->missionProposee)) {
  278.             try {
  279.                 $missionProposee = json_decode($this->missionProposee, true, 512, JSON_THROW_ON_ERROR);
  280.             } catch (\JsonException $e) {
  281.                 dump($e->getMessage());
  282.                 $missionProposee = [];
  283.             }
  284.         }
  286.         $exist = false;
  287.         foreach ($missionProposee as &$item) {
  288.             if ($item['id'] === $id) {
  289.                 $item['title'] = $title;
  290.                 $item['state'] = $state;
  291.                 $exist = true;
  292.                 break;
  293.             }
  294.         }
  296.         if (!$exist) {
  297.             $missionProposee[] = [
  298.                 'id'    => $id,
  299.                 'title' => $title,
  300.                 'state' => $state,
  301.                 'week'  => $sevent['week'] ?? null,
  302.                 'start' => $sevent['start'] ?? null,
  303.                 'end'   => $sevent['end'] ?? null,
  304.             ];
  305.         }
  307.         $this->missionProposee = json_encode($missionProposee, JSON_THROW_ON_ERROR);
  309.         return $this;
  310.     }
  314.     /**
  315.      * @throws JsonException
  316.      */
  317.     public function removeMissionProposee(string $idEvent): self
  318.     {
  319.         $missionProposee = [];
  320.         if (!empty($this->missionProposee)) {
  321.             try {
  322.                 $missionProposee = json_decode($this->missionProposee, true, 512, JSON_THROW_ON_ERROR);
  323.             } catch (\JsonException $e) {
  324.                 dump($e->getMessage());
  325.                 $missionProposee = [];
  326.             }
  327.         }
  329.         foreach ($missionProposee as $key => $item) {
  330.             if (($item['id'] ?? null) === $idEvent) {
  331.                 unset($missionProposee[$key]);
  332.             }
  333.         }
  335.         // Réindexation du tableau
  336.         $this->missionProposee = json_encode(array_values($missionProposee), JSON_THROW_ON_ERROR);
  338.         return $this;
  339.     }
  342.     public function setMissionProposee(?string $missionProposee): self
  343.     {
  344.         $this->missionProposee = $missionProposee;
  346.         return $this;
  347.     }
  349.     /**
  350.      * @throws JsonException
  351.      */
  352.     public function getMissionProposeeById(string $id)
  353.     {
  354.         $missionProposee = json_decode((string) $this->missionProposee, true, 512, JSON_THROW_ON_ERROR) ?? [];
  356.         foreach ($missionProposee as $item) {
  357.             if ($item['id'] === $id) {
  358.                 return $item;
  359.             }
  360.         }
  362.         return null;
  363.     }
  365.     /**
  366.      * @return Collection<int, Contrat>
  367.      */
  368.     public function getContrats(): Collection
  369.     {
  370.         return $this->contrats;
  371.     }
  373.     public function addContrat(Contrat $contrat): self
  374.     {
  375.         if (!$this->contrats->contains($contrat)) {
  376.             $this->contrats->add($contrat);
  377.             $contrat->addFormateur($this);
  378.         }
  380.         return $this;
  381.     }
  383.     public function removeContrat(Contrat $contrat): self
  384.     {
  385.         if ($this->contrats->removeElement($contrat)) {
  386.             $contrat->removeFormateur($this);
  387.         }
  389.         return $this;
  390.     }
  393.     /**
  394.      * @return Collection<int, LignePrestation>
  395.      */
  396.     public function getLignePrestations(): Collection
  397.     {
  398.         return $this->lignePrestations;
  399.     }
  401.     public function addLignePrestation(LignePrestation $lignePrestation): self
  402.     {
  403.         if (!$this->lignePrestations->contains($lignePrestation)) {
  404.             $this->lignePrestations->add($lignePrestation);
  405.             $lignePrestation->addFormateur($this);
  406.         }
  408.         return $this;
  409.     }
  411.     public function removeLignePrestation(LignePrestation $lignePrestation): self
  412.     {
  413.         if ($this->lignePrestations->removeElement($lignePrestation)) {
  414.             $lignePrestation->removeFormateur($this);
  415.         }
  417.         return $this;
  418.     }
  421.     /**
  422.      * @throws JsonException
  423.      */
  424.     public function verifMissionProposee(string $id): bool
  425.     {
  426.         // Si aucun JSON stocké, aucune mission proposée
  427.         if (empty($this->missionProposee)) {
  428.             return false;
  429.         }
  431.         // Tolérer un JSON éventuellement corrompu
  432.         try {
  433.             $missionProposee = json_decode((string) $this->missionProposee, true, 512, JSON_THROW_ON_ERROR) ?? [];
  434.         } catch (JsonException $e) {
  435.             // En cas de JSON invalide, on considère qu'il n'y a pas de mission correspondante
  436.             return false;
  437.         }
  438.         $exist = false;
  439.         foreach ($missionProposee as &$item) {
  440.             if ($item['id'] === $id) {
  441.                 $exist = true;
  442.             }
  443.         }
  444.         return $exist;
  445.     }
  448.     /**
  449.      * @return Collection<int, ApprenantLivrable>
  450.      */
  451.     public function getApprenantLivrables(): Collection
  452.     {
  453.         return $this->apprenantLivrables;
  454.     }
  456.     public function addApprenantLivrable(ApprenantLivrable $apprenantLivrable): self
  457.     {
  458.         if (!$this->apprenantLivrables->contains($apprenantLivrable)) {
  459.             $this->apprenantLivrables->add($apprenantLivrable);
  460.             $apprenantLivrable->setFormateur($this);
  461.         }
  463.         return $this;
  464.     }
  466.     public function removeApprenantLivrable(ApprenantLivrable $apprenantLivrable): self
  467.     {
  468.         // set the owning side to null (unless already changed)
  469.         if ($this->apprenantLivrables->removeElement($apprenantLivrable) && $apprenantLivrable->getFormateur() === $this) {
  470.             $apprenantLivrable->setFormateur(null);
  471.         }
  473.         return $this;
  474.     }
  476.     /**
  477.      * @return Collection<int, HistoriqueComment>
  478.      */
  479.     public function getHistoriqueComments(): Collection
  480.     {
  481.         return $this->historiqueComments;
  482.     }
  484.     public function addHistoriqueComment(HistoriqueComment $historiqueComment): self
  485.     {
  486.         if (!$this->historiqueComments->contains($historiqueComment)) {
  487.             $this->historiqueComments->add($historiqueComment);
  488.             $historiqueComment->setFormateur($this);
  489.         }
  491.         return $this;
  492.     }
  494.     public function removeHistoriqueComment(HistoriqueComment $historiqueComment): self
  495.     {
  496.         // set the owning side to null (unless already changed)
  497.         if ($this->historiqueComments->removeElement($historiqueComment) && $historiqueComment->getFormateur() === $this) {
  498.             $historiqueComment->setFormateur($this);
  499.         }
  501.         return $this;
  502.     }
  504.     public function getDebutHabilitation(): ?DateTime
  505.     {
  506.         return $this->debutHabilitation;
  507.     }
  509.     public function setDebutHabilitation(?DateTime $debutHabilitation): self
  510.     {
  511.         $this->debutHabilitation = $debutHabilitation;
  513.         return $this;
  514.     }
  516.     public function getFinHabilitation(): ?DateTime
  517.     {
  518.         return $this->finHabilitation;
  519.     }
  521.     public function setFinHabilitation(?DateTime $finHabilitation): self
  522.     {
  523.         $this->finHabilitation = $finHabilitation;
  525.         return $this;
  526.     }
  528.     public function isJuryUniquement(): ?bool
  529.     {
  530.         return $this->juryUniquement;
  531.     }
  534.     /**
  535.      * @return Collection<int, Parcours>
  536.      */
  537.     public function getParcoursRNCP(): Collection
  538.     {
  539.         return $this->parcoursRNCP;
  540.     }
  542.     public function addParcoursRNCP(Parcours $parcoursRNCP): self
  543.     {
  544.         if (!$this->parcoursRNCP->contains($parcoursRNCP)) {
  545.             $this->parcoursRNCP->add($parcoursRNCP);
  546.             $parcoursRNCP->setFormateur($this);
  547.         }
  549.         return $this;
  550.     }
  552.     public function removeParcoursRNCP(Parcours $parcoursRNCP): self
  553.     {
  554.         // set the owning side to null (unless already changed)
  555.         if ($this->parcoursRNCP->removeElement($parcoursRNCP) && $parcoursRNCP->getFormateur() === $this) {
  556.             $parcoursRNCP->setFormateur(null);
  557.         }
  559.         return $this;
  560.     }
  562.     public function getEntretienValider(): ?Entretien
  563.     {
  564.         $entretiens = $this->getEntretiens()->toArray();
  565.         return array_reduce($entretiens,
  566.             static fn(?Entretien $carry, Entretien $e) =>
  567.             $e->isStatut() && (!$carry || $e->getId() > $carry->getId()) ? $e : $carry,
  568.             null
  569.         );
  570.     }
  571. }