src/Entity/Utilisateur.php line 18

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Serializable;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  11. use Symfony\Component\Validator\Constraints as Assert;
  13. /**
  14.  * @ORM\Entity(repositoryClass="App\Repository\UtilisateurRepository")
  15.  * @UniqueEntity("UserName",message="Cette email est déjà utilisé")
  16.  * @UniqueEntity("idAg",message="Un agent ne peut avoir qu'un compte")
  17.  * @method string getUserIdentifier()*/
  18. class Utilisateur implements UserInterface, Serializable
  19. {
  20.     /**
  21.      * @ORM\Id()
  22.      * @ORM\GeneratedValue()
  23.      * @ORM\Column(type="integer")
  24.      */
  25.     private $id;
  29.     /**
  30.      * @ORM\Column(type="boolean")
  31.      */
  32.     private $Etat;
  34.     /**
  35.      * @ORM\Column(type="string", length=255)
  36.      */
  37.     private $Role;
  39.     /**
  40.      * @ORM\Column(type="date")
  41.      */
  42.     private $date_created;
  44.     /**
  45.      * @ORM\Column(type="date")
  46.      */
  47.     private $date_connected;
  49.     /**
  50.      * @ORM\Column(type="boolean")
  51.      */
  52.     private $status;
  54.     /**
  55.      * @ORM\Column(type="string", length=255)
  56.      */
  57.     private $UserName;
  59.     /**
  60.      * @ORM\Column(type="string", length=255)
  61.      * @Assert\Length(
  62.      *     min=8,
  63.      *     minMessage="Mot de passe courte, au moins 8 caractères"
  64.      * )
  65.      */
  66.     private $Password;
  68.     /**
  69.      * @var
  70.      */
  71.     private $ancienPassWord;
  73.     /**
  74.      * @var
  75.      * @Assert\EqualTo(propertyPath="NouveauPassWord",message="Ne correspond pas au mot de passe")
  76.      */
  77.     private $NouveauPassWord;
  79.     /**
  80.      * @Assert\EqualTo(propertyPath="password",message="Ne correspond pas au passe word")
  81.      */
  82.     private $confirmerPassword;
  85.     private $oldPassword;
  87.     /**
  88.      * @Assert\Length(min = "8", minMessage = "Minimum 8 caracteurs")
  89.      */
  90.     private $newPassword;
  92.     /**
  93.      * @Assert\EqualTo(propertyPath="newPassword",message="Ne correspond pas au nouveau passe word")
  94.      */
  95.     private $confPassword;
  97.     /**
  98.      * @ORM\Column(type="string", length=255)
  99.      */
  100.     private $langue;
  102.     /**
  103.      * @ORM\Column(type="boolean")
  104.      */
  105.     private $flag_sms;
  107.     /**
  108.      * @ORM\Column(type="boolean")
  109.      */
  110.     private $flag_voice_sms;
  112.     /**
  113.      * @ORM\Column(type="boolean")
  114.      */
  115.     private $flag_voice_whatsapp;
  117.     /**
  118.      * @ORM\OneToMany(targetEntity=Paiement::class, mappedBy="IdAg")
  119.      */
  120.     private $paiements;
  122.     /**
  123.      * @ORM\ManyToOne(targetEntity=Ville::class, inversedBy="utilisateurs")
  124.      */
  125.     private $ville;
  127.     /**
  128.      * @ORM\OneToMany(targetEntity=DepensesContenaire::class, mappedBy="IdAg")
  129.      */
  130.     private $depensesContenaires;
  132.     /**
  133.      * @ORM\OneToMany(targetEntity=TransfertEnvoie::class, mappedBy="userValidated")
  134.      */
  135.     private $transfertEnvoies;
  137.     /**
  138.      * @ORM\OneToOne(targetEntity=Agent::class, inversedBy="utilisateur", cascade={"persist", "remove"})
  139.      */
  140.     private $idAg;
  142.     /**
  143.      * @ORM\Column(type="boolean", nullable=true)
  144.      */
  145.     private $isMco;
  147.     /**
  148.      * @ORM\OneToMany(targetEntity=Depot::class, mappedBy="user")
  149.      */
  150.     private $depots;
  152.     /**
  153.      * @ORM\OneToMany(targetEntity=Finance::class, mappedBy="userReceipt")
  154.      */
  155.     private $finances;
  157.     /**
  158.      * @ORM\OneToMany(targetEntity=Finance::class, mappedBy="userCaisse")
  159.      */
  160.     private $financeCaisses;
  163.     private $totalCaisse;
  165.     /**
  166.      * @ORM\Column(type="boolean")
  167.      */
  168.     private $iSflagCalacul;
  170.     /**
  171.      * @ORM\Column(type="string", length=255, nullable=true)
  172.      */
  173.     private $caisse_localite;
  175.     /**
  176.      * @ORM\OneToMany(targetEntity=Reception::class, mappedBy="user")
  177.      */
  178.     private $receptions;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity=TmpConteneurReception::class, mappedBy="user")
  182.      */
  183.     private $tmpConteneurReceptions;
  185.     /**
  186.      * @ORM\OneToMany(targetEntity=TmpReception::class, mappedBy="user")
  187.      */
  188.     private $tmpReceptions;
  193.     public function __construct()
  194.     {
  195.         $this->date_connected = new \DateTime();
  196.         $this->date_created = new \DateTime();
  197.         $this->status = false;
  198.         $this->Etat = false;
  199.         $this->paiements = new ArrayCollection();
  200.         $this->depensesContenaires = new ArrayCollection();
  201.         $this->transfertEnvoies = new ArrayCollection();
  202.         $this->depots = new ArrayCollection();
  203.         $this->finances = new ArrayCollection();
  204.         $this->financeCaisses = new ArrayCollection();
  205.         $this->rapportClotures = new ArrayCollection();
  206.         $this->receptions = new ArrayCollection();
  207.         $this->tmpConteneurReceptions = new ArrayCollection();
  208.         $this->tmpReceptions = new ArrayCollection();
  209.     }
  211.     public function getId(): ?int
  212.     {
  213.         return $this->id;
  214.     }
  218.     public function getEtat(): ?bool
  219.     {
  220.         return $this->Etat;
  221.     }
  223.     public function setEtat(bool $Etat): self
  224.     {
  225.         $this->Etat = $Etat;
  227.         return $this;
  228.     }
  230.     public function getRole(): ?string
  231.     {
  232.         return $this->Role;
  233.     }
  235.     public function setRole(string $Role): self
  236.     {
  237.         $this->Role = $Role;
  239.         return $this;
  240.     }
  242.     public function getDateCreated(): ?\DateTimeInterface
  243.     {
  244.         return $this->date_created;
  245.     }
  247.     public function setDateCreated(\DateTimeInterface $date_created): self
  248.     {
  249.         $this->date_created = $date_created;
  251.         return $this;
  252.     }
  254.     public function getDateConnected(): ?\DateTimeInterface
  255.     {
  256.         return $this->date_connected;
  257.     }
  259.     public function setDateConnected(\DateTimeInterface $date_connected): self
  260.     {
  261.         $this->date_connected = $date_connected;
  263.         return $this;
  264.     }
  266.     public function getStatus(): ?bool
  267.     {
  268.         return $this->status;
  269.     }
  271.     public function setStatus(bool $status): self
  272.     {
  273.         $this->status = $status;
  275.         return $this;
  276.     }
  278.     public function getUserName(): ?string
  279.     {
  280.         return $this->UserName;
  281.     }
  283.     public function setUserName(string $UserName): self
  284.     {
  285.         $this->UserName = $UserName;
  287.         return $this;
  288.     }
  290.     public function getPassword(): ?string
  291.     {
  292.         return $this->Password;
  293.     }
  295.     public function setPassword(string $Password): self
  296.     {
  297.         $this->Password = $Password;
  299.         return $this;
  300.     }
  302.     /**
  303.      * String representation of object
  304.      * @link http://php.net/manual/en/serializable.serialize.php
  305.      * @return string the string representation of the object or null
  306.      * @since 5.1.0
  307.      */
  308.     public function serialize()
  309.     {
  310.         return serialize([
  311.             $this->id,
  312.             $this->UserName,
  313.             $this->idAg,
  314.             $this->Password,
  315.             $this->date_connected,
  316.         ]);
  317.     }
  319.     /**
  320.      * Constructs the object
  321.      * @link http://php.net/manual/en/serializable.unserialize.php
  322.      * @param string $serialized <p>
  323.      * The string representation of the object.
  324.      * </p>
  325.      * @return void
  326.      * @since 5.1.0
  327.      */
  328.     public function unserialize($serialized)
  329.     {
  330.         list(
  331.             $this->id,
  332.             $this->UserName,
  333.             $this->idAg,
  334.             $this->Password,
  335.             $this->date_connected
  336.             ) = unserialize($serialized,['allowed_classes' => false]);
  337.     }
  339.     /**
  340.      * Returns the roles granted to the user.
  341.      *
  342.      *     public function getRoles()
  343.      *     {
  344.      *         return ['ROLE_USER'];
  345.      *     }
  346.      *
  347.      * Alternatively, the roles might be stored on a ``roles`` property,
  348.      * and populated in any number of different ways when the user object
  349.      * is created.
  350.      *
  351.      * @return string[] The user roles
  352.      */
  353.     public function getRoles()
  354.     {
  355.         return [$this->getRole()];
  356.     }
  358.     /**
  359.      * Returns the salt that was originally used to encode the password.
  360.      *
  361.      * This can return null if the password was not encoded using a salt.
  362.      *
  363.      * @return string|null The salt
  364.      */
  365.     public function getSalt()
  366.     {
  367.         // TODO: Implement getSalt() method.
  368.     }
  370.     /**
  371.      * Removes sensitive data from the user.
  372.      *
  373.      * This is important if, at any given point, sensitive information like
  374.      * the plain-text password is stored on this object.
  375.      */
  376.     public function eraseCredentials()
  377.     {
  378.         // TODO: Implement eraseCredentials() method.
  379.     }
  381.     /**
  382.      * @return mixed
  383.      */
  384.     public function getAncienPassWord()
  385.     {
  386.         return $this->ancienPassWord;
  387.     }
  389.     /**
  390.      * @param mixed $ancienPassWord
  391.      */
  392.     public function setAncienPassWord($ancienPassWord)
  393.     {
  394.         $this->ancienPassWord = $ancienPassWord;
  395.     }
  397.     /**
  398.      * @return mixed
  399.      */
  400.     public function getNouveauPassWord()
  401.     {
  402.         return $this->NouveauPassWord;
  403.     }
  405.     /**
  406.      * @param mixed $NouveauPassWord
  407.      */
  408.     public function setNouveauPassWord($NouveauPassWord)
  409.     {
  410.         $this->NouveauPassWord = $NouveauPassWord;
  411.     }
  413.     /**
  414.      * @return mixed
  415.      */
  416.     public function getConfirmerPassword()
  417.     {
  418.         return $this->confirmerPassword;
  419.     }
  421.     /**
  422.      * @param mixed $confirmerPassword
  423.      */
  424.     public function setConfirmerPassword($confirmerPassword)
  425.     {
  426.         $this->confirmerPassword = $confirmerPassword;
  427.     }
  429.     /**
  430.      * @return mixed
  431.      */
  432.     public function getOldPassword()
  433.     {
  434.         return $this->oldPassword;
  435.     }
  437.     /**
  438.      * @param mixed $oldPassword
  439.      */
  440.     public function setOldPassword($oldPassword)
  441.     {
  442.         $this->oldPassword = $oldPassword;
  443.     }
  445.     /**
  446.      * @return mixed
  447.      */
  448.     public function getNewPassword()
  449.     {
  450.         return $this->newPassword;
  451.     }
  453.     /**
  454.      * @param mixed $newPassword
  455.      */
  456.     public function setNewPassword($newPassword)
  457.     {
  458.         $this->newPassword = $newPassword;
  459.     }
  461.     /**
  462.      * @return mixed
  463.      */
  464.     public function getConfPassword()
  465.     {
  466.         return $this->confPassword;
  467.     }
  469.     /**
  470.      * @param mixed $confPassword
  471.      */
  472.     public function setConfPassword($confPassword)
  473.     {
  474.         $this->confPassword = $confPassword;
  475.     }
  477.     public function getLangue(): ?string
  478.     {
  479.         return $this->langue;
  480.     }
  482.     public function setLangue(string $langue): self
  483.     {
  484.         $this->langue = $langue;
  486.         return $this;
  487.     }
  489.     public function getFlagSms(): ?bool
  490.     {
  491.         return $this->flag_sms;
  492.     }
  494.     public function setFlagSms(bool $flag_sms): self
  495.     {
  496.         $this->flag_sms = $flag_sms;
  498.         return $this;
  499.     }
  501.     public function getFlagVoiceSms(): ?bool
  502.     {
  503.         return $this->flag_voice_sms;
  504.     }
  506.     public function setFlagVoiceSms(bool $flag_voice_sms): self
  507.     {
  508.         $this->flag_voice_sms = $flag_voice_sms;
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return mixed
  514.      */
  515.     public function getFlagVoiceWhatsapp()
  516.     {
  517.         return $this->flag_voice_whatsapp;
  518.     }
  520.     /**
  521.      * @param mixed $flag_voice_whatsapp
  522.      */
  523.     public function setFlagVoiceWhatsapp($flag_voice_whatsapp)
  524.     {
  525.         $this->flag_voice_whatsapp = $flag_voice_whatsapp;
  526.     }
  528.     public function __call($name, $arguments)
  529.     {
  530.         // TODO: Implement @method string getUserIdentifier()
  531.     }
  533.     /**
  534.      * @return Collection<int, Paiement>
  535.      */
  536.     public function getPaiements(): Collection
  537.     {
  538.         return $this->paiements;
  539.     }
  541.     public function addPaiement(Paiement $paiement): self
  542.     {
  543.         if (!$this->paiements->contains($paiement)) {
  544.             $this->paiements[] = $paiement;
  545.             $paiement->setIdAg($this);
  546.         }
  548.         return $this;
  549.     }
  551.     public function removePaiement(Paiement $paiement): self
  552.     {
  553.         if ($this->paiements->removeElement($paiement)) {
  554.             // set the owning side to null (unless already changed)
  555.             if ($paiement->getIdAg() === $this) {
  556.                 $paiement->setIdAg(null);
  557.             }
  558.         }
  560.         return $this;
  561.     }
  563.     public function getVille(): ?Ville
  564.     {
  565.         return $this->ville;
  566.     }
  568.     public function setVille(?Ville $ville): self
  569.     {
  570.         $this->ville = $ville;
  572.         return $this;
  573.     }
  575.     /**
  576.      * @return Collection<int, DepensesContenaire>
  577.      */
  578.     public function getDepensesContenaires(): Collection
  579.     {
  580.         return $this->depensesContenaires;
  581.     }
  583.     public function addDepensesContenaire(DepensesContenaire $depensesContenaire): self
  584.     {
  585.         if (!$this->depensesContenaires->contains($depensesContenaire)) {
  586.             $this->depensesContenaires[] = $depensesContenaire;
  587.             $depensesContenaire->setIdAg($this);
  588.         }
  590.         return $this;
  591.     }
  593.     public function removeDepensesContenaire(DepensesContenaire $depensesContenaire): self
  594.     {
  595.         if ($this->depensesContenaires->removeElement($depensesContenaire)) {
  596.             // set the owning side to null (unless already changed)
  597.             if ($depensesContenaire->getIdAg() === $this) {
  598.                 $depensesContenaire->setIdAg(null);
  599.             }
  600.         }
  602.         return $this;
  603.     }
  605.     /**
  606.      * @return Collection<int, TransfertEnvoie>
  607.      */
  608.     public function getTransfertEnvoies(): Collection
  609.     {
  610.         return $this->transfertEnvoies;
  611.     }
  613.     public function addTransfertEnvoie(TransfertEnvoie $transfertEnvoie): self
  614.     {
  615.         if (!$this->transfertEnvoies->contains($transfertEnvoie)) {
  616.             $this->transfertEnvoies[] = $transfertEnvoie;
  617.             $transfertEnvoie->setUserValidated($this);
  618.         }
  620.         return $this;
  621.     }
  623.     public function removeTransfertEnvoie(TransfertEnvoie $transfertEnvoie): self
  624.     {
  625.         if ($this->transfertEnvoies->removeElement($transfertEnvoie)) {
  626.             // set the owning side to null (unless already changed)
  627.             if ($transfertEnvoie->getUserValidated() === $this) {
  628.                 $transfertEnvoie->setUserValidated(null);
  629.             }
  630.         }
  632.         return $this;
  633.     }
  635.     public function getIdAg(): ?Agent
  636.     {
  637.         return $this->idAg;
  638.     }
  640.     public function setIdAg(?Agent $idAg): self
  641.     {
  642.         $this->idAg = $idAg;
  644.         return $this;
  645.     }
  647.     public function isIsMco(): ?bool
  648.     {
  649.         return $this->isMco;
  650.     }
  652.     public function setIsMco(?bool $isMco): self
  653.     {
  654.         $this->isMco = $isMco;
  656.         return $this;
  657.     }
  659.     /**
  660.      * @return Collection<int, Depot>
  661.      */
  662.     public function getDepots(): Collection
  663.     {
  664.         return $this->depots;
  665.     }
  667.     public function addDepot(Depot $depot): self
  668.     {
  669.         if (!$this->depots->contains($depot)) {
  670.             $this->depots[] = $depot;
  671.             $depot->setUser($this);
  672.         }
  674.         return $this;
  675.     }
  677.     public function removeDepot(Depot $depot): self
  678.     {
  679.         if ($this->depots->removeElement($depot)) {
  680.             // set the owning side to null (unless already changed)
  681.             if ($depot->getUser() === $this) {
  682.                 $depot->setUser(null);
  683.             }
  684.         }
  686.         return $this;
  687.     }
  689.     /**
  690.      * @return Collection<int, Finance>
  691.      */
  692.     public function getFinances(): Collection
  693.     {
  694.         return $this->finances;
  695.     }
  697.     public function addFinance(Finance $finance): self
  698.     {
  699.         if (!$this->finances->contains($finance)) {
  700.             $this->finances[] = $finance;
  701.             $finance->setUserReceipt($this);
  702.         }
  704.         return $this;
  705.     }
  707.     public function removeFinance(Finance $finance): self
  708.     {
  709.         if ($this->finances->removeElement($finance)) {
  710.             // set the owning side to null (unless already changed)
  711.             if ($finance->getUserReceipt() === $this) {
  712.                 $finance->setUserReceipt(null);
  713.             }
  714.         }
  716.         return $this;
  717.     }
  719.     /**
  720.      * @return Collection<int, Finance>
  721.      */
  722.     public function getFinanceCaisses(): Collection
  723.     {
  724.         return $this->financeCaisses;
  725.     }
  727.     public function addFinanceCaiss(Finance $financeCaiss): self
  728.     {
  729.         if (!$this->financeCaisses->contains($financeCaiss)) {
  730.             $this->financeCaisses[] = $financeCaiss;
  731.             $financeCaiss->setUserCaisse($this);
  732.         }
  734.         return $this;
  735.     }
  737.     public function removeFinanceCaiss(Finance $financeCaiss): self
  738.     {
  739.         if ($this->financeCaisses->removeElement($financeCaiss)) {
  740.             // set the owning side to null (unless already changed)
  741.             if ($financeCaiss->getUserCaisse() === $this) {
  742.                 $financeCaiss->setUserCaisse(null);
  743.             }
  744.         }
  746.         return $this;
  747.     }
  750.     public function getTotalCaissse()
  751.     {
  753.     }
  755.     /**
  756.      * @return mixed
  757.      */
  758.     public function getTotalCaisse()
  759.     {
  760.         $total = 0;
  761.         foreach($this->getFinanceCaisses() as $v){
  762.             $total = $total + $v->getMontant();
  763.         }
  765.         return $this->totalCaisse = $total;
  766.     }
  768.     public function isISflagCalacul(): ?bool
  769.     {
  770.         return $this->iSflagCalacul;
  771.     }
  773.     public function setISflagCalacul(bool $iSflagCalacul): self
  774.     {
  775.         $this->iSflagCalacul = $iSflagCalacul;
  777.         return $this;
  778.     }
  780. public function __toString()
  781. {
  782.     return $this->getIdAg()->getNomAg();
  783. }
  785. public function getCaisseLocalite(): ?string
  786. {
  787.     return $this->caisse_localite;
  788. }
  790. public function setCaisseLocalite(?string $caisse_localite): self
  791. {
  792.     $this->caisse_localite = $caisse_localite;
  794.     return $this;
  795. }
  797. /**
  798.  * @return Collection<int, Reception>
  799.  */
  800. public function getReceptions(): Collection
  801. {
  802.     return $this->receptions;
  803. }
  805. public function addReception(Reception $reception): self
  806. {
  807.     if (!$this->receptions->contains($reception)) {
  808.         $this->receptions[] = $reception;
  809.         $reception->setUser($this);
  810.     }
  812.     return $this;
  813. }
  815. public function removeReception(Reception $reception): self
  816. {
  817.     if ($this->receptions->removeElement($reception)) {
  818.         // set the owning side to null (unless already changed)
  819.         if ($reception->getUser() === $this) {
  820.             $reception->setUser(null);
  821.         }
  822.     }
  824.     return $this;
  825. }
  827. /**
  828.  * @return Collection<int, TmpConteneurReception>
  829.  */
  830. public function getTmpConteneurReceptions(): Collection
  831. {
  832.     return $this->tmpConteneurReceptions;
  833. }
  835. public function addTmpConteneurReception(TmpConteneurReception $tmpConteneurReception): self
  836. {
  837.     if (!$this->tmpConteneurReceptions->contains($tmpConteneurReception)) {
  838.         $this->tmpConteneurReceptions[] = $tmpConteneurReception;
  839.         $tmpConteneurReception->setUser($this);
  840.     }
  842.     return $this;
  843. }
  845. public function removeTmpConteneurReception(TmpConteneurReception $tmpConteneurReception): self
  846. {
  847.     if ($this->tmpConteneurReceptions->removeElement($tmpConteneurReception)) {
  848.         // set the owning side to null (unless already changed)
  849.         if ($tmpConteneurReception->getUser() === $this) {
  850.             $tmpConteneurReception->setUser(null);
  851.         }
  852.     }
  854.     return $this;
  855. }
  857. /**
  858.  * @return Collection<int, TmpReception>
  859.  */
  860. public function getTmpReceptions(): Collection
  861. {
  862.     return $this->tmpReceptions;
  863. }
  865. public function addTmpReception(TmpReception $tmpReception): self
  866. {
  867.     if (!$this->tmpReceptions->contains($tmpReception)) {
  868.         $this->tmpReceptions[] = $tmpReception;
  869.         $tmpReception->setUser($this);
  870.     }
  872.     return $this;
  873. }
  875. public function removeTmpReception(TmpReception $tmpReception): self
  876. {
  877.     if ($this->tmpReceptions->removeElement($tmpReception)) {
  878.         // set the owning side to null (unless already changed)
  879.         if ($tmpReception->getUser() === $this) {
  880.             $tmpReception->setUser(null);
  881.         }
  882.     }
  884.     return $this;
  885. }
  889. }