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.     #[ORM\Column(length: 6)]
  100.     private ?string $codePin = null;
  102.     #[ORM\Column]
  103.     private ?int $idAddSecure = null;
  107.     //const MDPINFO = "8RLHJCl32uDf";
  108.     const MDPINFO = "Cont@ctSolu555$";
  109.     const USERINFO = "contact@solubac.fr";
  110.     const HOSTINFO = "smtp.office365.com";
  111.     //const HOSTINFO = "mail.infomaniak.ch";
  112.     const PORTINFO = 587;
  113.     const APIKEYGOOGLE = 'AIzaSyCyY3op2G-PX5ZD-UDY58jPKTJic1_y-rI';
  114.     //const PORTINFO = 465;
  116.     /**
  117.      * User constructor.
  118.      */
  119.     public function __construct()
  120.     {
  121.         $this->camions = new ArrayCollection();
  122.         $this->camionUsers = new ArrayCollection();
  123.         $this->documentations = new ArrayCollection();
  124.         $this->cartePaiements = new ArrayCollection();
  125.         $this->absences = new ArrayCollection();
  126.         $this->planningReccurences = new ArrayCollection();
  127.         $this->infoChauffeurs = new ArrayCollection();
  128.         $this->infoChauffeurDates = new ArrayCollection();
  129.         $this->planningUpdateDateTimes = new ArrayCollection();
  130.         $this->no = new ArrayCollection();
  131.         $this->documentChauffeurHistos = new ArrayCollection();
  132.         $this->date = new ArrayCollection();
  133.     }
  135.     public function getId(): ?int
  136.     {
  137.         return $this->id;
  138.     }
  140.     public function getEmail(): ?string
  141.     {
  142.         return $this->email;
  143.     }
  145.     public function setEmail(string $email): self
  146.     {
  147.         $this->email = $email;
  149.         return $this;
  150.     }
  152.     /**
  153.      * A visual identifier that represents this user.
  154.      *
  155.      * @see UserInterface
  156.      */
  157.     public function getUserIdentifier(): string
  158.     {
  159.         return (string) $this->email;
  160.     }
  162.     /**
  163.      * @see UserInterface
  164.      */
  165.     public function getRoles(): array
  166.     {
  167.         $roles = $this->roles;
  168.         // guarantee every user at least has ROLE_USER
  169.         $roles[] = 'ROLE_USER';
  171.         return array_unique($roles);
  172.     }
  174.     /**
  175.      * @see UserInterface
  176.      */
  177.     public function getRoleAdmin()
  178.     {
  179.         $admin = false;
  180.         foreach($this->roles as $role)
  181.         {
  182.             if($role=="ROLE_ADMIN")
  183.             {
  184.                 $admin = true;
  185.             }
  186.         }
  187.         return $admin;
  188.     }
  190.     /**
  191.      * @see UserInterface
  192.      */
  193.     public function getRoleNotif()
  194.     {
  195.         $admin = false;
  196.         foreach($this->roles as $role)
  197.         {
  198.             if($role=="ROLE_NOTIF")
  199.             {
  200.                 $admin = true;
  201.             }
  202.         }
  203.         return $admin;
  204.     }
  206.     /**
  207.      * @see UserInterface
  208.      */
  209.     public function getRoleChauffeur()
  210.     {
  211.         $admin = false;
  212.         foreach($this->roles as $role)
  213.         {
  214.             if($role=="ROLE_CHAUFFEUR")
  215.             {
  216.                 $admin = true;
  217.             }
  218.         }
  219.         return $admin;
  220.     }
  222.     /**
  223.      * @see UserInterface
  224.      */
  225.     public function getRoleAnal()
  226.     {
  227.         $admin = false;
  228.         foreach($this->roles as $role)
  229.         {
  230.             if($role=="ROLE_ANAL")
  231.             {
  232.                 $admin = true;
  233.             }
  234.         }
  235.         return $admin;
  236.     }
  238.     /**
  239.      * @see UserInterface
  240.      */
  241.     public function getRoleTech()
  242.     {
  243.         $admin = false;
  244.         foreach($this->roles as $role)
  245.         {
  246.             if($role=="ROLE_TECH")
  247.             {
  248.                 $admin = true;
  249.             }
  250.         }
  251.         return $admin;
  252.     }
  254.     /**
  255.      * @see UserInterface
  256.      */
  257.     public function getRoleExpl()
  258.     {
  259.         $admin = false;
  260.         foreach($this->roles as $role)
  261.         {
  262.             if($role=="ROLE_EXPL")
  263.             {
  264.                 $admin = true;
  265.             }
  266.         }
  267.         return $admin;
  268.     }
  270.     public function setRoles(array $roles): self
  271.     {
  272.         $this->roles = $roles;
  274.         return $this;
  275.     }
  277.     /**
  278.      * @see PasswordAuthenticatedUserInterface
  279.      */
  280.     public function getPassword(): string
  281.     {
  282.         return $this->password;
  283.     }
  285.     public function setPassword(string $password): self
  286.     {
  287.         $this->password = $password;
  289.         return $this;
  290.     }
  292.     /**
  293.      * @see UserInterface
  294.      */
  295.     public function eraseCredentials()
  296.     {
  297.         // If you store any temporary, sensitive data on the user, clear it here
  298.         // $this->plainPassword = null;
  299.     }
  301.     public function getPrenom(): ?string
  302.     {
  303.         return $this->prenom;
  304.     }
  306.     public function setPrenom(string $prenom): self
  307.     {
  308.         $this->prenom = $prenom;
  310.         return $this;
  311.     }
  313.     public function getNom(): ?string
  314.     {
  315.         return $this->nom;
  316.     }
  318.     public function setNom(string $nom): self
  319.     {
  320.         $this->nom = $nom;
  322.         return $this;
  323.     }
  325.     public function getVille(): ?VilleFrance
  326.     {
  327.         return $this->ville;
  328.     }
  330.     public function setVille(VilleFrance $ville): self
  331.     {
  332.         $this->ville = $ville;
  334.         return $this;
  335.     }
  337.     /**
  338.      * @return Collection<int, Camion>
  339.      */
  340.     public function getCamions(): Collection
  341.     {
  342.         return $this->camions;
  343.     }
  345.     public function addCamion(Camion $camion): self
  346.     {
  347.         if (!$this->camions->contains($camion)) {
  348.             $this->camions->add($camion);
  349.             $camion->setUser($this);
  350.         }
  352.         return $this;
  353.     }
  355.     public function removeCamion(Camion $camion): self
  356.     {
  357.         if ($this->camions->removeElement($camion)) {
  358.             // set the owning side to null (unless already changed)
  359.             if ($camion->getUser() === $this) {
  360.                 $camion->setUser(null);
  361.             }
  362.         }
  364.         return $this;
  365.     }
  367.     /**
  368.      * @return Collection<int, CamionUser>
  369.      */
  370.     public function getCamionUsers(): Collection
  371.     {
  372.         return $this->camionUsers;
  373.     }
  375.     public function addCamionUser(CamionUser $camionUser): self
  376.     {
  377.         if (!$this->camionUsers->contains($camionUser)) {
  378.             $this->camionUsers->add($camionUser);
  379.             $camionUser->setUser($this);
  380.         }
  382.         return $this;
  383.     }
  385.     public function removeCamionUser(CamionUser $camionUser): self
  386.     {
  387.         if ($this->camionUsers->removeElement($camionUser)) {
  388.             // set the owning side to null (unless already changed)
  389.             if ($camionUser->getUser() === $this) {
  390.                 $camionUser->setUser(null);
  391.             }
  392.         }
  394.         return $this;
  395.     }
  397.     public function __toString()
  398.     {
  399.         return $this->getPrenom().' '.$this->getNom();
  400.     }
  402.     public function getInitiales(): ?string
  403.     {
  404.         return $this->initiales;
  405.     }
  407.     public function setInitiales(string $initiales): self
  408.     {
  409.         $this->initiales = $initiales;
  411.         return $this;
  412.     }
  414.     public function getVilleAttache(): ?VilleFrance
  415.     {
  416.         return $this->villeAttache;
  417.     }
  419.     public function setVilleAttache(VilleFrance $villeAttache): self
  420.     {
  421.         $this->villeAttache = $villeAttache;
  423.         return $this;
  424.     }
  426.     /**
  427.      * @return Collection<int, Documentation>
  428.      */
  429.     public function getDocumentations(): Collection
  430.     {
  431.         return $this->documentations;
  432.     }
  434.     public function addDocumentation(Documentation $documentation): self
  435.     {
  436.         if (!$this->documentations->contains($documentation)) {
  437.             $this->documentations->add($documentation);
  438.             $documentation->setUser($this);
  439.         }
  441.         return $this;
  442.     }
  444.     public function removeDocumentation(Documentation $documentation): self
  445.     {
  446.         if ($this->documentations->removeElement($documentation)) {
  447.             // set the owning side to null (unless already changed)
  448.             if ($documentation->getUser() === $this) {
  449.                 $documentation->setUser(null);
  450.             }
  451.         }
  453.         return $this;
  454.     }
  456.     public function getMatricule(): ?string
  457.     {
  458.         return $this->matricule;
  459.     }
  461.     public function setMatricule(?string $matricule): self
  462.     {
  463.         $this->matricule = $matricule;
  465.         return $this;
  466.     }
  468.     public function getActif(): ?int
  469.     {
  470.         return $this->actif;
  471.     }
  473.     public function setActif(int $actif): self
  474.     {
  475.         $this->actif = $actif;
  477.         return $this;
  478.     }
  480.     public function getSystemeClient(): ?SystemeClient
  481.     {
  482.         return $this->systemeClient;
  483.     }
  485.     public function setSystemeClient(?SystemeClient $systemeClient): self
  486.     {
  487.         $this->systemeClient = $systemeClient;
  489.         return $this;
  490.     }
  492.     /**
  493.      * @return Collection<int, Absence>
  494.      */
  495.     public function getAbsences(): Collection
  496.     {
  497.         return $this->absences;
  498.     }
  500.     public function addAbsence(Absence $absence): self
  501.     {
  502.         if (!$this->absences->contains($absence)) {
  503.             $this->absences->add($absence);
  504.             $absence->setUser($this);
  505.         }
  507.         return $this;
  508.     }
  510.     public function removeAbsence(Absence $absence): self
  511.     {
  512.         if ($this->absences->removeElement($absence)) {
  513.             // set the owning side to null (unless already changed)
  514.             if ($absence->getUser() === $this) {
  515.                 $absence->setUser(null);
  516.             }
  517.         }
  519.         return $this;
  520.     }
  522.     /**
  523.      * @return Collection<int, PlanningReccurence>
  524.      */
  525.     public function getPlanningReccurences(): Collection
  526.     {
  527.         return $this->planningReccurences;
  528.     }
  530.     public function addPlanningReccurence(PlanningReccurence $planningReccurence): self
  531.     {
  532.         if (!$this->planningReccurences->contains($planningReccurence)) {
  533.             $this->planningReccurences->add($planningReccurence);
  534.             $planningReccurence->setUser($this);
  535.         }
  537.         return $this;
  538.     }
  540.     public function removePlanningReccurence(PlanningReccurence $planningReccurence): self
  541.     {
  542.         if ($this->planningReccurences->removeElement($planningReccurence)) {
  543.             // set the owning side to null (unless already changed)
  544.             if ($planningReccurence->getUser() === $this) {
  545.                 $planningReccurence->setUser(null);
  546.             }
  547.         }
  549.         return $this;
  550.     }
  552.     public function getCarteClefRendu(): ?int
  553.     {
  554.         return $this->carteClefRendu;
  555.     }
  557.     public function setCarteClefRendu(int $carteClefRendu): self
  558.     {
  559.         $this->carteClefRendu = $carteClefRendu;
  561.         return $this;
  562.     }
  564.     public function getRappelSms(): ?int
  565.     {
  566.         return $this->rappelSms;
  567.     }
  569.     public function setRappelSms(int $rappelSms): self
  570.     {
  571.         $this->rappelSms = $rappelSms;
  573.         return $this;
  574.     }
  576.     public function getTelephone(): ?string
  577.     {
  578.         return $this->telephone;
  579.     }
  581.     public function setTelephone(string $telephone): self
  582.     {
  583.         $this->telephone = $telephone;
  585.         return $this;
  586.     }
  588.     /**
  589.      * @return Collection<int, InfoChauffeur>
  590.      */
  591.     public function getInfoChauffeurs(): Collection
  592.     {
  593.         return $this->infoChauffeurs;
  594.     }
  596.     public function addInfoChauffeur(InfoChauffeur $infoChauffeur): self
  597.     {
  598.         if (!$this->infoChauffeurs->contains($infoChauffeur)) {
  599.             $this->infoChauffeurs->add($infoChauffeur);
  600.             $infoChauffeur->setUser($this);
  601.         }
  603.         return $this;
  604.     }
  606.     public function removeInfoChauffeur(InfoChauffeur $infoChauffeur): self
  607.     {
  608.         if ($this->infoChauffeurs->removeElement($infoChauffeur)) {
  609.             // set the owning side to null (unless already changed)
  610.             if ($infoChauffeur->getUser() === $this) {
  611.                 $infoChauffeur->setUser(null);
  612.             }
  613.         }
  615.         return $this;
  616.     }
  618.     public function getInfoChauffeur()
  619.     {
  620.         $return = null;
  621.         if(!empty($this->infoChauffeurs))
  622.         {
  623.             foreach($this->infoChauffeurs as $infoChauffeur)
  624.             {
  625.                 $return = $infoChauffeur;
  626.             }
  627.         }
  628.         return $return;
  629.     }
  631.     /**
  632.      * @return Collection<int, InfoChauffeurDate>
  633.      */
  634.     public function getInfoChauffeurDates(): Collection
  635.     {
  636.         return $this->infoChauffeurDates;
  637.     }
  639.     public function addInfoChauffeurDate(InfoChauffeurDate $infoChauffeurDate): self
  640.     {
  641.         if (!$this->infoChauffeurDates->contains($infoChauffeurDate)) {
  642.             $this->infoChauffeurDates->add($infoChauffeurDate);
  643.             $infoChauffeurDate->setUser($this);
  644.         }
  646.         return $this;
  647.     }
  649.     public function removeInfoChauffeurDate(InfoChauffeurDate $infoChauffeurDate): self
  650.     {
  651.         if ($this->infoChauffeurDates->removeElement($infoChauffeurDate)) {
  652.             // set the owning side to null (unless already changed)
  653.             if ($infoChauffeurDate->getUser() === $this) {
  654.                 $infoChauffeurDate->setUser(null);
  655.             }
  656.         }
  658.         return $this;
  659.     }
  661.     /**
  662.      * @return Collection<int, PlanningUpdateDateTime>
  663.      */
  664.     public function getPlanningUpdateDateTimes(): Collection
  665.     {
  666.         return $this->planningUpdateDateTimes;
  667.     }
  669.     public function addPlanningUpdateDateTime(PlanningUpdateDateTime $planningUpdateDateTime): static
  670.     {
  671.         if (!$this->planningUpdateDateTimes->contains($planningUpdateDateTime)) {
  672.             $this->planningUpdateDateTimes->add($planningUpdateDateTime);
  673.             $planningUpdateDateTime->setUserUpdate($this);
  674.         }
  676.         return $this;
  677.     }
  679.     public function removePlanningUpdateDateTime(PlanningUpdateDateTime $planningUpdateDateTime): static
  680.     {
  681.         if ($this->planningUpdateDateTimes->removeElement($planningUpdateDateTime)) {
  682.             // set the owning side to null (unless already changed)
  683.             if ($planningUpdateDateTime->getUserUpdate() === $this) {
  684.                 $planningUpdateDateTime->setUserUpdate(null);
  685.             }
  686.         }
  688.         return $this;
  689.     }
  691.     /**
  692.      * @return Collection<int, HoraireExploit>
  693.      */
  694.     public function getNo(): Collection
  695.     {
  696.         return $this->no;
  697.     }
  699.     public function addNo(HoraireExploit $no): static
  700.     {
  701.         if (!$this->no->contains($no)) {
  702.             $this->no->add($no);
  703.             $no->setUser($this);
  704.         }
  706.         return $this;
  707.     }
  709.     public function removeNo(HoraireExploit $no): static
  710.     {
  711.         if ($this->no->removeElement($no)) {
  712.             // set the owning side to null (unless already changed)
  713.             if ($no->getUser() === $this) {
  714.                 $no->setUser(null);
  715.             }
  716.         }
  718.         return $this;
  719.     }
  721.     public function getTelephonePro(): ?string
  722.     {
  723.         return $this->telephonePro;
  724.     }
  726.     public function setTelephonePro(string $telephonePro): static
  727.     {
  728.         $this->telephonePro = $telephonePro;
  730.         return $this;
  731.     }
  733.     public function getCodePin(): ?string
  734.     {
  735.         return $this->codePin;
  736.     }
  738.     public function setCodePin(string $codePin): static
  739.     {
  740.         $this->codePin = $codePin;
  742.         return $this;
  743.     }
  745.     public function getIdAddSecure(): ?int
  746.     {
  747.         return $this->idAddSecure;
  748.     }
  750.     public function setIdAddSecure(int $idAddSecure): static
  751.     {
  752.         $this->idAddSecure = $idAddSecure;
  754.         return $this;
  755.     }
  757. }