src/Entity/User.php line 28

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Enum\NotificationType;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\DBAL\Types\Types;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Component\HttpFoundation\File\File;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Vich\UploaderBundle\Mapping\Annotation as Vich;
  15. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  16. use Symfony\Component\Security\Core\User\UserInterface;
  17. use Symfony\Component\Uid\Uuid;
  18. use Misd\PhoneNumberBundle\Validator\Constraints\PhoneNumber as AssertPhoneNumber;
  19. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  20. use SymfonyCasts\Bundle\ResetPassword\Model\ResetPasswordToken;
  22. #[ORM\Entity(repositoryClass: UserRepository::class)]
  23. #[ORM\Table(name: 'users')]
  24. #[UniqueEntity(fields: ['email'], message: 'Cette adresse email est déjà utilisée par un autre compte')]
  25. /**
  26.  * @Vich\Uploadable()
  27.  */
  28. class User implements UserInterface, PasswordAuthenticatedUserInterface
  29. {
  31.    
  32.     #[ORM\Id]
  33.     #[ORM\Column(type: 'string', length: 22, unique: true)]
  34.     #[Groups(['campaign', 'user_read','mission_list', 'mission_read', 'mission_participant_write', 'message_write','message_read','user_directory'])]
  35.     private string $id;
  37.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  38.     // #[Assert\NotBlank(message: 'Ce champs est requis')]
  39.     #[Groups(['user_read', 'mission_read','mission_list', 'mission_participant_write','message_read', 'message_write','user_directory'])]
  40.     private ?string $firstname = null;
  42.     #[ORM\Column(type: 'boolean', nullable: true)]
  43.     private ?bool $newAdd = false;
  45.     #[ORM\Column(type: 'boolean', nullable: true)]
  46.     private ?bool $allCompany = false;
  48.      #[ORM\Column(type: 'boolean', nullable: true)]
  49.      #[Groups(['mission_list','mission_read','message_read','user_read'])]
  50.     private ?bool $salary = false;
  52.      #[ORM\Column(type: 'boolean', nullable: true)]
  53.     private ?bool $manager = false;
  55.       #[ORM\Column(type: 'boolean', nullable: true)]
  56.     private ?bool $partner = false;
  58.     #[ORM\Column(type: 'boolean', nullable: true)]
  59.     #[Groups(['mission_list','mission_read','message_read','user_read'])]
  60.     private ?bool $shareMyEmail = false;
  62.      #[ORM\Column(type: 'boolean', nullable: true)]
  63.      #[Groups(['mission_list','mission_read','message_read','user_read'])]
  64.     private ?bool $shareMyPhone = false;
  67.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  68.     // #[Assert\NotBlank(message: 'Ce champs est requis')]
  69.     #[Groups(['user_read', 'mission_read','mission_list','message_read', 'mission_participant_write', 'message_write','user_directory'])]
  70.     private ?string $lastname = null;
  72.     #[ORM\Column(type: 'string', nullable: true)]
  73.     #[Groups(['user_read', 'mission_read','mission_list','message_read', 'mission_participant_write'])]
  74.     private ?string $cellPhone = null;
  76.     #[ORM\Column(type: 'boolean', nullable: true)]
  77.     #[Groups(['mission_list','user_read', 'mission_read','message_read', 'mission_participant_write'])]
  78.     private ?bool $enabled = false;
  80.      #[ORM\Column(type: 'boolean', nullable: true)]
  81.     private ?bool $external = false;
  83.     #[ORM\Column(type: 'decimal', precision: 10, scale: 2, nullable: true)]
  84.     #[Groups(['mission_list','user_read','message_read','mission_read'])]
  85.     private ?float $dailyRate = null;
  87.     #[ORM\Column(type: 'decimal', precision: 10, scale: 2, nullable: true)]
  88.     #[Groups(['mission_list','user_read','message_read','mission_read'])]
  89.     private ?float $resaleRate = null;
  91.     #[ORM\Column(type: 'smallint', nullable: true)]
  92.     private ?int $billingMethod = 0;
  94.     /**
  95.      * @Vich\UploadableField(mapping="sub_contractor_image", fileNameProperty="pictureName")
  96.      */
  97.     #[Assert\File(mimeTypes: ['image/png', 'image/jpeg', 'image/jpg','image/webp'], mimeTypesMessage: 'Les formats supportés sont : PNG, JPEG, JPG')]
  98.     private ?File $picture = null;
  100.     #[ORM\Column(type: 'string', nullable: true)]
  101.     #[Groups(['mission_list','user_read', 'mission_read','message_read','user_directory'])]
  103.     private ?string $pictureName = null;
  105.     #[ORM\Column(type: 'datetime', nullable: true)]
  106.     #[Groups(['mission_list','user_read','message_read'])]
  107.     private ?\DateTimeInterface $updatedAt = null;
  109.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  110.     #[Assert\NotBlank(message: 'Ce champ est requis')]
  111.     // #[Assert\Email(message: 'Cette adresse n\'est pas valide')]
  112.     #[Groups(['mission_list','user_read', 'mission_read','message_read', 'mission_participant_write'])]
  113.     private string $email = '';
  115.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  117.     private $OriginalEmail ;
  119.     #[ORM\Column(type: 'json')]
  120.     #[Groups(['user_read'])]
  121.     private array $roles = [];
  123.     #[ORM\Column(type: 'string')]
  124.     private string $password = '';
  126.     #[Assert\Length(min: 8, minMessage: 'Le mot de passe doit faire 8 charactères minimum')]
  127.     #[Assert\NotCompromisedPassword(message: 'Votre mot de passe est trop faible, merci d\'en choisir un plus fort', threshold: 50000)]
  128.     private ?string $plainPassword = null;
  130.     #[ORM\Column(type: 'datetime', nullable: true)]
  131.     private ?\DateTimeInterface $createdAt;
  133.     #[ORM\Column(type: 'datetime', nullable: true)]
  134.     private ?\DateTimeInterface $lastConnectionAt = null;
  136.     #[ORM\Column(type: 'string', nullable: true)]
  137.     private ?string $accountType;
  139.     #[ORM\ManyToOne(targetEntity: Company::class, inversedBy: 'users')]
  140.     #[Groups(['user_read','message_read'])]
  141.     private ?Company $company;
  143.     #[ORM\ManyToMany(inversedBy: 'otherUser',targetEntity: Company::class)]
  144.     private $otherCompany;
  146.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Message::class)]
  147.     private $messages;
  149.    
  150.     #[ORM\OneToOne(targetEntity: UserData::class, cascade: ['persist', 'remove'])]
  151.     private ?UserData $userData;
  154.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: FileMission::class)]
  155.     private $fileMissions;
  158.     #[ORM\ManyToMany(mappedBy: 'user', targetEntity: WorkflowAction::class)]
  159.     private $workflowAction;
  161.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InfoMission::class)]
  162.     private $infoMissions;
  164.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Mission::class)]
  165.     private $missions;
  167.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Historique::class)]
  168.     private $historiques;
  170.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: CreditHistory::class)]
  171.     private $creditHistories;
  173.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: Campaign::class)]
  174.     private $campaigns;
  176.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SubContractorCompany::class, cascade: ["persist"])]
  177.     private $subContractorCompanies;
  179.     #[ORM\Column(type: 'json', nullable: true)]
  180.     #[Groups(['user_read'])]
  181.     private ?array $notificationType = [0,1,2];
  183.     #[ORM\Column(type: 'json', nullable: true)]
  184.     #[Groups(['user_read'])]
  185.     private ?array $notification = [0,1,2,3,4,5];
  187.     #[ORM\Column(type: 'json', nullable: true)]
  188.     #[Groups(['user_read'])]
  189.     private $freqNotification = [1];
  192.     #[ORM\Column(type: 'json', nullable: true)]
  193.     #[Groups(['user_read'])]
  194.     private $freqNotificationEverytime = [1,3,5,8];
  196.     #[ORM\Column(type: 'json', nullable: true)]
  197.     #[Groups(['user_read'])]
  198.     private $freqNotificationPerDay = [0,2];
  200.     #[ORM\Column(type: 'json', nullable: true)]
  201.     #[Groups(['user_read'])]
  202.     private $freqNotificationPerWeek = [6];
  204.     #[ORM\Column(type: 'json', nullable: true)]
  205.     #[Groups(['user_read'])]
  206.     private $freqNotificationPerMonth = [];
  208.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Device::class)]
  209.     private $devices;
  211.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Service::class)]
  212.     #[Groups(['user_read'])]
  213.     private $services;
  215.     #[ORM\ManyToMany(targetEntity: Job::class, mappedBy: 'user')]
  216.     #[Groups(['user_directory','user_read'])]
  218.     private $jobs;
  220.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  221.     private ?bool $isActiveNotification = false;
  223.     #[ORM\Column(type: 'boolean')]
  224.     #[Groups(['mission_list','user_read', 'mission_read', 'mission_participant_write'])]
  225.     private ?bool $deleted = false;
  227.     #[ORM\Column(type: 'boolean')]
  228.     private ?bool $referencingConfirmationNotification = false;
  230.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  231.     #[Groups(['user_read'])]
  232.     private $gender;
  234.     #[ORM\OneToMany(mappedBy: 'orderBy', targetEntity: BalanceTransactions::class)]
  235.     private $balanceTransactions;
  237.     #[ORM\Column(type: 'array', nullable: true)]
  238.     private $deviceConnectedList = [];
  240.     #[ORM\Column]
  241.     private ?bool $invisible = null;
  243.     #[ORM\Column(nullable: true)]
  244.     private ?\DateTimeImmutable $lastActivityAt = null;
  246.     #[ORM\Column(nullable: true)]
  247.     private ?bool $isLogged = null;
  249.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: MessageReaction::class)]
  250.     private Collection $messageReactions;
  252.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Emoji::class)]
  253.     private Collection $emoji;
  255.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: CommandeLogging::class)]
  256.     private $commandeLoggings;
  259.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Support::class, orphanRemoval: true,cascade: ["persist"])]
  260.     private $supports;
  261.     
  263.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ConfidentialityContract::class)]
  264.     private Collection $confidentialityContracts;
  266.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CampaignPendingToSend::class)]
  267.     private $campaignPendingToSends;
  270.     private $resetToken = null;
  272.     #[ORM\Column(type: 'boolean', nullable: true)]
  273.     private $isNewClient;
  275.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  276.     private $autorizationDateAt;
  278.     #[ORM\Column(type: 'boolean', nullable: true)]
  280.     private $acceptPresentation;
  282.     #[ORM\Column(type: 'text', nullable: true)]  
  283.     #[Groups(['user_directory'])]
  284.     private $description;
  286.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  287.     #[Groups(['user_directory'])]
  288.     private $title;
  290.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  291.     private $oneTimeLoginToken;
  293.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  294.     private $state; 
  295.     
  296.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Portfolio::class)]
  297.     #[Groups(['user_directory'])]
  298.     private $portfolio; 
  300.     #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'children',cascade: ["persist"])]
  301.     private $parent;
  303.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: User::class,cascade: ["persist"])]
  304.     private $children;
  306.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SignedContract::class)]
  307.     private $signedContracts;
  309.     #[ORM\OneToMany(mappedBy: 'representative', targetEntity: Company::class)]
  310.     private $companiesRepresentative;
  311.     private $originalEmail = "";
  313.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Product::class)]
  314.     private $products;
  316.     #[ORM\ManyToMany(targetEntity: WorkflowStep::class, mappedBy: 'userResponsable')]
  317.     private $workflowSteps;
  319.     //only for API
  320.     #[Groups(['user_read'])]
  321.     private $listAccount;
  323.     #[Groups(['user_read'])]
  324.     private $originalMailUser = "";
  326.     #[Groups(['user_read'])]
  327.     private $roleName ="";
  329.     #[Groups(['user_read'])]
  330.     private $lastActivityInMinute = 99999;
  331.     ///////
  333.     private $fullName;
  334.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  335.     #[Groups(['message_read', 'mission_read', 'message_write'])]
  337.     private $identifier;
  339.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: SharedResourcesCategory::class)]
  340.     private Collection $sharedResourcesCategories;
  343.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: CompanyResource::class)]
  344.     private Collection $companyResources;
  347.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: ResourceDeliverableHistory::class)]
  348.     private Collection $resourceDeliverableHistories;
  350.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FilesResourceDeliverableHistory::class)]
  351.     private Collection $filesResourceDeliverableHistories;
  353.     #[ORM\ManyToMany(targetEntity: FilePermissions::class, mappedBy: 'user')]
  354.     private Collection $filePermissions;
  356.     #[ORM\ManyToMany(targetEntity: FolderPermissions::class, mappedBy: 'user')]
  357.     private Collection $folderPermissions;
  359.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FolderPermissions::class)]
  360.     private Collection $folderPermissionsCreatedBy;
  362.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FilePermissions::class)]
  363.     private Collection $filePermissionsCreatedBy;
  365.     
  366.     
  367.     public function __construct()
  368.     {
  369.         $this->id = Uuid::v4()->toBase58();
  370.         $this->createdAt = new \DateTime('now');
  371.         $this->messages = new ArrayCollection();
  372.         $this->infoMissions = new ArrayCollection();
  373.         $this->missions = new ArrayCollection();
  374.         $this->historiques = new ArrayCollection();
  375.         $this->creditHistories = new ArrayCollection();
  376.         $this->campaigns = new ArrayCollection();
  377.         $this->subContractorCompanies = new ArrayCollection();
  378.         $this->devices = new ArrayCollection();
  379.         $this->services = new ArrayCollection();
  380.         $this->jobs = new ArrayCollection();
  381.         $this->balanceTransactions = new ArrayCollection();
  382.         $this->invisible = false;
  383.         $this->company = null;
  384.         $this->dailyRate = 0;
  385.         $this->resaleRate = 0;
  386.         $this->workflowAction = new ArrayCollection();
  388.         $this->messageReactions = new ArrayCollection();
  389.         $this->emoji = new ArrayCollection();
  390.         $this->commandeLoggings = new ArrayCollection();
  393.         $this->supports = new ArrayCollection();
  394.         $this->confidentialityContracts = new ArrayCollection();
  396.         $this->campaignPendingToSends = new ArrayCollection();
  397.         $this->fileMissions = new ArrayCollection();
  399.         $this->isNewClient = false;
  400.         $this->autorizationDateAt = new \DateTimeImmutable();
  401.         $this->state = 'enabled'; 
  402.         $this->portfolio = new ArrayCollection();
  403.         $this->otherCompany = new ArrayCollection();
  404.         $this->children = new ArrayCollection();
  405.         $this->signedContracts = new ArrayCollection();
  406.         $this->companiesRepresentative = new ArrayCollection();
  407.         $this->products = new ArrayCollection();
  408.         $this->workflowSteps = new ArrayCollection();
  409.         $this->sharedResourcesCategories = new ArrayCollection();
  410.         $this->companyResources = new ArrayCollection();
  411.         $this->resourceDeliverableHistories = new ArrayCollection();
  412.         $this->filesResourceDeliverableHistories = new ArrayCollection();
  413.         $this->filePermissions = new ArrayCollection();
  414.         $this->folderPermissions = new ArrayCollection();
  415.         $this->folderPermissionsCreatedBy = new ArrayCollection();
  416.         $this->filePermissionsCreatedBy = new ArrayCollection();
  418.     }
  420.     public function getId(): ?string
  421.     {
  422.         return $this->id;
  423.     }
  424.     public function setId($id){
  425.         $this->id = $id;
  426.         return $this;
  427.     }
  429.     public function __toString(): string
  430.     {
  431.         return $this->getFirstname().' '.$this->getLastname();
  432.     }
  434.     public function getEmail(): ?string
  435.     {
  437.         if ($this->getOriginalEmail() != null) {
  438.             return $this->getOriginalEmail();
  439.         }
  441.         return $this->email;
  442.     }
  444.     public function getOriginalMailUser(): ?string
  445.     {
  446.         return $this->email;
  447.     }
  449.     //  public function getOriginalEmail(): ?string
  450.     // {
  451.     //     return $this->email;
  452.     // }
  454.     public function setEmail(string $email): self
  455.     {
  456.         $this->email = $email;
  458.         return $this;
  459.     }
  461.     /**
  462.      * A visual identifier that represents this user.
  463.      *
  464.      * @see UserInterface
  465.      */
  466.     public function getUserIdentifier(): string
  467.     {
  468.         return (string) $this->email;
  469.     }
  471.     /**
  472.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  473.      */
  474.     public function getUsername(): string
  475.     {
  476.         return (string) $this->email;
  477.     }
  479.     /**
  480.      * @see UserInterface
  481.      */
  482.     public function getRoles(): array
  483.     {
  484.         $roles = $this->roles;
  485.         // if (isset($_SESSION['_sf2_attributes']['role_current_user']) and null !== $_SESSION['_sf2_attributes']['role_current_user']) {
  486.         //    $roles[0]= $_SESSION['_sf2_attributes']['role_current_user'];
  487.         // }
  488.         // $roles[0]='ROLE_MANAGER';
  489.         // guarantee every user at least has ROLE_USER
  490.         $roles[] = 'ROLE_USER';
  492.         return array_unique($roles);
  493.     }
  494.     public function getOriginalRoles(): array 
  495.     {
  496.         $roles = $this->roles;
  497.         // $roles[0]='ROLE_MANAGER';
  498.         // guarantee every user at least has ROLE_USER
  499.         $roles[] = 'ROLE_USER';
  501.         return array_unique($roles);
  502.     }
  504.     public function setRoles(array $roles): self
  505.     {
  506.         $this->roles = $roles;
  508.         return $this;
  509.     }
  511.     /**
  512.      * @see PasswordAuthenticatedUserInterface
  513.      */
  514.     public function getPassword(): string
  515.     {
  516.         return $this->password;
  517.     }
  519.     public function setPassword(string $password): self
  520.     {
  521.         
  522.         $this->password = $password;
  524.         return $this;
  525.     }
  527.     /**
  528.      * Returning a salt is only needed, if you are not using a modern
  529.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  530.      *
  531.      * @see UserInterface
  532.      */
  533.     public function getSalt(): ?string
  534.     {
  535.         return null;
  536.     }
  538.     /**
  539.      * @see UserInterface
  540.      */
  541.     public function eraseCredentials()
  542.     {
  543.         // If you store any temporary, sensitive data on the user, clear it here
  544.         // $this->plainPassword = null;
  545.     }
  547.     /**
  548.      * @return string|null
  549.      */
  550.     public function getFirstname(): ?string
  551.     {
  552.         return $this->firstname;
  553.     }
  555.     /**
  556.      * @param mixed $firstname
  557.      */
  558.     public function setFirstname(?string $firstname): self
  559.     {
  560.         $this->firstname = $firstname;
  562.         return $this;
  563.     }
  565.     /**
  566.      * @return string|null
  567.      */
  568.     public function getLastname(): ?string
  569.     {
  570.         return $this->lastname;
  571.     }
  573.     /**
  574.      * @param mixed $lastname
  575.      */
  576.     public function setLastname(?string $lastname): self
  577.     {
  578.         $this->lastname = $lastname;
  580.         return $this;
  581.     }
  583.     /**
  584.      * @return string|null
  585.      */
  586.     public function getCellPhone(): ?string
  587.     {
  588.         return $this->cellPhone;
  589.     }
  591.     /**
  592.      * @param mixed $cellPhone
  593.      */
  594.     public function setCellPhone(?string $cellPhone): self
  595.     {
  596.         $this->cellPhone = $cellPhone;
  598.         return $this;
  599.     }
  601.     /**
  602.      * @return bool
  603.      */
  604.     public function isEnabled(): bool
  605.     {
  606.         return $this->enabled;
  607.     }
  609.     /**
  610.      * @param int $enabled
  611.      */
  612.     public function setEnabled(bool $enabled): self
  613.     {
  614.         if (is_null($this->getParent()) and $enabled) {
  615.             foreach ($this->getChildren() as $userChild) {
  616.                 $userChild->setEnabled($enabled);
  617.             }
  618.         }
  619.         $this->enabled = $enabled;
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return bool|null
  626.      */
  627.     public function isExternal(): ?bool
  628.     {
  629.         return $this->external;
  630.     }
  632.     /**
  633.      * @param int $external
  634.      */
  635.     public function setExternal(bool $external): self
  636.     {
  637.         $this->external = $external;
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return mixed
  644.      */
  645.     public function getDailyRate(): ?string
  646.     {
  647.         return $this->dailyRate;
  648.     }
  650.     /**
  651.      * @param mixed $dailyRate
  652.      */
  653.     public function setDailyRate(?string $dailyRate): void
  654.     {
  655.         $this->dailyRate = $dailyRate;
  656.     }
  658.     /**
  659.      * @return mixed
  660.      */
  661.     public function getBillingMethod(): ?string
  662.     {
  663.         return $this->billingMethod;
  664.     }
  666.     /**
  667.      * @param mixed $billingMethod
  668.      */
  669.     public function setBillingMethod(?string $billingMethod): void
  670.     {
  671.         $this->billingMethod = $billingMethod;
  672.     }
  674.     public function serialize()
  675.     {
  676.         $this->picture = base64_encode($this->picture);
  677.     }
  679.     public function unserialize($serialized)
  680.     {
  681.         $this->picture = base64_decode($this->picture);
  682.     }
  684.     /**
  685.      * @return File|null
  686.      */
  687.     public function getPicture(): ?File
  688.     {
  689.         return $this->picture;
  690.     }
  692.     public function setPicture(?File $picture = null): void
  693.     {
  694.         $this->picture = $picture;
  696.         if (null !== $picture) {
  697.             // It is required that at least one field changes if you are using doctrine
  698.             // otherwise the event listeners won't be called and the file is lost
  699.             $this->updatedAt = new \DateTimeImmutable();
  700.         }
  701.     }
  703.     public function getUpdatedAt(): ?\DateTimeInterface
  704.     {
  705.         return $this->updatedAt;
  706.     }
  708.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  709.     {
  710.         $this->updatedAt = $updatedAt;
  712.         return $this;
  713.     }
  715.     /**
  716.      * @return string|null
  717.      */
  718.     public function getPictureName(): ?string
  719.     {
  720.         return $this->pictureName;
  721.     }
  723.     /**
  724.      * @param string|null $pictureName
  725.      */
  726.     public function setPictureName(?string $pictureName): void
  727.     {
  728.         $this->pictureName = $pictureName;
  729.     }
  731.     /**
  732.      * @return \DateTimeInterface|null
  733.      */
  734.     public function getCreatedAt(): ?\DateTimeInterface
  735.     {
  736.         return $this->createdAt;
  737.     }
  739.     /**
  740.      * @param \DateTimeInterface|null $createdAt
  741.      */
  742.     public function setCreatedAt(?\DateTimeInterface $createdAt): void
  743.     {
  744.         $this->createdAt = $createdAt;
  745.     }
  747.     /**
  748.      * @return \DateTimeInterface|null
  749.      */
  750.     public function getLastConnectionAt(): ?\DateTimeInterface
  751.     {
  752.         return $this->lastConnectionAt;
  753.     }
  755.     /**
  756.      * @param \DateTimeInterface|null $lastConnectionAt
  757.      * @return User
  758.      */
  759.     public function setLastConnectionAt(?\DateTimeInterface $lastConnectionAt): User
  760.     {
  761.         $this->lastConnectionAt = $lastConnectionAt;
  762.         return $this;
  763.     }
  765.     public function getPlainPassword(): ?string
  766.     {
  767.         return $this->plainPassword;
  768.     }
  770.     public function setPlainPassword(?string $password): self
  771.     {
  772.         $this->plainPassword = $password;
  774.         return $this;
  775.     }
  777.     /**
  778.      * @return string|null
  779.      */
  780.     public function getAccountType(): ?string
  781.     {
  782.         return $this->accountType;
  783.     }
  785.     /**
  786.      * @param string|null $accountType
  787.      * @return User
  788.      */
  789.     public function setAccountType(?string $accountType): User
  790.     {
  791.         $this->accountType = $accountType;
  792.         return $this;
  793.     }
  795.     public function getCompany(): ?Company
  796.     {
  797.         return $this->company;
  798.     }
  800.     public function setCompany(?Company $company): self
  801.     {
  802.         $this->company = $company;
  804.         return $this;
  805.     }
  807.     /**
  808.      * @return Collection|Message[]
  809.      */
  810.     public function getMessages(): Collection
  811.     {
  812.         return $this->messages;
  813.     }
  815.     public function addMessage(Message $message): self
  816.     {
  817.         if (!$this->messages->contains($message)) {
  818.             $this->messages[] = $message;
  819.             $message->setUser($this);
  820.         }
  822.         return $this;
  823.     }
  825.     public function removeMessage(Message $message): self
  826.     {
  827.         if ($this->messages->removeElement($message)) {
  828.             // set the owning side to null (unless already changed)
  829.             if ($message->getUser() === $this) {
  830.                 $message->setUser(null);
  831.             }
  832.         }
  834.         return $this;
  835.     }
  837.     /**
  838.      * @return Collection|InfoMission[]
  839.      */
  840.     public function getInfoMissions(): Collection
  841.     {
  842.         return $this->infoMissions;
  843.     }
  845.     public function addInfoMission(InfoMission $infoMission): self
  846.     {
  847.         if (!$this->infoMissions->contains($infoMission)) {
  848.             $this->infoMissions[] = $infoMission;
  849.             $infoMission->setUser($this);
  850.         }
  852.         return $this;
  853.     }
  855.     public function removeInfoMission(InfoMission $infoMission): self
  856.     {
  857.         if ($this->infoMissions->removeElement($infoMission)) {
  858.             // set the owning side to null (unless already changed)
  859.             if ($infoMission->getUser() === $this) {
  860.                 $infoMission->setUser(null);
  861.             }
  862.         }
  864.         return $this;
  865.     }
  867.     /**
  868.      * @return Collection|Mission[]
  869.      */
  870.     public function getMissions(): Collection
  871.     {
  872.         return $this->missions;
  873.     }
  875.     public function addMission(Mission $mission): self
  876.     {
  877.         if (!$this->missions->contains($mission)) {
  878.             $this->missions[] = $mission;
  879.             $mission->setContact($this);
  880.         }
  882.         return $this;
  883.     }
  885.     public function removeMission(Mission $mission): self
  886.     {
  887.         if ($this->missions->removeElement($mission)) {
  888.             // set the owning side to null (unless already changed)
  889.             if ($mission->getContact() === $this) {
  890.                 $mission->setContact(null);
  891.             }
  892.         }
  894.         return $this;
  895.     }
  897.     /**
  898.      * @return Collection|Historique[]
  899.      */
  900.     public function getHistoriques(): Collection
  901.     {
  902.         return $this->historiques;
  903.     }
  905.     public function addHistorique(Historique $historique): self
  906.     {
  907.         if (!$this->historiques->contains($historique)) {
  908.             $this->historiques[] = $historique;
  909.             $historique->setUser($this);
  910.         }
  912.         return $this;
  913.     }
  915.     public function removeHistorique(Historique $historique): self
  916.     {
  917.         if ($this->historiques->removeElement($historique)) {
  918.             // set the owning side to null (unless already changed)
  919.             if ($historique->getUser() === $this) {
  920.                 $historique->setUser(null);
  921.             }
  922.         }
  924.         return $this;
  925.     }
  927.     /**
  928.      * @return Collection|SubContractorCompany[]
  929.      */
  930.     public function getSubContractorCompanies(): Collection
  931.     {
  932.         return $this->subContractorCompanies;
  933.     }
  935.     public function addSubContractorCompany(SubContractorCompany $subContractorCompany): self
  936.     {
  937.         if (!$this->subContractorCompanies->contains($subContractorCompany)) {
  938.             $this->subContractorCompanies[] = $subContractorCompany;
  939.             $subContractorCompany->setUser($this);
  940.         }
  942.         return $this;
  943.     }
  945.     public function removeSubContractorCompany(SubContractorCompany $subContractorCompany): self
  946.     {
  947.         if ($this->subContractorCompanies->removeElement($subContractorCompany)) {
  948.             // set the owning side to null (unless already changed)
  949.             if ($subContractorCompany->getUser() === $this) {
  950.                 $subContractorCompany->setUser(null);
  951.             }
  952.         }
  954.         return $this;
  955.     }
  957.     /**
  958.      * @return Collection|Device[]
  959.      */
  960.     public function getDevices(): Collection
  961.     {
  962.         return $this->devices;
  963.     }
  965.     public function addDevice(Device $device): self
  966.     {
  967.         if (!$this->devices->contains($device)) {
  968.             $this->devices[] = $device;
  969.             $device->setUser($this);
  970.         }
  972.         return $this;
  973.     }
  975.     public function removeDevice(Device $device): self
  976.     {
  977.         if ($this->devices->removeElement($device)) {
  978.             // set the owning side to null (unless already changed)
  979.             if ($device->getUser() === $this) {
  980.                 $device->setUser(null);
  981.             }
  982.         }
  984.         return $this;
  985.     }
  987.     /**
  988.      * @return Collection|Service[]
  989.      */
  990.     public function getServices(): Collection
  991.     {
  992.         return $this->services;
  993.     }
  995.     public function addService(Service $service): self
  996.     {
  997.         if (!$this->services->contains($service)) {
  998.             $this->services[] = $service;
  999.             $service->setUser($this);
  1000.         }
  1002.         return $this;
  1003.     }
  1005.     public function removeService(Service $service): self
  1006.     {
  1007.         if ($this->services->removeElement($service)) {
  1008.             // set the owning side to null (unless already changed)
  1009.             if ($service->getUser() === $this) {
  1010.                 $service->setUser(null);
  1011.             }
  1012.         }
  1014.         return $this;
  1015.     }
  1017.     /**
  1018.      * @return array|null
  1019.      */
  1020.     public function getNotificationType(): ?array
  1021.     {
  1022.         return $this->notificationType;
  1023.     }
  1025.     /**
  1026.      * @param array|null $notificationType
  1027.      */
  1028.     public function setNotificationType(?array $notificationType): void
  1029.     {
  1030.         $this->notificationType = $notificationType;
  1031.     }
  1033.     /**
  1034.      * @return array|null
  1035.      */
  1036.     public function getNotification(): ?array
  1037.     {
  1038.         return $this->notification;
  1039.     }
  1041.     /**
  1042.      * @param array|null $notification
  1043.      */
  1044.     public function setNotification(?array $notification): void
  1045.     {
  1046.         $this->notification = $notification;
  1047.     }
  1049.     /**
  1050.      * @return Collection|Job[]
  1051.      */
  1052.     public function getJobs(): Collection
  1053.     {
  1054.         return $this->jobs;
  1055.     }
  1057.     public function addJob(Job $job): self
  1058.     {
  1059.         if (!$this->jobs->contains($job)) {
  1060.             $this->jobs[] = $job;
  1061.             $job->addUser($this);
  1062.         }
  1064.         return $this;
  1065.     }
  1067.     public function removeJob(Job $job): self
  1068.     {
  1069.         if ($this->jobs->removeElement($job)) {
  1070.             $job->removeUser($this);
  1071.         }
  1073.         return $this;
  1074.     }
  1076.     public function getIsActiveNotification(): ?bool
  1077.     {
  1078.         return $this->isActiveNotification;
  1079.     }
  1081.     public function setIsActiveNotification(bool $isActiveNotification): self
  1082.     {
  1083.         $this->isActiveNotification = $isActiveNotification;
  1085.         return $this;
  1086.     }
  1088.     public function getDeleted(): ?bool
  1089.     {
  1090.         return $this->deleted;
  1091.     }
  1093.     public function setDeleted(bool $deleted): self
  1094.     {
  1095.         $this->deleted = $deleted;
  1097.         return $this;
  1098.     }
  1100.     
  1101.     /**
  1102.      * @return array|null
  1103.      */
  1104.     public function getFreqNotification(): ?array
  1105.     {
  1106.         return $this->freqNotification;
  1107.     }
  1109.     /**
  1110.      * @param int|null $freqNotification
  1111.      */
  1112.     public function setFreqNotification(?array $freqNotification): void
  1113.     {
  1114.         $this->freqNotification = $freqNotification;
  1115.     }
  1117.     /**
  1118.      * @return array|null
  1119.      */
  1120.     public function getFreqNotificationEverytime(): ?array
  1121.     {
  1122.         return $this->freqNotificationEverytime;
  1123.     }
  1125.     /**
  1126.      * @param int|null $freqNotification
  1127.      */
  1128.     public function setFreqNotificationEverytime(?array $freqNotificationEverytime): void
  1129.     {
  1130.         $this->freqNotificationEverytime = $freqNotificationEverytime;
  1131.     }
  1133.      /**
  1134.      * @return array|null
  1135.      */
  1136.     public function getFreqNotificationPerDay(): ?array
  1137.     {
  1138.         return $this->freqNotificationPerDay;
  1139.     }
  1141.     /**
  1142.      * @param int|null $freqNotification
  1143.      */
  1144.     public function setFreqNotificationPerDay(?array $freqNotificationPerDay): void
  1145.     {
  1146.         $this->freqNotificationPerDay = $freqNotificationPerDay;
  1147.     }
  1148.     /**
  1149.      * @return array|null
  1150.      */
  1151.     public function getFreqNotificationPerWeek(): ?array
  1152.     {
  1153.         return $this->freqNotificationPerWeek;
  1154.     }
  1156.     /**
  1157.      * @param int|null $freqNotification
  1158.      */
  1159.     public function setFreqNotificationPerWeek(?array $freqNotificationPerWeek): void
  1160.     {
  1161.         $this->freqNotificationPerWeek = $freqNotificationPerWeek;
  1162.     }
  1164.     /**
  1165.      * @return array|null
  1166.      */
  1167.     public function getFreqNotificationPerMonth(): ?array
  1168.     {
  1169.         return $this->freqNotificationPerMonth;
  1170.     }
  1172.     /**
  1173.      * @param int|null $freqNotification
  1174.      */
  1175.     public function setFreqNotificationPerMonth(?array $freqNotificationPerMonth): void
  1176.     {
  1177.         $this->freqNotificationPerMonth = $freqNotificationPerMonth;
  1178.     }
  1180.     /**
  1181.      * @return float|null
  1182.      */
  1183.     public function getResaleRate(): ?float
  1184.     {
  1185.         return $this->resaleRate;
  1186.     }
  1188.     /**
  1189.      * @param float|null $resaleRate
  1190.      */
  1191.     public function setResaleRate(?float $resaleRate): void
  1192.     {
  1194.         //mettre 30% si le prix de vente est 0 ou null 
  1195.         if (($this->getResaleRate() == null or $this->getResaleRate() == 0)) {
  1196.             if ($this->getDailyRate() != null and $this->getDailyRate() > 0) {
  1197.                 $this->resaleRate = $this->getDailyRate() + ($this->getDailyRate() * 0.3);
  1198.             }else{
  1199.                 $this->resaleRate = $resaleRate;
  1200.             }
  1201.         }else{
  1202.             $this->resaleRate = $resaleRate;
  1203.         }
  1204.     }
  1206.     public function getReferencingConfirmationNotification(): ?bool
  1207.     {
  1208.         return $this->referencingConfirmationNotification;
  1209.     }
  1211.     public function setReferencingConfirmationNotification(bool $referencingConfirmationNotification): self
  1212.     {
  1213.         $this->referencingConfirmationNotification = $referencingConfirmationNotification;
  1215.         return $this;
  1216.     }
  1218.     public function getGender(): ?string
  1219.     {
  1220.         return $this->gender;
  1221.     }
  1223.     public function setGender(?string $gender): self
  1224.     {
  1225.         $this->gender = $gender;
  1227.         return $this;
  1228.     }
  1230.     public function getFullName():?string
  1231.     {
  1232.         return $this->getFirstname()."  ". $this->getLastname();
  1233.     }
  1235.     /**
  1236.      * @return Collection|BalanceTransactions[]
  1237.      */
  1238.     public function getBalanceTransactions(): Collection
  1239.     {
  1240.         return $this->balanceTransactions;
  1241.     }
  1243.     public function addBalanceTransaction(BalanceTransactions $balanceTransaction): self
  1244.     {
  1245.         if (!$this->balanceTransactions->contains($balanceTransaction)) {
  1246.             $this->balanceTransactions[] = $balanceTransaction;
  1247.             $balanceTransaction->setOrderBy($this);
  1248.         }
  1250.         return $this;
  1251.     }
  1253.     public function removeBalanceTransaction(BalanceTransactions $balanceTransaction): self
  1254.     {
  1255.         if ($this->balanceTransactions->removeElement($balanceTransaction)) {
  1256.             // set the owning side to null (unless already changed)
  1257.             if ($balanceTransaction->getOrderBy() === $this) {
  1258.                 $balanceTransaction->setOrderBy(null);
  1259.             }
  1260.         }
  1262.         return $this;
  1263.     }
  1265.     public function getDeviceConnectedList(): ?array
  1266.     {
  1267.         return $this->deviceConnectedList;
  1268.     }
  1270.     public function setDeviceConnectedList(?array $deviceConnectedList): self
  1271.     {
  1272.         $this->deviceConnectedList = $deviceConnectedList;
  1274.         return $this;
  1275.     }
  1277.     public function isInvisible(): ?bool
  1278.     {
  1279.         return $this->invisible;
  1280.     }
  1282.     public function setInvisible(bool $invisible): static
  1283.     {
  1284.         $this->invisible = $invisible;
  1286.         return $this;
  1287.     }
  1289.     public function getLastActivityAt(): ?\DateTimeImmutable
  1290.     {
  1291.         return $this->lastActivityAt;
  1292.     }
  1294.     public function setLastActivityAt(?\DateTimeImmutable $lastActivityAt): static
  1295.     {
  1296.         $this->lastActivityAt = $lastActivityAt;
  1298.         return $this;
  1299.     }
  1301.     public function getLastActivityInMinute(){
  1302.         if($this->getLastActivityAt() != null){
  1303.             $now = new \DateTimeImmutable();
  1304.             $userLastActivity = $this->getLastActivityAt();
  1305.             $interval= $now->diff($userLastActivity);
  1306.             return $interval->days * 24 * 60 + $interval->h * 60 + $interval->i; 
  1307.         }
  1308.         return 9999;
  1309.     }
  1311.     public function isLogged(): ?bool
  1312.     {
  1313.         return $this->isLogged;
  1314.     }
  1316.     public function setIsLogged(?bool $isLogged): static
  1317.     {
  1318.         $this->isLogged = $isLogged;
  1320.         return $this;
  1321.     }
  1324.     public function getEnabled(): ?bool
  1325.     {
  1326.         return $this->enabled;
  1327.     }
  1329.     public function getExternal(): ?bool
  1330.     {
  1331.         return $this->external;
  1332.     }
  1334.     public function getInvisible(): ?bool
  1335.     {
  1336.         return $this->invisible;
  1337.     }
  1339.     public function getIsLogged(): ?bool
  1340.     {
  1341.         return $this->isLogged;
  1342.     }
  1344.     
  1346.     /**
  1347.      * @return Collection<int, MessageReaction>
  1348.      */
  1349.     public function getMessageReactions(): Collection
  1350.     {
  1351.         return $this->messageReactions;
  1352.     }
  1354.     public function addMessageReaction(MessageReaction $messageReaction): static
  1355.     {
  1356.         if (!$this->messageReactions->contains($messageReaction)) {
  1357.             $this->messageReactions->add($messageReaction);
  1358.             $messageReaction->setUser($this);
  1359.         }
  1361.         return $this;
  1362.     }
  1367.     public function removeMessageReaction(MessageReaction $messageReaction): static
  1368.     {
  1369.         if ($this->messageReactions->removeElement($messageReaction)) {
  1370.             // set the owning side to null (unless already changed)
  1371.             if ($messageReaction->getUser() === $this) {
  1372.                 $messageReaction->setUser(null);
  1374.             }
  1375.         }
  1377.         return $this;
  1378.     }
  1380.     /**
  1381.      * @return Collection<int, Emoji>
  1382.      */
  1383.     public function getEmoji(): Collection
  1384.     {
  1385.         return $this->emoji;
  1386.     }
  1388.     public function addEmoji(Emoji $emoji): static
  1389.     {
  1390.         if (!$this->emoji->contains($emoji)) {
  1391.             $this->emoji->add($emoji);
  1392.             $emoji->setUser($this);
  1393.         }
  1395.         return $this;
  1396.     }
  1399.     public function removeEmoji(Emoji $emoji): static
  1400.     {
  1401.         if ($this->emoji->removeElement($emoji)) {
  1402.             // set the owning side to null (unless already changed)
  1403.             if ($emoji->getUser() === $this) {
  1404.                 $emoji->setUser(null);
  1405.             }
  1406.         }
  1408.         return $this;
  1409.     }
  1411.     /**
  1412.      * @return Collection|WorkflowAction[]
  1413.      */
  1414.     public function getWorkflowAction(): Collection
  1415.     {
  1416.         return $this->workflowAction;
  1417.     }
  1419.     public function addWorkflowAction(WorkflowAction $workflowAction): self
  1420.     {
  1421.         if (!$this->workflowAction->contains($workflowAction)) {
  1422.             $this->workflowAction[] = $workflowAction;
  1423.             $workflowAction->setUser($this);
  1424.         }
  1426.         return $this;
  1427.     }
  1429.     public function removeWorkflowAction(WorkflowAction $workflowAction): self
  1430.     {
  1431.         if ($this->workflowAction->removeElement($workflowAction)) {
  1432.             // set the owning side to null (unless already changed)
  1433.             if ($workflowAction->getUser() === $this) {
  1434.                 $workflowAction->setUser(null);
  1435.             }
  1436.         }
  1438.         return $this;
  1439.     }
  1441.     public function getDefaultEmoji(){
  1442.         return [
  1443.             [
  1444.                 "emoji" => "👍️",
  1445.                 "emojiId"=>350,
  1446.                 "detail" => "thumbs up"
  1447.             ],
  1448.             [
  1449.                 "emoji" => "❤️",
  1450.                 "emojiId"=>153,
  1451.                 "detail" => "red heart"
  1452.             ],
  1453.             [
  1454.                 "emoji" => "😆",
  1455.                 "emojiId"=>5,
  1456.                 "detail" => "grinning squinting face"
  1457.             ],
  1458.             [
  1459.                 "emoji" => "😮",
  1460.                 "emojiId"=>86,
  1461.                 "detail" => "face with open mouth"
  1462.             ],
  1463.             [
  1464.                 "emoji" => "😢",
  1465.                 "emojiId"=>97,
  1466.                 "detail" => "crying face"
  1467.             ],
  1468.             [
  1469.                 "emoji" => "😡",
  1470.                 "emojiId"=>108,
  1471.                 "detail" => "enraged face"
  1472.             ],
  1473.         ];
  1474.     }
  1476.     /**
  1477.      * @return Collection|CommandeLogging[]
  1478.      */
  1479.     public function getCommandeLoggings(): Collection
  1480.     {
  1481.         return $this->commandeLoggings;
  1482.     }
  1484.     public function addCommandeLogging(CommandeLogging $commandeLogging): self
  1485.     {
  1486.         if (!$this->commandeLoggings->contains($commandeLogging)) {
  1487.             $this->commandeLoggings[] = $commandeLogging;
  1488.             $commandeLogging->setUser($this);
  1489.         }
  1491.         return $this;
  1492.     }
  1494.     public function removeCommandeLogging(CommandeLogging $commandeLogging): self
  1495.     {
  1496.         if ($this->commandeLoggings->removeElement($commandeLogging)) {
  1497.             // set the owning side to null (unless already changed)
  1498.             if ($commandeLogging->getUser() === $this) {
  1499.                 $commandeLogging->setUser(null);
  1500.             }
  1501.         }
  1503.         return $this;
  1504.     }
  1506.     public function getNewAdd(): ?bool
  1507.     {
  1508.         return $this->newAdd;
  1509.     }
  1511.     public function setNewAdd(?bool $newAdd): self
  1512.     {
  1513.         $this->newAdd = $newAdd;
  1515.         return $this;
  1516.     }
  1518.     /**
  1519.      * @return Collection|CreditHistory[]
  1520.      */
  1521.     public function getCreditHistories(): Collection
  1522.     {
  1523.         return $this->creditHistories;
  1524.     }
  1526.     public function addCreditHistory(CreditHistory $creditHistory): self
  1527.     {
  1528.         if (!$this->creditHistories->contains($creditHistory)) {
  1529.             $this->creditHistories[] = $creditHistory;
  1530.             $creditHistory->setOrderedBy($this);
  1531.         }
  1533.         return $this;
  1534.     }
  1536.     public function removeCreditHistory(CreditHistory $creditHistory): self
  1537.     {
  1538.         if ($this->creditHistories->removeElement($creditHistory)) {
  1539.             // set the owning side to null (unless already changed)
  1540.             if ($creditHistory->getOrderedBy() === $this) {
  1541.                 $creditHistory->setOrderedBy(null);
  1542.             }
  1543.         }
  1545.         return $this;
  1546.     }
  1548.     /**
  1549.      * @return Collection|Campaign[]
  1550.      */
  1551.     public function getCampaigns(): Collection
  1552.     {
  1553.         return $this->campaigns;
  1554.     }
  1556.     public function addCampaign(Campaign $campaign): self
  1557.     {
  1558.         if (!$this->campaigns->contains($campaign)) {
  1559.             $this->campaigns[] = $campaign;
  1560.             $campaign->setOrderedBy($this);
  1561.         }
  1563.         return $this;
  1564.     }
  1566.     public function removeCampaign(Campaign $campaign): self
  1567.     {
  1568.         if ($this->campaigns->removeElement($campaign)) {
  1569.             // set the owning side to null (unless already changed)
  1570.             if ($campaign->getOrderedBy() === $this) {
  1571.                 $campaign->setOrderedBy(null);
  1572.             }
  1573.         }
  1575.         return $this;
  1576.     }
  1578.     public function getShareMyEmail(): ?bool
  1579.     {
  1580.         return $this->shareMyEmail;
  1581.     }
  1583.     public function setShareMyEmail(?bool $shareMyEmail): self
  1584.     {
  1585.         $this->shareMyEmail = $shareMyEmail;
  1587.         return $this;
  1588.     }
  1590.     public function getShareMyPhone(): ?bool
  1591.     {
  1592.         return $this->shareMyPhone;
  1593.     }
  1595.     public function setShareMyPhone(?bool $shareMyPhone): self
  1596.     {
  1597.         $this->shareMyPhone = $shareMyPhone;
  1599.         return $this;
  1600.     }
  1603.     /**
  1604.      * @return Collection|Support[]
  1605.      */
  1606.     public function getSupports(): Collection
  1607.     {
  1608.         return $this->supports;
  1609.     }
  1611.     public function addSupport(Support $support): self
  1612.     {
  1613.         if (!$this->supports->contains($support)) {
  1614.             $this->supports[] = $support;
  1615.             $support->setUser($this);
  1616.         }
  1618.         return $this;
  1619.     }
  1621.     public function removeSupport(Support $support): self
  1622.     {
  1623.         if ($this->supports->removeElement($support)) {
  1624.             // set the owning side to null (unless already changed)
  1625.             if ($support->getUser() === $this) {
  1626.                 $support->setUser(null);
  1627.             }
  1628.         }
  1629.     }
  1632.     public function getResetToken(): ?ResetPasswordToken
  1633.     {
  1634.         return $this->resetToken;
  1635.     }
  1637.     public function setResetToken(?ResetPasswordToken  $resetToken): self
  1638.     {
  1639.         $this->resetToken = $resetToken;
  1642.         return $this;
  1643.     }
  1645.     /**
  1646.      * @return Collection<int, ConfidentialityContract>
  1647.      */
  1648.     public function getConfidentialityContracts(): Collection
  1649.     {
  1650.         return $this->confidentialityContracts;
  1651.     }
  1653.     public function addConfidentialityContract(ConfidentialityContract $confidentialityContract): static
  1654.     {
  1655.         if (!$this->confidentialityContracts->contains($confidentialityContract)) {
  1656.             $this->confidentialityContracts->add($confidentialityContract);
  1657.             $confidentialityContract->setUser($this);
  1658.         }
  1660.         return $this;
  1661.     }
  1663.     public function removeConfidentialityContract(ConfidentialityContract $confidentialityContract): static
  1664.     {
  1665.         if ($this->confidentialityContracts->removeElement($confidentialityContract)) {
  1666.             // set the owning side to null (unless already changed)
  1667.             if ($confidentialityContract->getUser() === $this) {
  1668.                 $confidentialityContract->setUser(null);
  1669.             }
  1670.         }
  1672.         return $this;
  1673.     }
  1675.     /**
  1676.      * @return Collection|CampaignPendingToSend[]
  1677.      */
  1678.     public function getCampaignPendingToSends(): Collection
  1679.     {
  1680.         return $this->campaignPendingToSends;
  1681.     }
  1683.     public function addCampaignPendingToSend(CampaignPendingToSend $campaignPendingToSend): self
  1684.     {
  1685.         if (!$this->campaignPendingToSends->contains($campaignPendingToSend)) {
  1686.             $this->campaignPendingToSends[] = $campaignPendingToSend;
  1687.             $campaignPendingToSend->setUser($this);
  1688.         }
  1690.         return $this;
  1691.     }
  1693.     public function removeCampaignPendingToSend(CampaignPendingToSend $campaignPendingToSend): self
  1694.     {
  1695.         if ($this->campaignPendingToSends->removeElement($campaignPendingToSend)) {
  1696.             // set the owning side to null (unless already changed)
  1697.             if ($campaignPendingToSend->getUser() === $this) {
  1698.                 $campaignPendingToSend->setUser(null);
  1699.             }
  1700.         }
  1702.         return $this;
  1704.     }
  1706.     public function isNewAdd(): ?bool
  1707.     {
  1708.         return $this->newAdd;
  1709.     }
  1711.     public function isShareMyEmail(): ?bool
  1712.     {
  1713.         return $this->shareMyEmail;
  1714.     }
  1716.     public function isShareMyPhone(): ?bool
  1717.     {
  1718.         return $this->shareMyPhone;
  1719.     }
  1721.     public function isIsActiveNotification(): ?bool
  1722.     {
  1723.         return $this->isActiveNotification;
  1724.     }
  1726.     public function isDeleted(): ?bool
  1727.     {
  1728.         return $this->deleted;
  1729.     }
  1731.     public function isReferencingConfirmationNotification(): ?bool
  1732.     {
  1733.         return $this->referencingConfirmationNotification;
  1734.     }
  1736.     public function isIsLogged(): ?bool
  1737.     {
  1738.         return $this->isLogged;
  1739.     }
  1741.     /**
  1742.      * @return Collection<int, FileMission>
  1743.      */
  1744.     public function getFileMissions(): Collection
  1745.     {
  1746.         return $this->fileMissions;
  1747.     }
  1749.     public function addFileMission(FileMission $fileMission): static
  1750.     {
  1751.         if (!$this->fileMissions->contains($fileMission)) {
  1752.             $this->fileMissions->add($fileMission);
  1753.             $fileMission->setUser($this);
  1754.         }
  1756.         return $this;
  1757.     }
  1759.     public function removeFileMission(FileMission $fileMission): static
  1760.     {
  1761.         if ($this->fileMissions->removeElement($fileMission)) {
  1762.             // set the owning side to null (unless already changed)
  1763.             if ($fileMission->getUser() === $this) {
  1764.                 $fileMission->setUser(null);
  1765.             }
  1766.         }
  1768.         return $this;
  1770.     }
  1772.     public function getIsNewClient(): ?bool
  1773.     {
  1774.         return $this->isNewClient;
  1775.     }
  1777.     public function setIsNewClient(?bool $isNewClient): self
  1778.     {
  1779.         $this->isNewClient = $isNewClient;
  1781.         return $this;
  1782.     }
  1784.     public function getAutorizationDateAt(): ?\DateTimeImmutable
  1785.     {
  1786.         return $this->autorizationDateAt;
  1787.     }
  1789.     public function setAutorizationDateAt(?\DateTimeImmutable $autorizationDateAt): self
  1790.     {
  1791.         $this->autorizationDateAt = $autorizationDateAt;
  1793.         return $this;
  1794.     }
  1796.     public function getUserData(): ?UserData
  1797.     {
  1798.         return $this->userData;
  1799.     }
  1801.     public function setUserData(?UserData $userData): self
  1802.     {
  1803.         $this->userData = $userData;
  1805.         return $this;
  1806.     }
  1808.     public function getAcceptPresentation(): ?bool
  1809.     {
  1810.         return $this->acceptPresentation;
  1811.     }
  1813.     public function setAcceptPresentation(?bool $acceptPresentation): self
  1814.     {
  1815.         $this->acceptPresentation = $acceptPresentation;
  1817.         return $this;
  1818.     }
  1820.     public function getDescription(): ?string
  1821.     {
  1822.         return $this->description;
  1823.     }
  1825.     public function setDescription(?string $description): self
  1826.     {
  1827.         $this->description = $description;
  1829.         return $this;
  1830.     }
  1832.     public function getTitle(): ?string
  1833.     {
  1834.         return $this->title;
  1835.     }
  1837.     public function setTitle(?string $title): self
  1838.     {
  1839.         $this->title = $title;
  1841.         return $this;
  1842.     }
  1844.     public function getOneTimeLoginToken(): ?string
  1845.     {
  1846.         return $this->oneTimeLoginToken;
  1847.     }
  1849.     public function setOneTimeLoginToken(?string $oneTimeLoginToken): self
  1850.     {
  1851.         $this->oneTimeLoginToken = $oneTimeLoginToken;
  1853.         return $this;
  1854.     }
  1857.     public function getState(): ?string
  1858.     {
  1859.         return $this->state;
  1860.     }
  1862.     public function setState(?string $state): self
  1863.     {
  1864.         $this->state = $state;
  1865.         return  $this; 
  1866.     }
  1868.     /**
  1869.      * @return Collection|Portfolio[]
  1870.      */
  1871.     public function getPortfolio(): Collection
  1872.     {
  1873.         return $this->portfolio;
  1874.     }
  1876.     public function addPortfolio(Portfolio $portfolio): self
  1877.     {
  1878.         if (!$this->portfolio->contains($portfolio)) {
  1879.             $this->portfolio[] = $portfolio;
  1880.             $portfolio->setUser($this);
  1881.         }
  1883.         return $this;
  1884.     }
  1886.     public function removePortfolio(Portfolio $portfolio): self
  1887.     {
  1888.         if ($this->portfolio->removeElement($portfolio)) {
  1889.             // set the owning side to null (unless already changed)
  1890.             if ($portfolio->getUser() === $this) {
  1891.                 $portfolio->setUser(null);
  1892.             }
  1893.         }
  1895.         return $this;
  1896.     }
  1898.     public function getSalary(): ?bool
  1899.     {
  1900.         return $this->salary;
  1901.     }
  1903.     public function setSalary(?bool $salary): self
  1904.     {
  1905.         $this->salary = $salary;
  1907.         return $this;
  1908.     }
  1910.     public function getAllCompany(): ?bool
  1911.     {
  1912.         return $this->allCompany;
  1913.     }
  1915.     public function setAllCompany(?bool $allCompany): self
  1916.     {
  1917.         $this->allCompany = $allCompany;
  1919.         return $this;
  1920.     }
  1922.     public function getManager(): ?bool
  1923.     {
  1924.         return $this->manager;
  1925.     }
  1927.     public function setManager(?bool $manager): self
  1928.     {
  1929.         $this->manager = $manager;
  1931.         return $this;
  1932.     }
  1934.     /**
  1935.      * @return Collection|Company[]
  1936.      */
  1937.     public function getOtherCompany(): Collection
  1938.     {
  1939.         return $this->otherCompany;
  1940.     }
  1942.     public function addOtherCompany(Company $otherCompany): self
  1943.     {
  1944.         if (!$this->otherCompany->contains($otherCompany)) {
  1945.             $this->otherCompany[] = $otherCompany;
  1946.         }
  1948.         return $this;
  1949.     }
  1951.     public function removeOtherCompany(Company $otherCompany): self
  1952.     {
  1953.         $this->otherCompany->removeElement($otherCompany);
  1955.         return $this;
  1956.     }
  1958.     
  1960.     public function getPartner(): ?bool
  1961.     {
  1962.         return $this->partner;
  1963.     }
  1965.     public function setPartner(?bool $partner): self
  1966.     {
  1967.         $this->partner = $partner;
  1969.         return $this;
  1970.     }
  1972.     public function getParent(): ?self
  1973.     {
  1974.         return $this->parent;
  1975.     }
  1977.     public function setParent(?self $parent): self
  1978.     {
  1979.         $this->parent = $parent;
  1981.         return $this;
  1982.     }
  1984.     /**
  1985.      * @return Collection|User[]
  1986.      */
  1987.     public function getChildren(): Collection
  1988.     {
  1989.         return $this->children;
  1990.     }
  1992.     public function addChild(User $child): self
  1993.     {
  1994.         if (!$this->children->contains($child)) {
  1995.             $this->children[] = $child;
  1996.             $child->setParent($this);
  1997.         }
  1999.         return $this;
  2000.     }
  2002.     public function removeChild(User $child): self
  2003.     {
  2004.         if ($this->children->removeElement($child)) {
  2005.             // set the owning side to null (unless already changed)
  2006.             if ($child->getParent() === $this) {
  2007.                 $child->setParent(null);
  2008.             }
  2009.         }
  2011.         return $this;
  2012.     }
  2015.     public function getOriginalEmail(): ?string
  2016.     {
  2017.         return $this->OriginalEmail;
  2018.     }
  2020.     public function setOriginalEmail(?string $OriginalEmail): self
  2021.     {
  2022.         $this->OriginalEmail = $OriginalEmail;
  2024.         return $this;
  2025.     }
  2027.     /**
  2028.      * @return Collection|SignedContract[]
  2029.      */
  2030.     public function getSignedContracts(): Collection
  2031.     {
  2032.         return $this->signedContracts;
  2033.     }
  2035.     public function addSignedContract(SignedContract $signedContract): self
  2036.     {
  2037.         if (!$this->signedContracts->contains($signedContract)) {
  2038.             $this->signedContracts[] = $signedContract;
  2039.             $signedContract->setUser($this);
  2040.         }
  2042.         return $this;
  2043.     }
  2045.     public function removeSignedContract(SignedContract $signedContract): self
  2046.     {
  2047.         if ($this->signedContracts->removeElement($signedContract)) {
  2048.             // set the owning side to null (unless already changed)
  2049.             if ($signedContract->getUser() === $this) {
  2050.                 $signedContract->setUser(null);
  2051.             }
  2052.         }
  2054.         return $this;
  2055.     }
  2057.     /**
  2058.      * @return Collection|Company[]
  2059.      */
  2060.     public function getCompaniesRepresentative(): Collection
  2061.     {
  2062.         return $this->companiesRepresentative;
  2063.     }
  2065.     public function addCompanyRepresentative(Company $companiesRepresentative): self
  2066.     {
  2067.         if (!$this->companiesRepresentative->contains($companiesRepresentative)) {
  2068.             $this->companiesRepresentative[] = $companiesRepresentative;
  2069.             $companiesRepresentative->setRepresentative($this);
  2070.         }
  2072.         return $this;
  2073.     }
  2075.     public function removeCompanyRepresentative(Company $companiesRepresentative): self
  2076.     {
  2077.         if ($this->companiesRepresentative->removeElement($companiesRepresentative)) {
  2078.             // set the owning side to null (unless already changed)
  2079.             if ($companiesRepresentative->getRepresentative() === $this) {
  2080.                 $companiesRepresentative->setRepresentative(null);
  2081.             }
  2082.         }
  2084.         return $this;
  2085.     }
  2088.     /**
  2089.      * @return Collection|Product[]
  2090.      */
  2091.     public function getProducts(): Collection
  2092.     {
  2093.         return $this->products;
  2094.     }
  2097.     public function addProduct(Product $product): self
  2098.     {
  2099.         if (!$this->products->contains($product)) {
  2100.             $this->products[] = $product;
  2101.             $product->setCreatedBy($this);
  2102.         }
  2104.         return $this;
  2105.     }
  2107.     public function removeProduct(Product $product): self
  2108.     {
  2109.         if ($this->products->removeElement($product)) {
  2110.             // set the owning side to null (unless already changed)
  2111.             if ($product->getCreatedBy() === $this) {
  2112.                 $product->setCreatedBy(null);
  2113.             }
  2114.         }
  2116.         return $this;
  2117.     }
  2119.     /**
  2120.      * @return Collection|WorkflowStep[]
  2121.      */
  2122.     public function getWorkflowSteps(): Collection
  2123.     {
  2124.         return $this->workflowSteps;
  2125.     }
  2127.     public function addWorkflowStep(WorkflowStep $workflowStep): self
  2128.     {
  2129.         if (!$this->workflowSteps->contains($workflowStep)) {
  2130.             $this->workflowSteps[] = $workflowStep;
  2131.             $workflowStep->addUserResponsable($this);
  2132.         }
  2134.         return $this;
  2135.     }
  2137.     public function removeWorkflowStep(WorkflowStep $workflowStep): self
  2138.     {
  2139.         if ($this->workflowSteps->removeElement($workflowStep)) {
  2140.             $workflowStep->removeUserResponsable($this);
  2141.         }
  2143.         return $this;
  2144.     }
  2146.     // for api only
  2147.         public function getListAccount()
  2148.         {
  2149.             return $this->listAccount;
  2150.         }
  2151.         public function setListAccount($listAccount){
  2152.             $this->listAccount = $listAccount;
  2153.             return $this;
  2154.         }
  2156.         public function getRoleName()
  2157.         {
  2158.             return $this->roleName;
  2159.         }
  2160.         public function setRoleName($roleName){
  2161.             $this->roleName = $roleName;
  2162.             return $this;
  2163.         }
  2165.         public function getIdentifier(): ?string
  2166.         {
  2167.             return $this->identifier;
  2168.         }
  2170.         public function setIdentifier(?string $identifier): self
  2171.         {
  2172.             $this->identifier = $identifier;
  2174.             return $this;
  2175.         }
  2177.         /**
  2178.          * @return Collection<int, SharedResourcesCategory>
  2179.          */
  2180.         public function getSharedResourcesCategories(): Collection
  2181.         {
  2182.             return $this->sharedResourcesCategories;
  2183.         }
  2185.         public function addSharedResourcesCategory(SharedResourcesCategory $sharedResourcesCategory): static
  2186.         {
  2187.             if (!$this->sharedResourcesCategories->contains($sharedResourcesCategory)) {
  2188.                 $this->sharedResourcesCategories->add($sharedResourcesCategory);
  2189.                 $sharedResourcesCategory->setCreatedBy($this);
  2190.             }
  2192.             return $this;
  2193.         }
  2195.         public function removeSharedResourcesCategory(SharedResourcesCategory $sharedResourcesCategory): static
  2196.         {
  2197.             if ($this->sharedResourcesCategories->removeElement($sharedResourcesCategory)) {
  2198.                 // set the owning side to null (unless already changed)
  2199.                 if ($sharedResourcesCategory->getCreatedBy() === $this) {
  2200.                     $sharedResourcesCategory->setCreatedBy(null);
  2201.                 }
  2202.             }
  2204.             return $this;
  2205.         }
  2207.         /**
  2208.          * @return Collection<int, CompanyResource>
  2209.          */
  2210.         public function getCompanyResources(): Collection
  2211.         {
  2212.             return $this->companyResources;
  2213.         }
  2215.         public function addCompanyResource(CompanyResource $companyResource): static
  2216.         {
  2217.             if (!$this->companyResources->contains($companyResource)) {
  2218.                 $this->companyResources->add($companyResource);
  2219.                 $companyResource->setCreatedBy($this);
  2220.             }
  2222.             return $this;
  2223.         }
  2225.         public function removeCompanyResource(CompanyResource $companyResource): static
  2226.         {
  2227.             if ($this->companyResources->removeElement($companyResource)) {
  2228.                 // set the owning side to null (unless already changed)
  2229.                 if ($companyResource->getCreatedBy() === $this) {
  2230.                     $companyResource->setCreatedBy(null);
  2231.                 }
  2232.             }
  2234.             return $this;
  2235.         }
  2237.         // public function getFilePermissions(): ?FilePermissions
  2238.         // {
  2239.         //     return $this->filePermissions;
  2240.         // }
  2242.         // public function setFilePermissions(?FilePermissions $filePermissions): static
  2243.         // {
  2244.         //     $this->filePermissions = $filePermissions;
  2246.         //     return $this;
  2247.         // }
  2249.         /**
  2250.          * @return Collection<int, ResourceDeliverableHistory>
  2251.          */
  2252.         public function getResourceDeliverableHistories(): Collection
  2253.         {
  2254.             return $this->resourceDeliverableHistories;
  2255.         }
  2257.         public function addResourceDeliverableHistory(ResourceDeliverableHistory $resourceDeliverableHistory): static
  2258.         {
  2259.             if (!$this->resourceDeliverableHistories->contains($resourceDeliverableHistory)) {
  2260.                 $this->resourceDeliverableHistories->add($resourceDeliverableHistory);
  2261.                 $resourceDeliverableHistory->setCreatedBy($this);
  2262.             }
  2264.             return $this;
  2265.         }
  2267.         public function removeResourceDeliverableHistory(ResourceDeliverableHistory $resourceDeliverableHistory): static
  2268.         {
  2269.             if ($this->resourceDeliverableHistories->removeElement($resourceDeliverableHistory)) {
  2270.                 // set the owning side to null (unless already changed)
  2271.                 if ($resourceDeliverableHistory->getCreatedBy() === $this) {
  2272.                     $resourceDeliverableHistory->setCreatedBy(null);
  2273.                 }
  2274.             }
  2276.             return $this;
  2277.         }
  2279.         /**
  2280.          * @return Collection<int, FilesResourceDeliverableHistory>
  2281.          */
  2282.         public function getFilesResourceDeliverableHistories(): Collection
  2283.         {
  2284.             return $this->filesResourceDeliverableHistories;
  2285.         }
  2287.         public function addFilesResourceDeliverableHistory(FilesResourceDeliverableHistory $filesResourceDeliverableHistory): static
  2288.         {
  2289.             if (!$this->filesResourceDeliverableHistories->contains($filesResourceDeliverableHistory)) {
  2290.                 $this->filesResourceDeliverableHistories->add($filesResourceDeliverableHistory);
  2291.                 $filesResourceDeliverableHistory->setCreatedBy($this);
  2292.             }
  2294.             return $this;
  2295.         }
  2297.         public function removeFilesResourceDeliverableHistory(FilesResourceDeliverableHistory $filesResourceDeliverableHistory): static
  2298.         {
  2299.             if ($this->filesResourceDeliverableHistories->removeElement($filesResourceDeliverableHistory)) {
  2300.                 // set the owning side to null (unless already changed)
  2301.                 if ($filesResourceDeliverableHistory->getCreatedBy() === $this) {
  2302.                     $filesResourceDeliverableHistory->setCreatedBy(null);
  2303.                 }
  2304.             }
  2306.             return $this;
  2307.         }
  2309.         /**
  2310.          * @return Collection<int, FilePermissions>
  2311.          */
  2312.         public function getFilePermissions(): Collection
  2313.         {
  2314.             return $this->filePermissions;
  2315.         }
  2317.         public function addFilePermission(FilePermissions $filePermission): static
  2318.         {
  2319.             if (!$this->filePermissions->contains($filePermission)) {
  2320.                 $this->filePermissions->add($filePermission);
  2321.                 $filePermission->addUser($this);
  2322.             }
  2324.             return $this;
  2325.         }
  2327.         public function removeFilePermission(FilePermissions $filePermission): static
  2328.         {
  2329.             if ($this->filePermissions->removeElement($filePermission)) {
  2330.                 $filePermission->removeUser($this);
  2331.             }
  2333.             return $this;
  2334.         }
  2336.         /**
  2337.          * @return Collection<int, FolderPermissions>
  2338.          */
  2339.         public function getFolderPermissions(): Collection
  2340.         {
  2341.             return $this->folderPermissions;
  2342.         }
  2344.         public function addFolderPermission(FolderPermissions $folderPermission): static
  2345.         {
  2346.             if (!$this->folderPermissions->contains($folderPermission)) {
  2347.                 $this->folderPermissions->add($folderPermission);
  2348.                 $folderPermission->addUser($this);
  2349.             }
  2351.             return $this;
  2352.         }
  2354.         public function removeFolderPermission(FolderPermissions $folderPermission): static
  2355.         {
  2356.             if ($this->folderPermissions->removeElement($folderPermission)) {
  2357.                 $folderPermission->removeUser($this);
  2358.             }
  2360.             return $this;
  2361.         }
  2363.         /**
  2364.          * @return Collection<int, FolderPermissions>
  2365.          */
  2366.         public function getFolderPermissionsCreatedBy(): Collection
  2367.         {
  2368.             return $this->folderPermissionsCreatedBy;
  2369.         }
  2371.         public function addFolderPermissionsCreatedBy(FolderPermissions $folderPermissionsCreatedBy): static
  2372.         {
  2373.             if (!$this->folderPermissionsCreatedBy->contains($folderPermissionsCreatedBy)) {
  2374.                 $this->folderPermissionsCreatedBy->add($folderPermissionsCreatedBy);
  2375.                 $folderPermissionsCreatedBy->setCreatedBy($this);
  2376.             }
  2378.             return $this;
  2379.         }
  2381.         public function removeFolderPermissionsCreatedBy(FolderPermissions $folderPermissionsCreatedBy): static
  2382.         {
  2383.             if ($this->folderPermissionsCreatedBy->removeElement($folderPermissionsCreatedBy)) {
  2384.                 // set the owning side to null (unless already changed)
  2385.                 if ($folderPermissionsCreatedBy->getCreatedBy() === $this) {
  2386.                     $folderPermissionsCreatedBy->setCreatedBy(null);
  2387.                 }
  2388.             }
  2390.             return $this;
  2391.         }
  2393.         /**
  2394.          * @return Collection<int, FilePermissions>
  2395.          */
  2396.         public function getFilePermissionsCreatedBy(): Collection
  2397.         {
  2398.             return $this->filePermissionsCreatedBy;
  2399.         }
  2401.         public function addFilePermissionsCreatedBy(FilePermissions $filePermissionsCreatedBy): static
  2402.         {
  2403.             if (!$this->filePermissionsCreatedBy->contains($filePermissionsCreatedBy)) {
  2404.                 $this->filePermissionsCreatedBy->add($filePermissionsCreatedBy);
  2405.                 $filePermissionsCreatedBy->setCreatedBy($this);
  2406.             }
  2408.             return $this;
  2409.         }
  2411.         public function removeFilePermissionsCreatedBy(FilePermissions $filePermissionsCreatedBy): static
  2412.         {
  2413.             if ($this->filePermissionsCreatedBy->removeElement($filePermissionsCreatedBy)) {
  2414.                 // set the owning side to null (unless already changed)
  2415.                 if ($filePermissionsCreatedBy->getCreatedBy() === $this) {
  2416.                     $filePermissionsCreatedBy->setCreatedBy(null);
  2417.                 }
  2418.             }
  2420.             return $this;
  2421.         }
  2423.     
  2424. }