user.php

<?php

namespace App\Entity;

use Cocur\Slugify\Slugify;
use Doctrine\ORM\Mapping as ORM;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\ArrayCollection;
use Serializable;
use Symfony\Component\Validator\Constraints as Assert;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;

/**
 * @ORM\Entity(repositoryClass="App\Repository\UserRepository")
 * @ORM\HasLifecycleCallbacks()
 * @UniqueEntity(
 *  fields = {"email"},
 *  message = "Cette adresse email a déjà été utilisée."
 * )
 */
class User implements UserInterface
{
    /**
     * @ORM\Id()
     * @ORM\GeneratedValue()
     * @ORM\Column(type="integer")
     */
    private $id;

    /**
     * Adresse email de l'utilisateur
     * @ORM\Column(type="string", length=180, unique=true)
     * @Assert\NotBlank()
     * @Assert\Email(message="Veuillez renseigner un email valide")
     */
    private $email;

    /**
     * Rôles de l'utilisateur
     * @ORM\Column(type="json")
     */
    private $roles = [];

    /**
     * Mot de passe de l'utilisateur
     * @var string The hashed password
     * @ORM\Column(type="string")
     * @Assert\Length(
     *      min = 4,
     *      minMessage = "Votre mot de passe doit contenir au moins {{limit}}",
     * )
     */
    private $password;

    /**
     * Confirmation du mot de passe de l'utilisateur
     * @Assert\EqualTo(propertyPath="password", message="Vous n'avez pas correctement confirmé votre mot de passe")
     */
    public $passwordConfirm;

    /**
     * Nom de l'utilisateur
     * @ORM\Column(type="string", length=255)
     * @Assert\Length(
     *      min = 1,
     *      max = 20,
     *      minMessage = "Votre nom doit contenir au moins {{limit}} caractère",
     *      maxMessage = "Votre nom ne peut pas contenir plus de {{limit}} caractères"
     * )
     * @Assert\NotBlank
     */
    private $nom;

    /**
     * Prénom de l'utilisateur
     * @ORM\Column(type="string", length=255)
     * @Assert\Length(
     *      min = 1,
     *      max = 20,
     *      minMessage = "Votre prénom doit contenir au moins {{limit}} caractère",
     *      maxMessage = "Votre prénom ne peut pas contenir plus de {{limit}} caractères"
     * )
     * @Assert\NotBlank
     */
    private $prenom;

    /**
     * Slug de l'utilisateur
     * @ORM\Column(type="string", length=255)
     */
    private $slug;

    /**
     * Absences de l'utilisateur
     * @ORM\OneToMany(targetEntity="App\Entity\Absence", mappedBy="user", orphanRemoval=true, cascade={"persist", "remove"})
     */
    private $absences;

    /**
     * Service de l'utilisateur
     * @ORM\ManyToOne(targetEntity="App\Entity\GroupeValidateurs", inversedBy="users")
     * @ORM\JoinColumn(nullable=true)
     */
    private $groupe;

    /**
     * Soldes des congés de l'utilisateur
     * @ORM\OneToMany(targetEntity="App\Entity\SoldeConges", mappedBy="user", orphanRemoval=true, fetch="EAGER", cascade={"persist","remove"})
     */
    private $soldeConges;

    /**
     * Feuille de congés de l'utilisateur
     * @ORM\OneToOne(targetEntity="App\Entity\FeuilleConge", inversedBy="user", cascade={"persist", "remove"})
     */
    private $feuilleConge;

    /**
     * Avatar de l'utilisateur
     * @ORM\OneToOne(targetEntity="App\Entity\Avatar", mappedBy="user", cascade={"persist", "remove"})
     */
    private $avatar;

    /**
     * Profession de l'utilisateur
     * @ORM\Column(type="string", length=255, nullable = true)
     * @Assert\NotBlank
     */
    private $profession;

    /**
     * Date de demande de réinitialisation du mot de passe de l'utilisateur
     * @ORM\Column(type="datetime", nullable=true)
     */
    private $passwordRequestedAt;

    /**
     * Token de réinitialisation du mot de passe de l'utilisateur
     * @ORM\Column(type="string", length=255, nullable=true)
     */
    private $token;

    /**
     * Ordres de mission de l'utilisateur
     * @ORM\OneToMany(targetEntity="App\Entity\OrdreMission", mappedBy="user")
     */
    private $ordreMissions;

