src/Entity/User.php line 13

  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  12. #[ORM\Entity(repositoryClass: UserRepository::class)]
  13. class User implements UserInterface, PasswordAuthenticatedUserInterface
  14. {
  15.     #[ORM\Id]
  16.     #[ORM\GeneratedValue]
  17.     #[ORM\Column]
  18.     private ?int $id = null;
  20.     #[ORM\Column(length: 180, unique: true)]
  21.     private ?string $email = null;
  23.     
  24.     #[ORM\Column]
  25.     private array $roles = [];
  27.     /**
  28.      * @var string The hashed password
  29.      */
  30.     #[ORM\Column]
  31.     private ?string $password = null;
  33.     #[ORM\Column(length: 50)]
  34.     private ?string $prenom = null;
  36.     #[ORM\Column(length: 50)]
  37.     private ?string $nom = null;
  39.     #[ORM\ManyToOne]
  40.     private ?VilleFrance $ville = null;
  42.     #[ORM\Column(length: 50)]
  43.     private ?string $initiales = null;
  45.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Camion::class)]
  46.     private Collection $camions;
  48.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CamionUser::class)]
  49.     private Collection $camionUsers;
  51.     #[ORM\ManyToOne]
  52.     private ?VilleFrance $villeAttache = null;
  54.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Documentation::class)]
  55.     private Collection $documentations;
  57.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CartePaiement::class)]
  58.     private Collection $cartePaiements;
  60.     #[ORM\Column(length: 10, nullable: true)]
  61.     private ?string $matricule = null;
  63.     #[ORM\Column]
  64.     private ?int $actif = null;
  66.     #[ORM\ManyToOne(inversedBy: 'users')]
  67.     private ?SystemeClient $systemeClient = null;
  69.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Absence::class)]
  70.     private Collection $absences;
  72.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: PlanningReccurence::class)]
  73.     private Collection $planningReccurences;
  75.     #[ORM\Column]
  76.     private ?int $carteClefRendu = null;
  78.     #[ORM\Column]
  79.     private ?int $rappelSms = null;
  81.     #[ORM\Column(length: 255)]
  82.     private ?string $telephone = null;
  84.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InfoChauffeur::class)]
  85.     private Collection $infoChauffeurs;
  87.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InfoChauffeurDate::class)]
  88.     private Collection $infoChauffeurDates;
  90.     #[ORM\OneToMany(mappedBy: 'userUpdate', targetEntity: PlanningUpdateDateTime::class)]
  91.     private Collection $planningUpdateDateTimes;
  93.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: HoraireExploit::class)]
  94.     private Collection $no;
  96.     #[ORM\Column(length: 20)]
  97.     private ?string $telephonePro = null;
  99.     //const MDPINFO = "8RLHJCl32uDf";
  100.     const MDPINFO = "Cont@ctSolu555$";
  101.     const USERINFO = "contact@solubac.fr";
  102.     const HOSTINFO = "smtp.office365.com";
  103.     //const HOSTINFO = "mail.infomaniak.ch";
  104.     const PORTINFO = 587;
  105.     const APIKEYGOOGLE = 'AIzaSyCyY3op2G-PX5ZD-UDY58jPKTJic1_y-rI';
  106.     //const PORTINFO = 465;
  108.     /**
  109.      * User constructor.
  110.      */
  111.     public function __construct()
  112.     {
  113.         $this->camions = new ArrayCollection();
  114.         $this->camionUsers = new ArrayCollection();
  115.         $this->documentations = new ArrayCollection();
  116.         $this->cartePaiements = new ArrayCollection();
  117.         $this->absences = new ArrayCollection();
  118.         $this->planningReccurences = new ArrayCollection();
  119.         $this->infoChauffeurs = new ArrayCollection();
  120.         $this->infoChauffeurDates = new ArrayCollection();
  121.         $this->planningUpdateDateTimes = new ArrayCollection();
  122.         $this->no = new ArrayCollection();
  123.     }
  125.     public function getId(): ?int
  126.     {
  127.         return $this->id;
  128.     }
  130.     public function getEmail(): ?string
  131.     {
  132.         return $this->email;
  133.     }
  135.     public function setEmail(string $email): self
  136.     {
  137.         $this->email = $email;
  139.         return $this;
  140.     }
  142.     /**
  143.      * A visual identifier that represents this user.
  144.      *
  145.      * @see UserInterface
  146.      */
  147.     public function getUserIdentifier(): string
  148.     {
  149.         return (string) $this->email;
  150.     }
  152.     /**
  153.      * @see UserInterface
  154.      */
  155.     public function getRoles(): array
  156.     {
  157.         $roles = $this->roles;
  158.         // guarantee every user at least has ROLE_USER
  159.         $roles[] = 'ROLE_USER';
  161.         return array_unique($roles);
  162.     }
  164.     /**
  165.      * @see UserInterface
  166.      */
  167.     public function getRoleAdmin()
  168.     {
  169.         $admin = false;
  170.         foreach($this->roles as $role)
  171.         {
  172.             if($role=="ROLE_ADMIN")
  173.             {
  174.                 $admin = true;
  175.             }
  176.         }
  177.         return $admin;
  178.     }
  180.     /**
  181.      * @see UserInterface
  182.      */
  183.     public function getRoleNotif()
  184.     {
  185.         $admin = false;
  186.         foreach($this->roles as $role)
  187.         {
  188.             if($role=="ROLE_NOTIF")
  189.             {
  190.                 $admin = true;
  191.             }
  192.         }
  193.         return $admin;
  194.     }
  196.     /**
  197.      * @see UserInterface
  198.      */
  199.     public function getRoleChauffeur()
  200.     {
  201.         $admin = false;
  202.         foreach($this->roles as $role)
  203.         {
  204.             if($role=="ROLE_CHAUFFEUR")
  205.             {
  206.                 $admin = true;
  207.             }
  208.         }
  209.         return $admin;
  210.     }
  212.     /**
  213.      * @see UserInterface
  214.      */
  215.     public function getRoleAnal()
  216.     {
  217.         $admin = false;
  218.         foreach($this->roles as $role)
  219.         {
  220.             if($role=="ROLE_ANAL")
  221.             {
  222.                 $admin = true;
  223.             }
  224.         }
  225.         return $admin;
  226.     }
  228.     /**
  229.      * @see UserInterface
  230.      */
  231.     public function getRoleTech()
  232.     {
  233.         $admin = false;
  234.         foreach($this->roles as $role)
  235.         {
  236.             if($role=="ROLE_TECH")
  237.             {
  238.                 $admin = true;
  239.             }
  240.         }
  241.         return $admin;
  242.     }
  244.     /**
  245.      * @see UserInterface
  246.      */
  247.     public function getRoleExpl()
  248.     {
  249.         $admin = false;
  250.         foreach($this->roles as $role)
  251.         {
  252.             if($role=="ROLE_EXPL")
  253.             {
  254.                 $admin = true;
  255.             }
  256.         }
  257.         return $admin;
  258.     }
  260.     public function setRoles(array $roles): self
  261.     {
  262.         $this->roles = $roles;
  264.         return $this;
  265.     }
  267.     /**
  268.      * @see PasswordAuthenticatedUserInterface
  269.      */
  270.     public function getPassword(): string
  271.     {
  272.         return $this->password;
  273.     }
  275.     public function setPassword(string $password): self
  276.     {
  277.         $this->password = $password;
  279.         return $this;
  280.     }
  282.     /**
  283.      * @see UserInterface
  284.      */
  285.     public function eraseCredentials()
  286.     {
  287.         // If you store any temporary, sensitive data on the user, clear it here
  288.         // $this->plainPassword = null;
  289.     }
  291.     public function getPrenom(): ?string
  292.     {
  293.         return $this->prenom;
  294.     }
  296.     public function setPrenom(string $prenom): self
  297.     {
  298.         $this->prenom = $prenom;
  300.         return $this;
  301.     }
  303.     public function getNom(): ?string
  304.     {
  305.         return $this->nom;
  306.     }
  308.     public function setNom(string $nom): self
  309.     {
  310.         $this->nom = $nom;
  312.         return $this;
  313.     }
  315.     public function getVille(): ?VilleFrance
  316.     {
  317.         return $this->ville;
  318.     }
  320.     public function setVille(VilleFrance $ville): self
  321.     {
  322.         $this->ville = $ville;
  324.         return $this;
  325.     }
  327.     /**
  328.      * @return Collection<int, Camion>
  329.      */
  330.     public function getCamions(): Collection
  331.     {
  332.         return $this->camions;
  333.     }
  335.     public function addCamion(Camion $camion): self
  336.     {
  337.         if (!$this->camions->contains($camion)) {
  338.             $this->camions->add($camion);
  339.             $camion->setUser($this);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removeCamion(Camion $camion): self
  346.     {
  347.         if ($this->camions->removeElement($camion)) {
  348.             // set the owning side to null (unless already changed)
  349.             if ($camion->getUser() === $this) {
  350.                 $camion->setUser(null);
  351.             }
  352.         }
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, CamionUser>
  359.      */
  360.     public function getCamionUsers(): Collection
  361.     {
  362.         return $this->camionUsers;
  363.     }
  365.     public function addCamionUser(CamionUser $camionUser): self
  366.     {
  367.         if (!$this->camionUsers->contains($camionUser)) {
  368.             $this->camionUsers->add($camionUser);
  369.             $camionUser->setUser($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removeCamionUser(CamionUser $camionUser): self
  376.     {
  377.         if ($this->camionUsers->removeElement($camionUser)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($camionUser->getUser() === $this) {
  380.                 $camionUser->setUser(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     public function __toString()
  388.     {
  389.         return $this->getPrenom().' '.$this->getNom();
  390.     }
  392.     public function getInitiales(): ?string
  393.     {
  394.         return $this->initiales;
  395.     }
  397.     public function setInitiales(string $initiales): self
  398.     {
  399.         $this->initiales = $initiales;
  401.         return $this;
  402.     }
  404.     public function getVilleAttache(): ?VilleFrance
  405.     {
  406.         return $this->villeAttache;
  407.     }
  409.     public function setVilleAttache(VilleFrance $villeAttache): self
  410.     {
  411.         $this->villeAttache = $villeAttache;
  413.         return $this;
  414.     }
  416.     /**
  417.      * @return Collection<int, Documentation>
  418.      */
  419.     public function getDocumentations(): Collection
  420.     {
  421.         return $this->documentations;
  422.     }
  424.     public function addDocumentation(Documentation $documentation): self
  425.     {
  426.         if (!$this->documentations->contains($documentation)) {
  427.             $this->documentations->add($documentation);
  428.             $documentation->setUser($this);
  429.         }
  431.         return $this;
  432.     }
  434.     public function removeDocumentation(Documentation $documentation): self
  435.     {
  436.         if ($this->documentations->removeElement($documentation)) {
  437.             // set the owning side to null (unless already changed)
  438.             if ($documentation->getUser() === $this) {
  439.                 $documentation->setUser(null);
  440.             }
  441.         }
  443.         return $this;
  444.     }
  446.     public function getMatricule(): ?string
  447.     {
  448.         return $this->matricule;
  449.     }
  451.     public function setMatricule(?string $matricule): self
  452.     {
  453.         $this->matricule = $matricule;
  455.         return $this;
  456.     }
  458.     public function getActif(): ?int
  459.     {
  460.         return $this->actif;
  461.     }
  463.     public function setActif(int $actif): self
  464.     {
  465.         $this->actif = $actif;
  467.         return $this;
  468.     }
  470.     public function getSystemeClient(): ?SystemeClient
  471.     {
  472.         return $this->systemeClient;
  473.     }
  475.     public function setSystemeClient(?SystemeClient $systemeClient): self
  476.     {
  477.         $this->systemeClient = $systemeClient;
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, Absence>
  484.      */
  485.     public function getAbsences(): Collection
  486.     {
  487.         return $this->absences;
  488.     }
  490.     public function addAbsence(Absence $absence): self
  491.     {
  492.         if (!$this->absences->contains($absence)) {
  493.             $this->absences->add($absence);
  494.             $absence->setUser($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeAbsence(Absence $absence): self
  501.     {
  502.         if ($this->absences->removeElement($absence)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($absence->getUser() === $this) {
  505.                 $absence->setUser(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, PlanningReccurence>
  514.      */
  515.     public function getPlanningReccurences(): Collection
  516.     {
  517.         return $this->planningReccurences;
  518.     }
  520.     public function addPlanningReccurence(PlanningReccurence $planningReccurence): self
  521.     {
  522.         if (!$this->planningReccurences->contains($planningReccurence)) {
  523.             $this->planningReccurences->add($planningReccurence);
  524.             $planningReccurence->setUser($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removePlanningReccurence(PlanningReccurence $planningReccurence): self
  531.     {
  532.         if ($this->planningReccurences->removeElement($planningReccurence)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($planningReccurence->getUser() === $this) {
  535.                 $planningReccurence->setUser(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     public function getCarteClefRendu(): ?int
  543.     {
  544.         return $this->carteClefRendu;
  545.     }
  547.     public function setCarteClefRendu(int $carteClefRendu): self
  548.     {
  549.         $this->carteClefRendu = $carteClefRendu;
  551.         return $this;
  552.     }
  554.     public function getRappelSms(): ?int
  555.     {
  556.         return $this->rappelSms;
  557.     }
  559.     public function setRappelSms(int $rappelSms): self
  560.     {
  561.         $this->rappelSms = $rappelSms;
  563.         return $this;
  564.     }
  566.     public function getTelephone(): ?string
  567.     {
  568.         return $this->telephone;
  569.     }
  571.     public function setTelephone(string $telephone): self
  572.     {
  573.         $this->telephone = $telephone;
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection<int, InfoChauffeur>
  580.      */
  581.     public function getInfoChauffeurs(): Collection
  582.     {
  583.         return $this->infoChauffeurs;
  584.     }
  586.     public function addInfoChauffeur(InfoChauffeur $infoChauffeur): self
  587.     {
  588.         if (!$this->infoChauffeurs->contains($infoChauffeur)) {
  589.             $this->infoChauffeurs->add($infoChauffeur);
  590.             $infoChauffeur->setUser($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removeInfoChauffeur(InfoChauffeur $infoChauffeur): self
  597.     {
  598.         if ($this->infoChauffeurs->removeElement($infoChauffeur)) {
  599.             // set the owning side to null (unless already changed)
  600.             if ($infoChauffeur->getUser() === $this) {
  601.                 $infoChauffeur->setUser(null);
  602.             }
  603.         }
  605.         return $this;
  606.     }
  608.     public function getInfoChauffeur()
  609.     {
  610.         $return = null;
  611.         if(!empty($this->infoChauffeurs))
  612.         {
  613.             foreach($this->infoChauffeurs as $infoChauffeur)
  614.             {
  615.                 $return = $infoChauffeur;
  616.             }
  617.         }
  618.         return $return;
  619.     }
  621.     /**
  622.      * @return Collection<int, InfoChauffeurDate>
  623.      */
  624.     public function getInfoChauffeurDates(): Collection
  625.     {
  626.         return $this->infoChauffeurDates;
  627.     }
  629.     public function addInfoChauffeurDate(InfoChauffeurDate $infoChauffeurDate): self
  630.     {
  631.         if (!$this->infoChauffeurDates->contains($infoChauffeurDate)) {
  632.             $this->infoChauffeurDates->add($infoChauffeurDate);
  633.             $infoChauffeurDate->setUser($this);
  634.         }
  636.         return $this;
  637.     }
  639.     public function removeInfoChauffeurDate(InfoChauffeurDate $infoChauffeurDate): self
  640.     {
  641.         if ($this->infoChauffeurDates->removeElement($infoChauffeurDate)) {
  642.             // set the owning side to null (unless already changed)
  643.             if ($infoChauffeurDate->getUser() === $this) {
  644.                 $infoChauffeurDate->setUser(null);
  645.             }
  646.         }
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection<int, PlanningUpdateDateTime>
  653.      */
  654.     public function getPlanningUpdateDateTimes(): Collection
  655.     {
  656.         return $this->planningUpdateDateTimes;
  657.     }
  659.     public function addPlanningUpdateDateTime(PlanningUpdateDateTime $planningUpdateDateTime): static
  660.     {
  661.         if (!$this->planningUpdateDateTimes->contains($planningUpdateDateTime)) {
  662.             $this->planningUpdateDateTimes->add($planningUpdateDateTime);
  663.             $planningUpdateDateTime->setUserUpdate($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removePlanningUpdateDateTime(PlanningUpdateDateTime $planningUpdateDateTime): static
  670.     {
  671.         if ($this->planningUpdateDateTimes->removeElement($planningUpdateDateTime)) {
  672.             // set the owning side to null (unless already changed)
  673.             if ($planningUpdateDateTime->getUserUpdate() === $this) {
  674.                 $planningUpdateDateTime->setUserUpdate(null);
  675.             }
  676.         }
  678.         return $this;
  679.     }
  681.     /**
  682.      * @return Collection<int, HoraireExploit>
  683.      */
  684.     public function getNo(): Collection
  685.     {
  686.         return $this->no;
  687.     }
  689.     public function addNo(HoraireExploit $no): static
  690.     {
  691.         if (!$this->no->contains($no)) {
  692.             $this->no->add($no);
  693.             $no->setUser($this);
  694.         }
  696.         return $this;
  697.     }
  699.     public function removeNo(HoraireExploit $no): static
  700.     {
  701.         if ($this->no->removeElement($no)) {
  702.             // set the owning side to null (unless already changed)
  703.             if ($no->getUser() === $this) {
  704.                 $no->setUser(null);
  705.             }
  706.         }
  708.         return $this;
  709.     }
  711.     public function getTelephonePro(): ?string
  712.     {
  713.         return $this->telephonePro;
  714.     }
  716.     public function setTelephonePro(string $telephonePro): static
  717.     {
  718.         $this->telephonePro = $telephonePro;
  720.         return $this;
  721.     }
  722. }