src/Entity/User.php line 25

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 App\Entity\Attachement;
  9. use App\Entity\Attribution;
  10. use App\Entity\Commande;
  11. use App\Entity\CommandeFournisseur;
  12. use App\Entity\CommandePrestataire;
  13. use App\Entity\Devis;
  14. use App\Entity\Facture;
  15. use App\Entity\FactureFournisseur;
  16. use App\Entity\FacturePrestataire;
  17. use Symfony\Component\Security\Core\User\UserInterface;
  19. /**
  20.  * User
  21.  *
  22.  * @ORM\Table(name="users")
  23.  * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
  24.  */
  25. class User implements UserInterface
  26. {
  27.     /**
  28.      * @ORM\Id()
  29.      * @ORM\GeneratedValue()
  30.      * @ORM\Column(type="integer")
  31.      */
  32.     private $id;
  34.     /**
  35.      * @var string
  36.      *
  37.      * @ORM\Column(name="username", type="string", length=75, unique=true, nullable=true)
  38.      */
  39.     private $username;
  41.     /**
  42.      * @var string
  43.      *
  44.      * @ORM\Column(name="nom", type="string", length=75)
  45.      */
  46.     private $nom;
  48.     /**
  49.      * @var string
  50.      *
  51.      * @ORM\Column(name="prenom", type="string", length=75)
  52.      */
  53.     private $prenom;
  55.     /**
  56.      * @var string
  57.      *
  58.      * @ORM\Column(name="email", type="string", length=75, unique=true)
  59.      */
  60.     private $email;
  62.     /**
  63.      * @var string
  64.      *
  65.      * @ORM\Column(name="password", type="string", length=255, nullable=true)
  66.      */
  67.     protected $password;
  69.     /**
  70.      * @ORM\Column(type="string", length=255, nullable=true)
  71.      */
  72.     private $telephone;
  74.     /**
  75.      * @ORM\Column(type="string", length=255, nullable=true, unique=true)
  76.      */
  77.     private $mobile;
  79.     /**
  80.      * @ORM\Column(name="roles", type="array")
  81.      */
  82.     private $roles = array();
  84.     /**
  85.      * @var bool
  86.      *
  87.      * @ORM\Column(name="isActive", type="boolean")
  88.      */
  89.     private $isActive;
  91.     /**
  92.      * @var string
  93.      * @ORM\Column(name="token", type="string", length=64, nullable=true)
  94.      */
  95.     private $token;
  97.     /**
  98.      * @var date
  99.      * @ORM\Column(name="validity", type="datetime")
  100.      */
  101.     private $validity;
  103.     /**
  104.      * @var float
  105.      * @ORM\Column(name="portefeuille", type="float", nullable=true)
  106.      */
  107.     private $portefeuille;
  109.     /**
  110.      * @ORM\ManyToOne(targetEntity="App\Entity\UserEntity")
  111.      * @ORM\JoinColumn(nullable=false)
  112.      */
  113.     private $userEntity;
  115.     /**
  116.      * @var Attribution[]
  117.      * @ORM\OneToMany(targetEntity="App\Entity\Attribution", mappedBy="user")
  118.      */
  119.     private $attributions;
  121.     /**
  122.      * @ORM\OneToMany(targetEntity="App\Entity\Commande", mappedBy="user")
  123.      */
  124.     private $commandes;
  126.     /**
  127.      * @ORM\OneToMany(targetEntity="App\Entity\CommandeFournisseur", mappedBy="user")
  128.      */
  129.     private $commandeFournisseur;
  131.     /**
  132.      * @ORM\OneToMany(targetEntity="App\Entity\CommandePrestataire", mappedBy="user")
  133.      */
  134.     private $commandePrestataire;
  136.     /**
  137.      * @ORM\OneToMany(targetEntity="App\Entity\FactureFournisseur", mappedBy="user")
  138.      */
  139.     private $factureFournisseur;
  141.     /**
  142.      * @ORM\OneToMany(targetEntity="App\Entity\FacturePrestataire", mappedBy="user")
  143.      */
  144.     private $facturePrestataire;
  146.     /**
  147.      * @ORM\OneToMany(targetEntity="App\Entity\Devis", mappedBy="user")
  148.      */
  149.     private $devis;
  151.     /**
  152.      * @ORM\OneToMany(targetEntity="App\Entity\Attachement", mappedBy="user")
  153.      */
  154.     private $attachements;
  156.     /**
  157.      * @ORM\OneToMany(targetEntity="App\Entity\Facture", mappedBy="user")
  158.      */
  159.     private $factures;
  161.     /**
  162.      * @ORM\OneToMany(targetEntity="App\Entity\Organisme", mappedBy="user")
  163.      */
  164.     private $organismes;
  166.     /**
  167.      * @ORM\OneToMany(targetEntity="App\Entity\Contact", mappedBy="user")
  168.      */
  169.     private $contacts;
  171.     /**
  172.      * @ORM\OneToMany(targetEntity=DataView::class, mappedBy="owner", orphanRemoval=true)
  173.      * @ORM\OrderBy({"id" = "ASC"})
  174.      */
  175.     private $dataViews;
  177.     /**
  178.      * @ORM\ManyToOne(targetEntity=Entite::class, inversedBy="users")
  179.      */
  180.     private $entite;
  182.     /**
  183.      * @ORM\OneToMany(targetEntity=UserArticle::class, mappedBy="user")
  184.      */
  185.     private $userArticles;
  187.     /**
  188.      * @ORM\OneToMany(targetEntity=AvancementCommande::class, mappedBy="editor")
  189.      */
  190.     private $avancementCommandes;
  192.     /**
  193.      * @ORM\OneToMany(targetEntity=AvancementCommandeFournisseur::class, mappedBy="editor")
  194.      */
  195.     private $avancementCommandeFournisseurs;
  197.     /**
  198.      * @ORM\OneToMany(targetEntity=Parametre::class, mappedBy="owner")
  199.      */
  200.     private $parametres;
  202.     /**
  203.      * @ORM\Column(type="bigint", nullable=true)
  204.      */
  205.     private $lastConnexionAt;
  207.     public function getRolesForm($role)
  208.     {
  209.         if ($role[0] == 'ROLE_SUPER_SUDALYS') {
  210.             $roles = [
  211.                      'Administrateur' => 'ROLE_ADMIN',
  212.                      'Utilisateur Sudalys' => 'ROLE_SUDALYS',
  213.                      'Super Admin Sudalys' => 'ROLE_SUPER_SUDALYS',
  214.                      'Administrif Sudalys' => 'ROLE_SUDALYS_ADMINISTRATIF'
  215.             ];
  216.         } elseif ($role[0] == 'ROLE_SUDALYS_ADMINISTRATIF') {
  217.             $roles = [
  218.                     'Administrateur' => 'ROLE_ADMIN',
  219.                     'Utilisateur Sudalys' => 'ROLE_SUDALYS',
  220.                     'Administrif Sudalys' => 'ROLE_SUDALYS_ADMINISTRATIF'];
  221.         } elseif ($role[0] == 'ROLE_SUDALYS') {
  222.             $roles = [
  223.                 'Utilisateur Sudalys' => 'ROLE_SUDALYS'
  224.             ];
  225.         }
  226.         return $roles;
  227.     }
  229.     public function __construct()
  230.     {
  231.         $this->isActive = true;
  232.         $this->attributions = new ArrayCollection();
  233.         $this->commandes = new ArrayCollection();
  234.         $this->commandeFournisseur = new ArrayCollection();
  235.         $this->commandePrestataire= new ArrayCollection();
  236.         $this->factureFournisseur = new ArrayCollection();
  237.         $this->facturePrestataire = new ArrayCollection();
  238.         $this->devis = new ArrayCollection();
  239.         $this->attachements = new ArrayCollection();
  240.         $this->factures = new ArrayCollection();
  241.         $this->organismes = new ArrayCollection();
  242.         $this->contacts = new ArrayCollection();
  243.         $this->dataViews = new ArrayCollection();
  244.         $this->userArticles = new ArrayCollection();
  245.         $this->avancementCommandes = new ArrayCollection();
  246.         $this->avancementCommandeFournisseurs = new ArrayCollection();
  247.         $this->parametres = new ArrayCollection();
  248.     }
  250.     public function __toString()
  251.     {
  252.         return $this->prenom . " " . $this->nom;
  253.     }
  254.     public function getAffaires()
  255.     {
  256.         $affaires = [];
  257.         $attributions = $this->getAttributions();
  258.         foreach ($attributions as $attribution) {
  259.             if ($attribution->getAffaire()->getArchivedAt() === null) {
  260.                 array_push($affaires, $attribution->getAffaire());
  261.             }
  262.         }
  263.         return $affaires;
  264.     }
  266.     /**
  267.      * Get id
  268.      *
  269.      * @return int
  270.      */
  271.     public function getId()
  272.     {
  273.         return $this->id;
  274.     }
  276.     /**
  277.      * Set username
  278.      *
  279.      * @param string $username
  280.      *
  281.      * @return User
  282.      */
  283.     public function setUsername($username)
  284.     {
  285.         $this->username = $username;
  287.         return $this;
  288.     }
  290.     /**
  291.      * Get username
  292.      *
  293.      * @return string
  294.      */
  295.     public function getUsername()
  296.     {
  297.         return $this->username;
  298.     }
  300.     /**
  301.      * Set password
  302.      *
  303.      * @param string $password
  304.      *
  305.      * @return User
  306.      */
  307.     public function setPassword($password)
  308.     {
  309.         $this->password = $password;
  311.         return $this;
  312.     }
  314.     public function getTelephone()
  315.     {
  316.         return $this->telephone;
  317.     }
  319.     public function setTelephone($telephone)
  320.     {
  321.         $this->telephone = $telephone;
  323.         return $this;
  324.     }
  326.     public function getMobile()
  327.     {
  328.         return $this->mobile;
  329.     }
  331.     public function setMobile($mobile)
  332.     {
  333.         $this->mobile = $mobile;
  335.         return $this;
  336.     }
  338.     /**
  339.      * Get password
  340.      *
  341.      * @return string
  342.      */
  343.     public function getPassword()
  344.     {
  345.         return $this->password;
  346.     }
  348.     /**
  349.      * Set email
  350.      *
  351.      * @param string $email
  352.      *
  353.      * @return User
  354.      */
  355.     public function setEmail($email)
  356.     {
  357.         $this->email = $email;
  359.         return $this;
  360.     }
  362.     /**
  363.      * Get email
  364.      *
  365.      * @return string
  366.      */
  367.     public function getEmail()
  368.     {
  369.         return $this->email;
  370.     }
  372.     /**
  373.      * Set isActive
  374.      *
  375.      * @param boolean $isActive
  376.      *
  377.      * @return User
  378.      */
  379.     public function setIsActive($isActive)
  380.     {
  381.         $this->isActive = $isActive;
  383.         return $this;
  384.     }
  386.     /**
  387.      * Get isActive
  388.      *
  389.      * @return bool
  390.      */
  391.     public function getIsActive()
  392.     {
  393.         return $this->isActive;
  394.     }
  396.     public function getSalt()
  397.     {
  398.         // you *may* need a real salt depending on your encoder
  399.         // see section on salt below
  400.         return null;
  401.     }
  403.     public function eraseCredentials()
  404.     {
  405.         $this->plainPassword = null;
  406.     }
  408.     public function getRoles()
  409.     {
  410.         return $this->roles;
  411.     }
  413.     /**
  414.      * Set roles
  415.      *
  416.      * @param array $roles
  417.      *
  418.      * @return User
  419.      */
  420.     public function setRoles($roles)
  421.     {
  422.         $this->roles = $roles;
  424.         return $this;
  425.     }
  427.     /**
  428.      * Set nom
  429.      *
  430.      * @param string $nom
  431.      *
  432.      * @return User
  433.      */
  434.     public function setNom($nom)
  435.     {
  436.         $this->nom = $nom;
  438.         return $this;
  439.     }
  441.     /**
  442.      * Get nom
  443.      *
  444.      * @return string
  445.      */
  446.     public function getNom()
  447.     {
  448.         return $this->nom;
  449.     }
  451.     /**
  452.      * Set prenom
  453.      *
  454.      * @param string $prenom
  455.      *
  456.      * @return User
  457.      */
  458.     public function setPrenom($prenom)
  459.     {
  460.         $this->prenom = $prenom;
  462.         return $this;
  463.     }
  465.     /**
  466.      * Get prenom
  467.      *
  468.      * @return string
  469.      */
  470.     public function getPrenom()
  471.     {
  472.         return $this->prenom;
  473.     }
  475.     /**
  476.      * Set userEntity
  477.      *
  478.      * @param UserEntity $userEntity
  479.      *
  480.      * @return User
  481.      */
  482.     public function setUserEntity($userEntity)
  483.     {
  484.         $this->userEntity = $userEntity;
  486.         return $this;
  487.     }
  489.     /**
  490.      * Get userEntity
  491.      *
  492.      * @return UserEntity
  493.      */
  494.     public function getUserEntity()
  495.     {
  496.         return $this->userEntity;
  497.     }
  499.     /**
  500.      * Set token
  501.      *
  502.      * @param string $token
  503.      *
  504.      * @return User
  505.      */
  506.     public function setToken($token)
  507.     {
  508.         $this->token = $token;
  510.         return $this;
  511.     }
  513.     /**
  514.      * Get token
  515.      *
  516.      * @return string
  517.      */
  518.     public function getToken()
  519.     {
  520.         return $this->token;
  521.     }
  523.     /**
  524.      * Set validity
  525.      *
  526.      * @param \DateTime $validity
  527.      *
  528.      * @return User
  529.      */
  530.     public function setValidity($validity)
  531.     {
  532.         $this->validity = $validity;
  534.         return $this;
  535.     }
  537.     /**
  538.      * Get validity
  539.      *
  540.      * @return \DateTime
  541.      */
  542.     public function getValidity()
  543.     {
  544.         return $this->validity;
  545.     }
  547.     /**
  548.      * Set portefeuille
  549.      *
  550.      * @param float $portefeuille
  551.      *
  552.      * @return User
  553.      */
  554.     public function setPortefeuille($portefeuille)
  555.     {
  556.         $this->portefeuille = $portefeuille;
  558.         return $this;
  559.     }
  561.     /**
  562.      * Get portefeuille
  563.      *
  564.      * @return float
  565.      */
  566.     public function getPortefeuille()
  567.     {
  568.         return $this->portefeuille;
  569.     }
  571.     /**
  572.      * @return Collection|Attribution[]
  573.      */
  574.     public function getAttributions()
  575.     {
  576.         return $this->attributions;
  577.     }
  579.     public function addAttributions(Attribution $attribution)
  580.     {
  581.         if (!$this->attributions->contains($attribution)) {
  582.             $this->attributions[] = $attribution;
  583.             $attribution->setUser($this);
  584.         }
  586.         return $this;
  587.     }
  589.     public function removeAttributions(Attribution $attribution)
  590.     {
  591.         if ($this->attributions->contains($attribution)) {
  592.             $this->attributions->removeElement($attribution);
  593.             // set the owning side to null (unless already changed)
  594.             if ($attribution->getUser() === $this) {
  595.                 $attribution->setUser(null);
  596.             }
  597.         }
  599.         return $this;
  600.     }
  602.     /**
  603.      * @return Collection|Commande[]
  604.      */
  605.     public function getCommandes()
  606.     {
  607.         return $this->commandes;
  608.     }
  610.     public function addCommande(Commande $commande)
  611.     {
  612.         if (!$this->commandes->contains($commande)) {
  613.             $this->commandes[] = $commande;
  614.             $commande->setUser($this);
  615.         }
  617.         return $this;
  618.     }
  620.     public function removeCommande(Commande $commande)
  621.     {
  622.         if ($this->commandes->contains($commande)) {
  623.             $this->commandes->removeElement($commande);
  624.             // set the owning side to null (unless already changed)
  625.             if ($commande->getUser() === $this) {
  626.                 $commande->setUser(null);
  627.             }
  628.         }
  630.         return $this;
  631.     }
  633.     /**
  634.      * @return Collection|CommandeFournisseur[]
  635.      */
  636.     public function getCommandeFournisseur()
  637.     {
  638.         return $this->commandeFournisseurs;
  639.     }
  641.     public function addCommandeFournisseur(CommandeFournisseur $commandeFournisseur)
  642.     {
  643.         if (!$this->commandeFournisseur->contains($commandeFournisseur)) {
  644.             $this->commandeFournisseur[] = $commandeFournisseur;
  645.             $commandeFournisseur->setUser($this);
  646.         }
  648.         return $this;
  649.     }
  651.     public function removeCommandeFournisseur(CommandeFournisseur $commandeFournisseur)
  652.     {
  653.         if ($this->commandeFournisseur->contains($commandeFournisseur)) {
  654.             $this->commandeFournisseur->removeElement($commandeFournisseur);
  655.             // set the owning side to null (unless already changed)
  656.             if ($commandeFournisseur->getUser() === $this) {
  657.                 $commandeFournisseur->setUser(null);
  658.             }
  659.         }
  661.         return $this;
  662.     }
  664.     /**
  665.      * @return Collection|CommandePrestataire[]
  666.      */
  667.     public function getCommandePrestataire()
  668.     {
  669.         return $this->commandePrestataire;
  670.     }
  672.     public function addCommandePrestataire(CommandePrestataire $commandePrestataire)
  673.     {
  674.         if (!$this->commandePrestataire->contains($commandePrestataire)) {
  675.             $this->commandePrestataire[] = $commandePrestataire;
  676.             $commandePrestataire->setUser($this);
  677.         }
  679.         return $this;
  680.     }
  682.     public function removeCommandePrestataire(CommandePrestataire $commandePrestataire)
  683.     {
  684.         if ($this->commandePrestataire>contains($commandePrestataire)) {
  685.             $this->commandePrestataire->removeElement($commandePrestataire);
  686.             // set the owning side to null (unless already changed)
  687.             if ($commandePrestataire->getUser() === $this) {
  688.                 $commandePrestataire->setUser(null);
  689.             }
  690.         }
  692.         return $this;
  693.     }
  695.     /**
  696.      * @return Collection|FactureFournisseur[]
  697.      */
  698.     public function getFactureFournisseur()
  699.     {
  700.         return $this->factureFournisseurs;
  701.     }
  703.     public function addFactureFournisseur(FactureFournisseur $factureFournisseur)
  704.     {
  705.         if (!$this->factureFournisseur->contains($factureFournisseur)) {
  706.             $this->factureFournisseur[] = $factureFournisseur;
  707.             $factureFournisseur->setUser($this);
  708.         }
  710.         return $this;
  711.     }
  713.     public function removeFactureFournisseur(FactureFournisseur $factureFournisseur)
  714.     {
  715.         if ($this->factureFournisseur->contains($factureFournisseur)) {
  716.             $this->factureFournisseur->removeElement($factureFournisseur);
  717.             // set the owning side to null (unless already changed)
  718.             if ($factureFournisseur->getUser() === $this) {
  719.                 $factureFournisseur->setUser(null);
  720.             }
  721.         }
  723.         return $this;
  724.     }
  726.     /**
  727.      * @return Collection|FacturePrestataire[]
  728.      */
  729.     public function getFacturePrestataire()
  730.     {
  731.         return $this->facturePrestataire;
  732.     }
  734.     public function addFacturePrestataire(FacturePrestataire $facturePrestataire)
  735.     {
  736.         if (!$this->facturePrestataire->contains($facturePrestataire)) {
  737.             $this->facturePrestataire[] = $facturePrestataire;
  738.             $facturePrestataire->setUser($this);
  739.         }
  741.         return $this;
  742.     }
  744.     public function removeFacturePrestataire(FacturePrestataire $facturePrestataire)
  745.     {
  746.         if ($this->facturePrestataire->contains($facturePrestataire)) {
  747.             $this->facturePrestataire->removeElement($facturePrestataire);
  748.             // set the owning side to null (unless already changed)
  749.             if ($facturePrestataire->getUser() === $this) {
  750.                 $facturePrestataire->setUser(null);
  751.             }
  752.         }
  754.         return $this;
  755.     }
  757.     /**
  758.      * @return Collection|Devis[]
  759.      */
  760.     public function getDevis()
  761.     {
  762.         return $this->devis;
  763.     }
  765.     public function addDevi(Devis $devi)
  766.     {
  767.         if (!$this->devis->contains($devi)) {
  768.             $this->devis[] = $devi;
  769.             $devi->setUser($this);
  770.         }
  772.         return $this;
  773.     }
  775.     public function removeDevi(Devis $devi)
  776.     {
  777.         if ($this->devis->contains($devi)) {
  778.             $this->devis->removeElement($devi);
  779.             // set the owning side to null (unless already changed)
  780.             if ($devi->getUser() === $this) {
  781.                 $devi->setUser(null);
  782.             }
  783.         }
  785.         return $this;
  786.     }
  788.     /**
  789.      * @return Collection|Attachement[]
  790.      */
  791.     public function getAttachements()
  792.     {
  793.         return $this->attachements;
  794.     }
  796.     public function addAttachements(Attachement $attachement)
  797.     {
  798.         if (!$this->attachements->contains($attachement)) {
  799.             $this->attachements[] = $attachement;
  800.             $attachement->setUser($this);
  801.         }
  803.         return $this;
  804.     }
  806.     public function removeAttachements(Attachement $attachement)
  807.     {
  808.         if ($this->attachements->contains($attachement)) {
  809.             $this->attachements->removeElement($attachement);
  810.             // set the owning side to null (unless already changed)
  811.             if ($attachement->getUser() === $this) {
  812.                 $attachement->setUser(null);
  813.             }
  814.         }
  816.         return $this;
  817.     }
  819.     /**
  820.      * @return Collection|Facture[]
  821.      */
  822.     public function getFactures()
  823.     {
  824.         return $this->factures;
  825.     }
  827.     public function addFacture(Facture $facture)
  828.     {
  829.         if (!$this->factures->contains($facture)) {
  830.             $this->factures[] = $facture;
  831.             $facture->setUser($this);
  832.         }
  834.         return $this;
  835.     }
  837.     public function removeFacture(Facture $facture)
  838.     {
  839.         if ($this->factures->contains($facture)) {
  840.             $this->factures->removeElement($facture);
  841.             // set the owning side to null (unless already changed)
  842.             if ($facture->getUser() === $this) {
  843.                 $facture->setUser(null);
  844.             }
  845.         }
  847.         return $this;
  848.     }
  850.     /**
  851.      * @return Collection|Organisme[]
  852.      */
  853.     public function getOrganismes()
  854.     {
  855.         return $this->organismes;
  856.     }
  858.     /**
  859.      * @return Collection|DataView[]
  860.      */
  861.     public function getDataViews(): Collection
  862.     {
  863.         return $this->dataViews;
  864.     }
  866.     public function addDataView(DataView $dataView): self
  867.     {
  868.         if (!$this->dataViews->contains($dataView)) {
  869.             $this->dataViews[] = $dataView;
  870.             $dataView->setOwner($this);
  871.         }
  873.         return $this;
  874.     }
  876.     public function removeDataView(DataView $dataView): self
  877.     {
  878.         if ($this->dataViews->contains($dataView)) {
  879.             $this->dataViews->removeElement($dataView);
  880.             // set the owning side to null (unless already changed)
  881.             if ($dataView->getOwner() === $this) {
  882.                 $dataView->setOwner(null);
  883.             }
  884.         }
  886.         return $this;
  887.     }
  889.     public function getEntite(): ?Entite
  890.     {
  891.         return $this->entite;
  892.     }
  894.     public function setEntite(?Entite $entite): self
  895.     {
  896.         $this->entite = $entite;
  898.         return $this;
  899.     }
  901.     /**
  902.      * @return Collection|UserArticle[]
  903.      */
  904.     public function getUserArticles(): Collection
  905.     {
  906.         return $this->userArticles;
  907.     }
  909.     public function addUserArticle(UserArticle $userArticle): self
  910.     {
  911.         if (!$this->userArticles->contains($userArticle)) {
  912.             $this->userArticles[] = $userArticle;
  913.             $userArticle->setUser($this);
  914.         }
  916.         return $this;
  917.     }
  919.     public function removeUserArticle(UserArticle $userArticle): self
  920.     {
  921.         if ($this->userArticles->removeElement($userArticle)) {
  922.             // set the owning side to null (unless already changed)
  923.             if ($userArticle->getUser() === $this) {
  924.                 $userArticle->setUser(null);
  925.             }
  926.         }
  928.         return $this;
  929.     }
  931.     /**
  932.      * @return Collection|AvancementCommande[]
  933.      */
  934.     public function getAvancementCommandes(): Collection
  935.     {
  936.         return $this->avancementCommandes;
  937.     }
  939.     public function addAvancementCommande(AvancementCommande $avancementCommande): self
  940.     {
  941.         if (!$this->avancementCommandes->contains($avancementCommande)) {
  942.             $this->avancementCommandes[] = $avancementCommande;
  943.             $avancementCommande->setEditor($this);
  944.         }
  946.         return $this;
  947.     }
  949.     public function removeAvancementCommande(AvancementCommande $avancementCommande): self
  950.     {
  951.         if ($this->avancementCommandes->removeElement($avancementCommande)) {
  952.             // set the owning side to null (unless already changed)
  953.             if ($avancementCommande->getEditor() === $this) {
  954.                 $avancementCommande->setEditor(null);
  955.             }
  956.         }
  958.         return $this;
  959.     }
  961.     /**
  962.      * @return Collection|AvancementCommandeFournisseur[]
  963.      */
  964.     public function getAvancementCommandeFournisseurs(): Collection
  965.     {
  966.         return $this->avancementCommandeFournisseurs;
  967.     }
  969.     public function addAvancementCommandeFournisseur(AvancementCommandeFournisseur $avancementCommandeFournisseur): self
  970.     {
  971.         if (!$this->avancementCommandeFournisseurs->contains($avancementCommandeFournisseur)) {
  972.             $this->avancementCommandeFournisseurs[] = $avancementCommandeFournisseur;
  973.             $avancementCommandeFournisseur->setEditor($this);
  974.         }
  976.         return $this;
  977.     }
  979.     public function removeAvancementCommandeFournisseur(AvancementCommandeFournisseur $avancementCommandeFournisseur): self
  980.     {
  981.         if ($this->avancementCommandeFournisseurs->removeElement($avancementCommandeFournisseur)) {
  982.             // set the owning side to null (unless already changed)
  983.             if ($avancementCommandeFournisseur->getEditor() === $this) {
  984.                 $avancementCommandeFournisseur->setEditor(null);
  985.             }
  986.         }
  988.         return $this;
  989.     }
  991.     /**
  992.      * @return Collection|Parametre[]
  993.      */
  994.     public function getParametres(): Collection
  995.     {
  996.         return $this->parametres;
  997.     }
  999.     public function addParametre(Parametre $parametre): self
  1000.     {
  1001.         if (!$this->parametres->contains($parametre)) {
  1002.             $this->parametres[] = $parametre;
  1003.             $parametre->setOwner($this);
  1004.         }
  1006.         return $this;
  1007.     }
  1009.     public function removeParametre(Parametre $parametre): self
  1010.     {
  1011.         if ($this->parametres->removeElement($parametre)) {
  1012.             // set the owning side to null (unless already changed)
  1013.             if ($parametre->getOwner() === $this) {
  1014.                 $parametre->setOwner(null);
  1015.             }
  1016.         }
  1018.         return $this;
  1019.     }
  1021.     public function getLastConnexionAt(): ?string
  1022.     {
  1023.         return $this->lastConnexionAt;
  1024.     }
  1026.     public function setLastConnexionAt(?string $lastConnexionAt): self
  1027.     {
  1028.         $this->lastConnexionAt = $lastConnexionAt;
  1030.         return $this;
  1031.     }
  1032. }