    /**
     * Signature de l'utilisateur
     * @ORM\OneToOne(targetEntity="App\Entity\Signature", mappedBy="user", cascade={"persist", "remove"})
     */
    private $signature;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\Validateur", mappedBy="validateur", orphanRemoval=true, cascade={"persist"})
     */
    private $validateurs;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\AbsencesPrevision", mappedBy="user", orphanRemoval=true)
     */
    private $absencesPrevisions;

    /**
     * @ORM\Column(type="string", length=255)
     */
    private $hexColor;



    /**
     * @ORM\Column(type="boolean")
     */
    private $autoValidation = false;

    /**
     * @Assert\Expression(
     *     "not (this.getAutovalidation() == true and this.getSuppleant() != null)",
     *     message="Vous devez choisir entre l'auto-validation et avoir un suppléant"
     * )
     * @ORM\ManyToOne(targetEntity="App\Entity\User", inversedBy="delegues")
     */
    private $suppleant;

    /**
     * @ORM\OneToMany(targetEntity="App\Entity\User", mappedBy="suppleant")
     */
    private $delegues;

    /**
     * @ORM\Column(type="boolean")
     */
    private $activeMails = true;

    /**
     * @ORM\ManyToOne(targetEntity="App\Entity\Entreprise", inversedBy="users")
     * @ORM\JoinColumn(nullable=false)
     */
    private $entreprise;


    public function __construct()
    {
        $this->absences = new ArrayCollection();
        $this->soldeConges = new ArrayCollection();
        $this->ordreMissions = new ArrayCollection();
        $this->validateurs = new ArrayCollection();
        $this->absencesPrevisions = new ArrayCollection();
        $this->delegues = new ArrayCollection();
    }

    /**
     * Permet d'initialiser le slug
     *
     * @ORM\PrePersist
     * @ORM\PreUpdate
     *
     * @return void
     */
    public function initializeSlug()
    {
        if (empty($this->slug)) {
            $slugify = new Slugify();
            $this->slug =  $slugify->slugify($this->prenom . ' ' . $this->nom);
        }
    }

    /**
     * Initialiser l'utilisateur
     *
     * @ORM\PrePersist
     *
     * @return void
     */
    public function initializeUser()
    {
        if(empty($this->hexColor))
        {
            $this->hexColor = $this->rand_color();
        }
    }

    public function getId(): ?int
    {
        return $this->id;
    }

    /**
     * Retourne l'adresse email de l'utilisateur
     *
     * @return string|null
     */
    public function getEmail(): ?string
    {
        return $this->email;
    }

    /**
     * Insère l'adresse email de l'utilisateur
     *
     * @param string $email
     * @return self
     */
    public function setEmail(string $email): self
    {
        $this->email = $email;

        return $this;
    }

    /**
     * A visual identifier that represents this user.
     *
     * @see UserInterface
     */
    public function getUsername(): string
    {
        return (string) $this->email;
    }

    /**
     * @see UserInterface
     */
    public function getRoles(): array
    {
        $roles = $this->roles;
        // guarantee every user at least has ROLE_USER
        $roles[] = 'ROLE_USER';

        return array_unique($roles);
    }

    /**
     * Insère les rôles d'un utilisateur
     *
     * @param array $roles
     * @return self
     */
    public function setRoles(array $roles): self
    {
        $this->roles = $roles;

        return $this;
    }

    /**
     * Ajoute un rôle à l'utilisateur
     *
     * @param string $role
     * @return self
     */
    public function addRole($role)
    {
        if (!in_array($role, $this->roles)) {
            array_push($this->roles, $role);
        }

        return $this;
    }

    /**
     * Vérifie si l'utilisateur possède le rôle passé en paramètre
     *
     * @param string $role
     * @return boolean
     */
    public function hasRole($role)
    {
        return in_array(strtoupper($role), $this->getRoles(), true);
    }

    /**
     * Supprime un rôle dans la liste des rôles de l'utilisateur
     *
     * @param string $role
     * @return self
     */
    public function removeRole($role)
    {
        if (false !== $key = array_search(strtoupper($role), $this->roles, true)) {
            unset($this->roles[$key]);
            $this->roles = array_values($this->roles);
        }

        return $this;
    }

    /**
     * @see UserInterface
     */
    public function getPassword(): string
    {
        return (string) $this->password;
    }

    /**
     * Insère le mot de passe de l'utilisateur
     *
     * @param string $password
     * @return self
     */
    public function setPassword(string $password): self
    {
        $this->password = $password;

        return $this;
    }

    /**
     * @see UserInterface
     */
    public function getSalt()
    {
        // not needed when using the "bcrypt" algorithm in security.yaml
    }

