src/Entity/User.php line 18

Open in your IDE?
  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\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Gedmo\Mapping\Annotation as Gedmo;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  * @UniqueEntity(fields={"email"}, message="Il existe déjà un compte avec cette adresse.")
  17.  */
  18. class User implements UserInterface, PasswordAuthenticatedUserInterface {
  19.     /**
  20.      * @ORM\Id
  21.      * @ORM\GeneratedValue
  22.      * @ORM\Column(type="integer")
  23.      */
  24.     private $id;
  25.     /**
  26.      * @ORM\Column(type="string", length=180, unique=true)
  27.      *
  28.      */
  29.     private $email;
  31.     /**
  32.      * @ORM\Column(type="json")
  33.      */
  34.     private $roles = array();
  36.     /**
  37.      * @var string The hashed password
  38.      * @ORM\Column(type="string")
  39.      */
  40.     private $password;
  42.     /**
  43.     * @ORM\Column(type="datetime")
  44.     * @Gedmo\Timestampable(on="create")
  45.     */
  46.     private $createdAt;
  47.     /**
  48.      * @ORM\Column(type="datetime")
  49.      * @Gedmo\Timestampable(on="update")
  50.      */
  51.     private $updatedAt;
  53.     /**
  54.      * @ORM\Column(type="string", length=50, nullable=true)
  55.      */
  56.     private $nom;
  58.     /**
  59.      * @ORM\Column(type="string", length=50, nullable=true)
  60.      */
  61.     private $prenom;
  63.     /**
  64.      * @ORM\Column(type="date", nullable=true)
  65.      */
  66.     private $naissance;
  68.     /**
  69.      * @ORM\Column(type="string", length=5, nullable=true)
  70.      */
  71.     private $cp;
  73.     /**
  74.      * @ORM\Column(type="string", length=10, nullable=true)
  75.      */
  76.     private $telephone;
  78.     /**
  79.      * @ORM\Column(type="integer")
  80.      */
  81.     private $isVerified = false;
  83.     /**
  84.      * @ORM\Column(type="integer", options={"comment": "0: demande en cours, 1: approuvée, 2: refusée","default":0})
  85.      */
  86.     private $isApprouved = false;
  88.     /**
  89.      * @ORM\Column(type="boolean")
  90.      */
  91.     private $isSuspend = false;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity=UserEleveDocument::class, mappedBy="users", orphanRemoval=true, cascade={"persist", "remove"})
  95.      */
  96.     private $documents;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=ShopPanier::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "remove"})
  100.      */
  101.     private $shopPaniers;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=ShopOrder::class, mappedBy="user", orphanRemoval=true, cascade={"persist", "remove"})
  105.      * @ORM\OrderBy({"createdAt" = "DESC"})
  106.      */
  107.     private $shopOrders;
  109.     /**
  110.      * @ORM\OneToMany(targetEntity=ShopUserAdress::class, mappedBy="user", cascade={"persist", "remove"})
  111.      */
  112.     private $shopUserAdresses;
  114.     /**
  115.      * @ORM\OneToMany(targetEntity=UserEleveCredit::class, mappedBy="user", cascade={"persist", "remove"})
  116.      */
  117.     private $UserEleveCredits;
  119.     /**
  120.      * @ORM\OneToMany(targetEntity=ShopOrderProductConsommation::class, mappedBy="user", cascade={"persist", "remove"})
  121.      */
  122.     private $ShopOrderProductConsommations;
  124.     /**
  125.      * @ORM\Column(type="string", length=255)
  126.      */
  127.     private $ville;
  129.     /**
  130.      * @ORM\OneToMany(targetEntity=UserEnseignantDocument::class, mappedBy="user", orphanRemoval=true, cascade={"remove"})
  131.      */
  132.     private $userEnseignantDocuments;
  134.     /**
  135.      * @ORM\OneToOne(targetEntity=UserEnseignantAccountDetail::class, mappedBy="user", cascade={"persist"})
  136.      */
  137.     private $userEnseignantAccountDetail;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=UserEnseignantAccountVehicule::class, mappedBy="user", orphanRemoval=true, cascade={"remove"})
  141.      */
  142.     private $userEnseignantAccountVehicules;
  144.     /**
  145.      * @ORM\Column(type="string", length=25, nullable=true)
  146.      */
  147.     private $dpt;
  149.     /**
  150.      * @ORM\OneToMany(targetEntity=ActiviteDisponibilite::class, mappedBy="user", orphanRemoval=true, cascade={"remove"})
  151.      */
  152.     private $activiteDisponibilites;
  154.     /**
  155.      * @ORM\OneToMany(targetEntity=ActiviteDisponibiliteInscription::class, mappedBy="user", orphanRemoval=true, cascade={"remove"})
  156.      */
  157.     private $activiteDisponibiliteInscriptions;
  159.     /**
  160.      * @ORM\OneToMany(targetEntity=UserEnseignantLieu::class, mappedBy="user", orphanRemoval=true)
  161.      */
  162.     private $userEnseignantLieux;
  164.     /**
  165.      * @ORM\Column(type="string", length=255, nullable=true)
  166.      */
  167.     private $reference;
  169.     /**
  170.      * @ORM\OneToMany(targetEntity=UserEleveCreditConsommation::class, mappedBy="user", orphanRemoval=true, cascade={"remove"})
  171.      */
  172.     private $userEleveCreditConsommations;
  174.     /**
  175.      * @ORM\OneToMany(targetEntity=LivretEvaluation::class, mappedBy="eleve", orphanRemoval=true, cascade={"remove"})
  176.      */
  177.     private $livretEvaluations;
  179.     /**
  180.      * @ORM\OneToMany(targetEntity=LivretEstimation::class, mappedBy="eleve", cascade={"remove"})
  181.      */
  182.     private $estimations;
  184.     /**
  185.      * @ORM\OneToMany(targetEntity=UserEnseignantFacture::class, mappedBy="enseignant", cascade={"remove"})
  186.      */
  187.     private $factures;
  189.     /**
  190.      * @ORM\Column(type="string", unique=true, nullable=true)
  191.      */
  192.     private $apiToken;
  194.     /**
  195.      * @ORM\Column(type="datetime", nullable=true)
  196.      */
  197.     private $deletedAt;
  199.     public function __construct() {
  200.         $this->documents = new ArrayCollection();
  201.         $this->shopPaniers = new ArrayCollection();
  202.         $this->shopOrders = new ArrayCollection();
  203.         $this->shopUserAdresses = new ArrayCollection();
  204.         $this->UserEleveCredits = new ArrayCollection();
  205.         $this->ShopOrderProductConsommations = new ArrayCollection();
  206.         $this->userEnseignantDocuments = new ArrayCollection();
  207.         $this->userEnseignantAccountVehicules = new ArrayCollection();
  208.         $this->activiteDisponibilites = new ArrayCollection();
  209.         $this->activiteDisponibiliteInscriptions = new ArrayCollection();
  210.         $this->userEnseignantLieux = new ArrayCollection();
  211.         $this->userEleveCreditConsommations = new ArrayCollection();
  212.         $this->livretEvaluations = new ArrayCollection();
  213.         $this->estimations = new ArrayCollection();
  214.         $this->factures = new ArrayCollection();
  215.     }
  217.     public function getId(): ?int {
  218.         return $this->id;
  219.     }
  221.     public function getEmail(): ?string {
  222.         return $this->email;
  223.     }
  225.     public function setEmail(string $email): self {
  226.         $this->email = $email;
  227.                                                                                                                                                                                                                                                                                     
  228.         return $this;
  229.     }
  231.     /**
  232.      * A visual identifier that represents this user.
  233.      *
  234.      * @see UserInterface
  235.      */
  236.     public function getUserIdentifier(): string {
  237.         return (string) $this->email;
  238.     }
  240.     /**
  241.      * @see UserInterface
  242.      */
  243.     public function getRoles(): array {
  244.         $roles = $this->roles;
  245.         // guarantee every user at least has ROLE_USER
  246.         $roles[] = 'ROLE_USER';
  247.                                                                                                                                                                                                                                                                                     
  248.         return array_unique($roles);
  249.     }
  251.     public function setRoles(array $roles): self {
  252.         $this->roles = $roles;
  253.                                                                                                                                                                                                                                                                                     
  254.         return $this;
  255.     }
  257.     /**
  258.      * @see PasswordAuthenticatedUserInterface
  259.      */
  260.     public function getPassword(): string {
  261.         return $this->password;
  262.     }
  264.     public function setPassword(string $password): self {
  265.         $this->password = $password;
  266.                                                                                                                                                                                                                                                                                     
  267.         return $this;
  268.     }
  270.     /**
  271.      * Returning a salt is only needed, if you are not using a modern
  272.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  273.      *
  274.      * @see UserInterface
  275.      */
  276.     public function getSalt(): ?string {
  277.         return null;
  278.     }
  280.     /**
  281.      * @see UserInterface
  282.      */
  283.     public function eraseCredentials() {
  284.         // If you store any temporary, sensitive data on the user, clear it here
  285.                                                                                                                                                                                                                                                                                             // $this->plainPassword = null;
  286.     }
  288.     public function getUsername(): string {
  289.         return $this->email;
  290.     }
  291.     public function getCreatedAt(): ?\DateTimeInterface {
  292.         return $this->createdAt;
  293.     }
  294.     public function setCreatedAt(?\DateTimeInterface $createdAt): self {
  295.         $this->createdAt = $createdAt;
  296.                                                                                                                                                                                                                                                                                     
  297.         return $this;
  298.     }
  299.     public function getUpdatedAt(): ?\DateTimeInterface {
  300.         return $this->updatedAt;
  301.     }
  302.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self {
  303.         $this->updatedAt = $updatedAt;
  304.                                                                                                                                                                                                                                                                                     
  305.         return $this;
  306.     }
  308.     public function getNom(): ?string {
  309.         return $this->nom;
  310.     }
  312.     public function setNom(?string $nom): self {
  313.         $this->nom = $nom;
  314.                                                                                                                                                                                                                         
  315.         return $this;
  316.     }
  318.     public function getPrenom(): ?string {
  319.         return $this->prenom;
  320.     }
  322.     public function setPrenom(?string $prenom): self {
  323.         $this->prenom = $prenom;
  324.                                                                                                                                                                                                                         
  325.         return $this;
  326.     }
  328.     public function getNaissance(): ?\DateTimeInterface {
  329.         return $this->naissance;
  330.     }
  332.     public function setNaissance(?\DateTimeInterface $naissance): self {
  333.         $this->naissance = $naissance;
  334.                                                                                                                                                                                                                         
  335.         return $this;
  336.     }
  338.     public function getCp(): ?string {
  339.         return $this->cp;
  340.     }
  342.     public function setCp(?string $cp): self {
  343.         $this->cp = $cp;
  344.                                                                                                                                                                                                                         
  345.         return $this;
  346.     }
  348.     public function getTelephone(): ?string {
  349.         return $this->telephone;
  350.     }
  352.     public function setTelephone(?string $telephone): self {
  353.         if(strlen($telephone) > 10){
  354.             $telephone = str_replace(' ', '', $telephone);
  355.         }
  356.         if(strlen($telephone) > 10){
  357.             $telephone = str_replace('+33', '0', $telephone);
  358.         }
  359.         $this->telephone = $telephone;
  360.         return $this;
  361.     }
  363.     public function isVerified(): bool {
  364.         return $this->isVerified;
  365.     }
  367.     public function setIsVerified(bool $isVerified): self {
  368.         $this->isVerified = $isVerified;
  369.                                                                                                                                                                                                                         
  370.         return $this;
  371.     }
  373.     public function isApprouved(): int {
  374.         return $this->isApprouved;
  375.     }
  377.     public function isDisapproved(): bool {
  378.         return $this->isApprouved == 2;
  379.     }
  381.     public function isApproved(): bool {
  382.         return $this->isApprouved == 1;
  383.     }
  384.     public function isPending(): bool {
  385.         return $this->isApprouved == 0;
  386.     }
  388.     public function setIsApprouved(int $isApprouved): self {
  389.         $this->isApprouved = $isApprouved;
  390.                                                                                                                                                                                                                         
  391.         return $this;
  392.     }
  394.     public function isSuspend(): bool {
  395.         return $this->isSuspend;
  396.     }
  398.     public function setIsSuspend(bool $isSuspend): self {
  399.         $this->isSuspend = $isSuspend;
  400.                                                                                                                                                                                                                         
  401.         return $this;
  402.     }
  403.     /**
  404.      * @return Collection|UserEleveDocument[]
  405.      */
  406.     public function getDocuments(): Collection {
  407.         return $this->documents;
  408.     }
  410.     public function addDocument(UserEleveDocument $document): self {
  411.         if (!$this->documents->contains($document)) {
  412.             $this->documents[] = $document;
  413.             $document->setUsers($this);
  414.         }
  415.                                                                                                                                                                                         
  416.         return $this;
  417.     }
  419.     public function removeDocument(UserEleveDocument $document): self {
  420.         if ($this->documents->removeElement($document)) {
  421.             // set the owning side to null (unless already changed)
  422.             if ($document->getUsers() === $this) {
  423.                 $document->setUsers(null);
  424.             }
  425.         }
  426.                                                                                                                                                                                         
  427.         return $this;
  428.     }
  430.     /**
  431.      * @return Collection|ShopPanier[]
  432.      */
  433.     public function getShopPaniers(): Collection {
  434.         return $this->shopPaniers;
  435.     }
  437.     public function addShopPanier(ShopPanier $shopPanier): self {
  438.         if (!$this->shopPaniers->contains($shopPanier)) {
  439.             $this->shopPaniers[] = $shopPanier;
  440.             $shopPanier->setUser($this);
  441.         }
  442.                                                                                                             
  443.         return $this;
  444.     }
  446.     public function removeShopPanier(ShopPanier $shopPanier): self {
  447.         if ($this->shopPaniers->removeElement($shopPanier)) {
  448.             // set the owning side to null (unless already changed)
  449.             if ($shopPanier->getUser() === $this) {
  450.                 $shopPanier->setUser(null);
  451.             }
  452.         }
  453.                                                                                                             
  454.         return $this;
  455.     }
  457.     /**
  458.      * @return Collection|ShopOrder[]
  459.      */
  460.     public function getShopOrders(): Collection {
  461.         return $this->shopOrders;
  462.     }
  464.     public function addShopOrder(ShopOrder $shopOrder): self {
  465.         if (!$this->shopOrders->contains($shopOrder)) {
  466.             $this->shopOrders[] = $shopOrder;
  467.             $shopOrder->setUser($this);
  468.         }
  469.                                                                                                             
  470.         return $this;
  471.     }
  473.     public function removeShopOrder(ShopOrder $shopOrder): self {
  474.         if ($this->shopOrders->removeElement($shopOrder)) {
  475.             // set the owning side to null (unless already changed)
  476.             if ($shopOrder->getUser() === $this) {
  477.                 $shopOrder->setUser(null);
  478.             }
  479.         }
  480.                                                                                                             
  481.         return $this;
  482.     }
  484.     /**
  485.      * @return Collection|ShopUserAdress[]
  486.      */
  487.     public function getShopUserAdresses(): Collection {
  488.         return $this->shopUserAdresses;
  489.     }
  491.     public function addShopUserAdress(ShopUserAdress $shopUserAdress): self {
  492.         if (!$this->shopUserAdresses->contains($shopUserAdress)) {
  493.             $this->shopUserAdresses[] = $shopUserAdress;
  494.             $shopUserAdress->setUser($this);
  495.         }
  496.                                                                                                             
  497.         return $this;
  498.     }
  500.     public function removeShopUserAdress(ShopUserAdress $shopUserAdress): self {
  501.         if ($this->shopUserAdresses->removeElement($shopUserAdress)) {
  502.             // set the owning side to null (unless already changed)
  503.             if ($shopUserAdress->getUser() === $this) {
  504.                 $shopUserAdress->setUser(null);
  505.             }
  506.         }
  507.                                                                                                             
  508.         return $this;
  509.     }
  511.     /**
  512.      * @return Collection|UserEleveCredit[]
  513.      */
  514.     public function getUserEleveCredits(): Collection {
  515.         return $this->UserEleveCredits;
  516.     }
  518.     public function addUserEleveCredit(UserEleveCredit $UserEleveCredit): self {
  519.         if (!$this->UserEleveCredits->contains($UserEleveCredit)) {
  520.             $this->UserEleveCredits[] = $UserEleveCredit;
  521.             $UserEleveCredit->setUser($this);
  522.         }
  523.                         
  524.         return $this;
  525.     }
  527.     public function removeUserEleveCredit(UserEleveCredit $UserEleveCredit): self {
  528.         if ($this->UserEleveCredits->removeElement($UserEleveCredit)) {
  529.             // set the owning side to null (unless already changed)
  530.             if ($UserEleveCredit->getUser() === $this) {
  531.                 $UserEleveCredit->setUser(null);
  532.             }
  533.         }
  534.                         
  535.         return $this;
  536.     }
  537.     public function getUserEleveCredit(ShopCategorie $Category): ?UserEleveCredit {
  538.         $UserEleveCredit = $this->UserEleveCredits->filter(function($element) use($Category) {
  539.             return $element->getCategorie()->getId() == $Category->getId();
  540.         })->first();
  541.         if ($UserEleveCredit) {
  542.             return $UserEleveCredit;
  543.         }
  544.         return null;
  545.     }
  547.     /**
  548.      * @return Collection|ShopOrderProductConsommation[]
  549.      */
  550.     public function getShopOrderProductConsommations(): Collection {
  551.         return $this->ShopOrderProductConsommations;
  552.     }
  554.     public function addShopOrderProductConsommation(ShopOrderProductConsommation $ShopOrderProductConsommation): self {
  555.         if (!$this->ShopOrderProductConsommations->contains($ShopOrderProductConsommation)) {
  556.             $this->ShopOrderProductConsommations[] = $ShopOrderProductConsommation;
  557.             $ShopOrderProductConsommation->setUser($this);
  558.         }
  559.                         
  560.         return $this;
  561.     }
  563.     public function removeShopOrderProductConsommation(ShopOrderProductConsommation $ShopOrderProductConsommation): self {
  564.         if ($this->ShopOrderProductConsommations->removeElement($ShopOrderProductConsommation)) {
  565.             // set the owning side to null (unless already changed)
  566.             if ($ShopOrderProductConsommation->getUser() === $this) {
  567.                 $ShopOrderProductConsommation->setUser(null);
  568.             }
  569.         }
  570.                         
  571.         return $this;
  572.     }
  574.     public function getVille(): ?string {
  575.         return $this->ville;
  576.     }
  578.     public function setVille(string $ville): self {
  579.         $this->ville = $ville;
  580.                         
  581.         return $this;
  582.     }
  584.     /**
  585.      * @return Collection|UserEnseignantDocument[]
  586.      */
  587.     public function getUserEnseignantDocuments(): Collection {
  588.         return $this->userEnseignantDocuments;
  589.     }
  591.     public function addUserEnseignantDocument(UserEnseignantDocument $userEnseignantDocument): self {
  592.         if (!$this->userEnseignantDocuments->contains($userEnseignantDocument)) {
  593.             $this->userEnseignantDocuments[] = $userEnseignantDocument;
  594.             $userEnseignantDocument->setUser($this);
  595.         }
  596.                         
  597.         return $this;
  598.     }
  600.     public function removeUserEnseignantDocument(UserEnseignantDocument $userEnseignantDocument): self {
  601.         if ($this->userEnseignantDocuments->removeElement($userEnseignantDocument)) {
  602.             // set the owning side to null (unless already changed)
  603.             if ($userEnseignantDocument->getUser() === $this) {
  604.                 $userEnseignantDocument->setUser(null);
  605.             }
  606.         }
  607.                         
  608.         return $this;
  609.     }
  610.     public function getDocument($doc): ?UserEnseignantDocument {
  611.         $elements = $this->getUserEnseignantDocuments()->filter(function($Document) use ($doc) {return $Document->getDoc() == $doc;});
  612.         if(count($elements))
  613.         return $elements[0];
  614.         return null;
  615.     }
  617.     /**
  618.     * @return Collection|UserEnseignantAccountVehicule[]
  619.     */
  620.     public function getUserEnseignantAccountVehicules(): Collection {
  621.         return $this->userEnseignantAccountVehicules;
  622.     }
  624.     public function addUserEnseignantAccountVehicule(UserEnseignantAccountVehicule $userEnseignantAccountVehicule): self {
  625.         if (!$this->userEnseignantAccountVehicules->contains($userEnseignantAccountVehicule)) {
  626.             $this->userEnseignantAccountVehicules[] = $userEnseignantAccountVehicule;
  627.             $userEnseignantAccountVehicule->setUser($this);
  628.         }
  630.         return $this;
  631.     }
  633.     public function removeUserEnseignantAccountVehicule(UserEnseignantAccountVehicule $userEnseignantAccountVehicule): self {
  634.         if ($this->userEnseignantAccountVehicules->removeElement($userEnseignantAccountVehicule)) {
  635.             // set the owning side to null (unless already changed)
  636.             if ($userEnseignantAccountVehicule->getUser() === $this) {
  637.                 $userEnseignantAccountVehicule->setUser(null);
  638.             }
  639.         }
  641.         return $this;
  642.     }
  644.     public function getAccountDetail(): ?UserEnseignantAccountDetail {
  645.         return $this->getUserEnseignantAccountDetail();
  646.     }
  647.     public function getUserEnseignantAccountDetail(): ?UserEnseignantAccountDetail {
  648.         return $this->userEnseignantAccountDetail;
  649.     }
  651.     public function setUserEnseignantAccountDetail(UserEnseignantAccountDetail $userEnseignantAccountDetail): self {
  652.         // set the owning side of the relation if necessary
  653.         if ($userEnseignantAccountDetail->getUser() !== $this) {
  654.             $userEnseignantAccountDetail->setUser($this);
  655.         }
  657.         $this->userEnseignantAccountDetail = $userEnseignantAccountDetail;
  659.         return $this;
  660.     }
  662.     public function getDpt(): ?string
  663.     {
  664.         return $this->dpt;
  665.     }
  667.     public function setDpt(?string $dpt): self
  668.     {
  669.         $this->dpt = $dpt;
  671.         return $this;
  672.     }
  674.     /**
  675.      * @return Collection|ActiviteDisponibilite[]
  676.      */
  677.     public function getActiviteDisponibilites(): Collection
  678.     {
  679.         return $this->activiteDisponibilites;
  680.     }
  682.     public function addActiviteDisponibilite(ActiviteDisponibilite $activiteDisponibilite): self
  683.     {
  684.         if (!$this->activiteDisponibilites->contains($activiteDisponibilite)) {
  685.             $this->activiteDisponibilites[] = $activiteDisponibilite;
  686.             $activiteDisponibilite->setUser($this);
  687.         }
  689.         return $this;
  690.     }
  692.     public function removeActiviteDisponibilite(ActiviteDisponibilite $activiteDisponibilite): self
  693.     {
  694.         if ($this->activiteDisponibilites->removeElement($activiteDisponibilite)) {
  695.             // set the owning side to null (unless already changed)
  696.             if ($activiteDisponibilite->getUser() === $this) {
  697.                 $activiteDisponibilite->setUser(null);
  698.             }
  699.         }
  701.         return $this;
  702.     }
  704.     /**
  705.      * @return Collection|ActiviteDisponibiliteInscription[]
  706.      */
  707.     public function getActiviteDisponibiliteInscriptions(): Collection
  708.     {
  709.         return $this->activiteDisponibiliteInscriptions;
  710.     }
  712.     public function addActiviteDisponibiliteInscription(ActiviteDisponibiliteInscription $activiteDisponibiliteInscription): self
  713.     {
  714.         if (!$this->activiteDisponibiliteInscriptions->contains($activiteDisponibiliteInscription)) {
  715.             $this->activiteDisponibiliteInscriptions[] = $activiteDisponibiliteInscription;
  716.             $activiteDisponibiliteInscription->setUser($this);
  717.         }
  719.         return $this;
  720.     }
  722.     public function removeActiviteDisponibiliteInscription(ActiviteDisponibiliteInscription $activiteDisponibiliteInscription): self
  723.     {
  724.         if ($this->activiteDisponibiliteInscriptions->removeElement($activiteDisponibiliteInscription)) {
  725.             // set the owning side to null (unless already changed)
  726.             if ($activiteDisponibiliteInscription->getUser() === $this) {
  727.                 $activiteDisponibiliteInscription->setUser(null);
  728.             }
  729.         }
  731.         return $this;
  732.     }
  734.     /**
  735.      * @return Collection|UserEnseignantLieu[]
  736.      */
  737.     public function getUserEnseignantLieux(): Collection
  738.     {
  739.         return $this->userEnseignantLieux;
  740.     }
  742.     public function addUserEnseignantLieux(UserEnseignantLieu $userEnseignantLieux): self
  743.     {
  744.         if (!$this->userEnseignantLieux->contains($userEnseignantLieux)) {
  745.             $this->userEnseignantLieux[] = $userEnseignantLieux;
  746.             $userEnseignantLieux->setUser($this);
  747.         }
  749.         return $this;
  750.     }
  752.     public function removeUserEnseignantLieux(UserEnseignantLieu $userEnseignantLieux): self
  753.     {
  754.         if ($this->userEnseignantLieux->removeElement($userEnseignantLieux)) {
  755.             // set the owning side to null (unless already changed)
  756.             if ($userEnseignantLieux->getUser() === $this) {
  757.                 $userEnseignantLieux->setUser(null);
  758.             }
  759.         }
  761.         return $this;
  762.     }
  763.     public function getReference(): ?string
  764.     {
  765.         return $this->reference;
  766.     }
  768.     public function setReference(?string $reference): self
  769.     {
  770.         $this->reference = $reference;
  772.         return $this;
  773.     }
  774.     public function getDir(): string {
  775.         $path = realpath(__DIR__ . '/../../');
  776.         $path .= '/var';
  777.         $path .= '/user';
  778.         $slugger = new \Symfony\Component\String\Slugger\AsciiSlugger;
  779.         $path .= '/'.$slugger->slug($this->getUserIdentifier());
  780.         return $path;
  781.     }
  783.     /**
  784.      * @return Collection<int, UserEleveCreditConsommation>
  785.      */
  786.     public function getUserEleveCreditConsommations(): Collection
  787.     {
  788.         return $this->userEleveCreditConsommations;
  789.     }
  791.     public function addUserEleveCreditConsommation(UserEleveCreditConsommation $userEleveCreditConsommation): self
  792.     {
  793.         if (!$this->userEleveCreditConsommations->contains($userEleveCreditConsommation)) {
  794.             $this->userEleveCreditConsommations[] = $userEleveCreditConsommation;
  795.             $userEleveCreditConsommation->setUser($this);
  796.         }
  798.         return $this;
  799.     }
  801.     public function removeUserEleveCreditConsommation(UserEleveCreditConsommation $userEleveCreditConsommation): self
  802.     {
  803.         if ($this->userEleveCreditConsommations->removeElement($userEleveCreditConsommation)) {
  804.             // set the owning side to null (unless already changed)
  805.             if ($userEleveCreditConsommation->getUser() === $this) {
  806.                 $userEleveCreditConsommation->setUser(null);
  807.             }
  808.         }
  810.         return $this;
  811.     }
  812.     public function isRole(string $role):bool {
  813.         return in_array('ROLE_'.strtoupper($role), $this->getRoles());
  814.     }
  816.     public function isEleve():bool {
  817.         return $this->isRole('eleve');
  818.     }
  820.     public function isProf():bool {
  821.         return $this->isRole('prof');
  822.     }
  824.     public function isAdmin():bool {
  825.         return $this->isRole('admin')||$this->isRole('super_admin');
  826.     }
  828.     public function isSalarie():bool {
  829.         if(!$this->isProf())return false;
  830.         if(!$this->getUserEnseignantAccountDetail())return false;
  831.         return $this->getUserEnseignantAccountDetail()->isSalarie();
  832.     }
  834.     public function isIndependant():bool {
  835.         if(!$this->isProf())return false;
  836.         if(!$this->getUserEnseignantAccountDetail())return false;
  837.         return $this->getUserEnseignantAccountDetail()->isIndependant();
  838.     }
  840.     public function getType() : ?string
  841.     {
  842.         if($this->isSalarie())return 'salarie';
  843.         if($this->isIndependant())return 'independant';
  844.         return null;
  845.     }
  847.     /**
  848.      * @return Collection<int, LivretEvaluation>
  849.      */
  850.     public function getLivretEvaluations(): Collection
  851.     {
  852.         return $this->livretEvaluations;
  853.     }
  855.     public function addLivretEvaluation(LivretEvaluation $livretEvaluation): self
  856.     {
  857.         if (!$this->livretEvaluations->contains($livretEvaluation)) {
  858.             $this->livretEvaluations[] = $livretEvaluation;
  859.             $livretEvaluation->setEleve($this);
  860.         }
  862.         return $this;
  863.     }
  865.     public function removeLivretEvaluation(LivretEvaluation $livretEvaluation): self
  866.     {
  867.         if ($this->livretEvaluations->removeElement($livretEvaluation)) {
  868.             // set the owning side to null (unless already changed)
  869.             if ($livretEvaluation->getEleve() === $this) {
  870.                 $livretEvaluation->setEleve(null);
  871.             }
  872.         }
  874.         return $this;
  875.     }
  877.     /**
  878.      * @return Collection<int, LivretEstimation>
  879.      */
  880.     public function getEstimations(): Collection
  881.     {
  882.         return $this->estimations;
  883.     }
  885.     public function addEstimation(LivretEstimation $estimation): self
  886.     {
  887.         if (!$this->estimations->contains($estimation)) {
  888.             $this->estimations[] = $estimation;
  889.             $estimation->setEleve($this);
  890.         }
  892.         return $this;
  893.     }
  895.     public function removeEstimation(LivretEstimation $estimation): self
  896.     {
  897.         if ($this->estimations->removeElement($estimation)) {
  898.             // set the owning side to null (unless already changed)
  899.             if ($estimation->getEleve() === $this) {
  900.                 $estimation->setEleve(null);
  901.             }
  902.         }
  904.         return $this;
  905.     }
  907.     /**
  908.      * @return Collection<int, UserEnseignantFacture>
  909.      */
  910.     public function getFactures(): Collection
  911.     {
  912.         return $this->factures;
  913.     }
  915.     public function addFacture(UserEnseignantFacture $facture): self
  916.     {
  917.         if (!$this->factures->contains($facture)) {
  918.             $this->factures[] = $facture;
  919.             $facture->setEnseignant($this);
  920.         }
  922.         return $this;
  923.     }
  925.     public function removeFacture(UserEnseignantFacture $facture): self
  926.     {
  927.         if ($this->factures->removeElement($facture)) {
  928.             // set the owning side to null (unless already changed)
  929.             if ($facture->getEnseignant() === $this) {
  930.                 $facture->setEnseignant(null);
  931.             }
  932.         }
  934.         return $this;
  935.     }
  936.     public function getFacture(\DateTimeInterface $periode_debut, \DateTimeInterface $periode_fin): ?UserEnseignantFacture
  937.     {
  938.         $Facture = $this->factures->filter(function($element) use($periode_debut, $periode_fin) {
  939.             if($element->getExport())return false;
  940.             if($element->getPeriodeDebut()->format('c') != $periode_debut->format('c'))return false;
  941.             if($element->getPeriodeFin()->format('c') != $periode_fin->format('c'))return false;
  942.             return true;
  943.         })->first();
  944.         if ($Facture) {
  945.             return $Facture;
  946.         }
  947.         return null;
  948.     }
  950.     public function getApiToken(): ?string
  951.     {
  952.         return $this->apiToken;
  953.     }
  955.     public function setApiToken(?string $apiToken): self
  956.     {
  957.         $this->apiToken = $apiToken;
  959.         return $this;
  960.     }
  962.     public function isDeleted(): bool
  963.     {
  964.         return ($this->deletedAt !== null);
  965.     }
  967.     public function getDeletedAt(): ?\DateTimeInterface
  968.     {
  969.         return $this->deletedAt;
  970.     }
  972.     public function setDeletedAt(?\DateTimeInterface $deletedAt): self
  973.     {
  974.         $this->deletedAt = $deletedAt;
  976.         return $this;
  977.     }
  979. }