    /**
     * @see UserInterface
     */
    public function eraseCredentials()
    {
        // If you store any temporary, sensitive data on the user, clear it here
        // $this->plainPassword = null;
    }

    /**
     * Retourne le nom de l'utilisateur
     *
     * @return string|null
     */
    public function getNom(): ?string
    {
        return $this->nom;
    }

    /**
     * Insère le nom de l'utilisateur
     *
     * @param string $nom
     * @return self
     */
    public function setNom(string $nom): self
    {
        $this->nom = $nom;

        return $this;
    }

    /**
     * Retourne le prénom de l'utilisateur
     *
     * @return string|null
     */
    public function getPrenom(): ?string
    {
        return $this->prenom;
    }

    /**
     * Insère le prénom de l'utilisateur
     *
     * @param string $prenom
     * @return self
     */
    public function setPrenom(string $prenom): self
    {
        $this->prenom = $prenom;

        return $this;
    }

    /**
     * Retourne le slug de l'utilisateur
     *
     * @return string|null
     */
    public function getSlug(): ?string
    {
        return $this->slug;
    }

    /**
     * Retourne le slug de l'utilisateur
     *
     * @param string $slug
     * @return self
     */
    public function setSlug(string $slug): self
    {
        $this->slug = $slug;

        return $this;
    }

    /**
     * Retourne la collection d'absences de l'utilisateur
     * @return Collection|Absence[]
     */
    public function getAbsences(): Collection
    {
        return $this->absences;
    }

    /**
     * Ajoute une absence à l'utilisateur
     *
     * @param Absence $absence
     * @return self
     */
    public function addAbsence(Absence $absence): self
    {
        if (!$this->absences->contains($absence)) {
            $this->absences[] = $absence;
            $absence->setUser($this);
        }

        return $this;
    }

    /**
     * Supprime une absence de l'utilisateur
     *
     * @param Absence $absence
     * @return self
     */
    public function removeAbsence(Absence $absence): self
    {
        if ($this->absences->contains($absence)) {
            $this->absences->removeElement($absence);
            // set the owning side to null (unless already changed)
            if ($absence->getUser() === $this) {
                $absence->setUser(null);
            }
        }

        return $this;
    }

    /**
     * Retourne le nom complet de l'utilisateur
     *
     * @return string
     */
    public function getFullname()
    {
        return strtoupper($this->nom) . ' ' . $this->prenom;
    }

    /**
     * Retourne le service de l'utilisateur
     *
     * @return GroupeValidateurs|null
     */
    public function getGroupe(): ?GroupeValidateurs
    {
        return $this->groupe;
    }

    /**
     * Insère le service de l'utilisateur
     *
     * @param GroupeValidateurs|null $groupe
     * @return self
     */
    public function setGroupe(?GroupeValidateurs $groupe): self
    {
        $this->groupe = $groupe;

        return $this;
    }

    /**
     * Retourne une collection de soldes de congés appartenant à l'utilisateur
     * @return Collection|SoldeConges[]
     */
    public function getSoldeConges(): Collection
    {
        return $this->soldeConges;
    }

    /**
     * Ajoute un solde de congé à l'utilisateur
     *
     * @param SoldeConges $soldeConge
     * @return self
     */
    public function addSoldeConge(SoldeConges $soldeConge): self
    {
        if (!$this->soldeConges->contains($soldeConge)) {
            $this->soldeConges[] = $soldeConge;
            $soldeConge->setUser($this);
        }

        return $this;
    }

    /**
     * Décrémente un solde congé d'un utilisateur
     *
     * @param SoldeConges $soldeDec
     * @return self
     */
    public function decrementeSoldeConge(SoldeConges $soldeDec)
    {
        if ($soldeDec->getTypeConge()->getSoldeInitial() != null) {

            foreach ($this->soldeConges as $solde) {
                if ($solde == $soldeDec) {
                    $solde->setSolde($solde->getSolde() - 1);
                }
            }
        }

        return $this;
    }

    /**
     * Supprime un solde congé de l'utilisateur
     *
     * @param SoldeConges $soldeConge
     * @return self
     */
    public function removeSoldeConge(SoldeConges $soldeConge): self
    {
        if ($this->soldeConges->contains($soldeConge)) {
            $this->soldeConges->removeElement($soldeConge);
            // set the owning side to null (unless already changed)
            if ($soldeConge->getUser() === $this) {
                $soldeConge->setUser(null);
            }
        }

        return $this;
    }

    /**
     * Retourne les soldes qui sont actifs ( qui n'ont pas de solde initial égal à null)
     *
     * @return array
     */
    public function getSoldesActif()
    {
        $soldesTypesConge = $this->soldeConges;

        foreach ($soldesTypesConge as $solde) {
            if ($solde->getSolde() == 0) {
                $soldesTypesConge->removeElement($solde);
            }
        }

        return $soldesTypesConge;
    }

    /**
     * Retourne la feuille de congé de l'utilisateur
     *
     * @return FeuilleConge|null
     */
    public function getFeuilleConge(): ?FeuilleConge
    {
        return $this->feuilleConge;
    }

    /**
     * Insère la feuille de congé de l'utilisateur
     *
     * @param FeuilleConge|null $feuilleConge
     * @return self
     */
    public function setFeuilleConge(?FeuilleConge $feuilleConge): self
    {
        $this->feuilleConge = $feuilleConge;

        return $this;
    }

    /**
     * Retourne l'avatar de l'utilisateur
     *
     * @return Avatar|null
     */
    public function getAvatar(): ?Avatar
    {
        return $this->avatar;
    }

    /**
     * Insère l'avatar de l'utilisateur
     *
     * @param Avatar|null $avatar
     * @return self
     */
    public function setAvatar(?Avatar $avatar): self
    {
        $this->avatar = $avatar;

        // set (or unset) the owning side of the relation if necessary
        $newUser = $avatar === null ? null : $this;
        if ($newUser !== $avatar->getUser()) {
            $avatar->setUser($newUser);
        }

        return $this;
    }

    /**
     * Retourne le solde d'heures de l'utilisateur
     *
     * @return string|null
     */
    public function getSoldeHeures()
    {
        foreach ($this->soldeConges as $solde) {
            if ($solde->getTypeConge()->getNom() == "Heures supp") {
                return $this->convertDecimalToTime($solde->getSolde());
            }
        }

        return null;
    }

    /**
     * Converti un décimal en horaire (hh:mm)
     *
     * @param float $decimal
     * @return string
     */
    public function convertDecimalToTime($decimal)
    {
        $heures = floor($decimal);
        $minutes = round(($decimal - $heures) * 60);

        $sHeures = strval($heures);
        $sMinutes = strval($minutes);

        if ($heures < 10) {
            $sHeures = '0' . $heures;
        }

        if ($minutes < 10) {
            $sMinutes = '0' . $minutes;
        }

        $time = $sHeures . ' h ' . $sMinutes;
        return $time;
    }

    /**
     * Retourne la profession d'un utilisateur
     *
     * @return string|null
     */
    public function getProfession(): ?string
    {
        return $this->profession;
    }

    /**
     * Insère la profession d'un utilisateur
     *
     * @param string|null $profession
     * @return self
     */
    public function setProfession(?string $profession): self
    {
        $this->profession = $profession;

        return $this;
    }

    /**
     * Retourne la date de demande de réinitialisation de mot de passe de la part de l'utilisateur
     *
     * @return \DateTimeInterface|null
     */
    public function getPasswordRequestedAt(): ?\DateTimeInterface
    {
        return $this->passwordRequestedAt;
    }

    /**
     * Insère la date de demande de réinitialisation de mot de passe de la part de l'utilisateur
     *
     * @param \DateTimeInterface|null $passwordRequestedAt
     * @return self
     */
    public function setPasswordRequestedAt(?\DateTimeInterface $passwordRequestedAt): self
    {
        $this->passwordRequestedAt = $passwordRequestedAt;

        return $this;
    }

    /**
     * Retourne le token de demande de réinitialisation de mot de passe de la part de l'utilisateur
     *
     * @return string|null
     */
    public function getToken(): ?string
    {
        return $this->token;
    }

    /**
     * Insère le token de demande de réinitialisation de mot de passe de la part de l'utilisateur
     *
     * @param string|null $token
     * @return self
     */
    public function setToken(?string $token): self
    {
        $this->token = $token;

        return $this;
    }

    /**
     * Retourne les ordres de mission de l'utilisateur
     * @return Collection|OrdreMission[]
     */
    public function getOrdreMissions(): Collection
    {
        return $this->ordreMissions;
    }

    /**
     * Ajoute un ordre de mission à l'utilisateur
     *
     * @param OrdreMission $ordreMission
     * @return self
     */
    public function addOrdreMission(OrdreMission $ordreMission): self
    {
        if (!$this->ordreMissions->contains($ordreMission)) {
            $this->ordreMissions[] = $ordreMission;
            $ordreMission->setUser($this);
        }

        return $this;
    }

    /**
     * Supprime un ordre de mission de l'utilisateur
     *
     * @param OrdreMission $ordreMission
     * @return self
     */
    public function removeOrdreMission(OrdreMission $ordreMission): self
    {
        if ($this->ordreMissions->contains($ordreMission)) {
            $this->ordreMissions->removeElement($ordreMission);
            // set the owning side to null (unless already changed)
            if ($ordreMission->getUser() === $this) {
                $ordreMission->setUser(null);
            }
        }

        return $this;
    }

    /**
     * Retourne la signature de l'utilisateur
     *
     * @return Signature|null
     */
    public function getSignature(): ?Signature
    {
        return $this->signature;
    }

    /**
     * Insère la signature de l'utilisateur
     *
     * @param Signature|null $signature
     * @return self
     */
    public function setSignature(?Signature $signature): self
    {
        $this->signature = $signature;

        // set (or unset) the owning side of the relation if necessary
        $newUser = null === $signature ? null : $this;
        if ($signature->getUser() !== $newUser) {
            $signature->setUser($newUser);
        }

        return $this;
    }

    /**
     * @return Collection|Validateur[]
     */
    public function getValidateurs(): Collection
    {
        return $this->validateurs;
    }

    public function addValidateur(Validateur $validateur): self
    {
        if (!$this->validateurs->contains($validateur)) {
            $this->validateurs[] = $validateur;
            $validateur->setValidateur($this);
        }

        return $this;
    }

    public function removeValidateur(Validateur $validateur): self
    {
        if ($this->validateurs->contains($validateur)) {
            $this->validateurs->removeElement($validateur);
            // set the owning side to null (unless already changed)
            if ($validateur->getValidateur() === $this) {
                $validateur->setValidateur(null);
            }
        }

        return $this;
    }

    /**
     * @return Collection|AbsencesPrevision[]
     */
    public function getAbsencesPrevisions(): Collection
    {
        return $this->absencesPrevisions;
    }

    public function addAbsencesPrevision(AbsencesPrevision $absencesPrevision): self
    {
        if (!$this->absencesPrevisions->contains($absencesPrevision)) {
            $this->absencesPrevisions[] = $absencesPrevision;
            $absencesPrevision->setUser($this);
        }

        return $this;
    }

    public function removeAbsencesPrevision(AbsencesPrevision $absencesPrevision): self
    {
        if ($this->absencesPrevisions->contains($absencesPrevision)) {
            $this->absencesPrevisions->removeElement($absencesPrevision);
            // set the owning side to null (unless already changed)
            if ($absencesPrevision->getUser() === $this) {
                $absencesPrevision->setUser(null);
            }
        }

        return $this;
    }

    public function getHexColor(): ?string
    {
        return $this->hexColor;
    }

    public function setHexColor(string $hexColor): self
    {
        $this->hexColor = $hexColor;

        return $this;
    }



    public function getAutoValidation(): ?bool
    {
        return $this->autoValidation;
    }

    public function setAutoValidation(?bool $autoValidation): self
    {
        $this->autoValidation = $autoValidation;

        return $this;
    }

    public function getSuppleant(): ?self
    {
        return $this->suppleant;
    }

    public function setSuppleant(?self $suppleant): self
    {
        $this->suppleant = $suppleant;

        return $this;
    }

    /**
     * @return Collection|self[]
     */
    public function getDelegues(): Collection
    {
        return $this->delegues;
    }

    public function addDelegue(self $delegue): self
    {
        if (!$this->delegues->contains($delegue)) {
            $this->delegues[] = $delegue;
            $delegue->setSuppleant($this);
        }

        return $this;
    }

    public function removeDelegue(self $delegue): self
    {
        if ($this->delegues->contains($delegue)) {
            $this->delegues->removeElement($delegue);
            // set the owning side to null (unless already changed)
            if ($delegue->getSuppleant() === $this) {
                $delegue->setSuppleant(null);
            }
        }

        return $this;
    }

    public function getActiveMails(): ?bool
    {
        return $this->activeMails;
    }

    public function setActiveMails(bool $activeMails): self
    {
        $this->activeMails = $activeMails;

        return $this;
    }

    /**
     * Renvoi une couleur en hexadecimal
     *
     * @return string
     */
    public function rand_color() {
        // return '#' . str_pad(dechex(mt_rand(0, 0xFFFFFF)), 6, '0', STR_PAD_LEFT);
        return sprintf('#%06X', mt_rand(0xFF9999, 0xFFFF00));

    }

    public function getEntreprise(): ?Entreprise
    {
        return $this->entreprise;
    }

    public function setEntreprise(?Entreprise $entreprise): self
    {
        $this->entreprise = $entreprise;

        return $this;
    }


}