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;
  66.     #[ORM\Column(type: 'boolean', nullable: true)]
  67.     #[Groups(['mission_list','mission_read','message_read','user_read'])]
  68.     private ?bool $shareMyWhatsapp = false;
  70.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  71.     #[Groups(['mission_list','mission_read','message_read','user_read'])]
  72.     private ?string $myWhatsappLink = null;
  74.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  75.     // #[Assert\NotBlank(message: 'Ce champs est requis')]
  76.     #[Groups(['user_read', 'mission_read','mission_list','message_read', 'mission_participant_write', 'message_write','user_directory'])]
  77.     private ?string $lastname = null;
  79.     #[ORM\Column(type: 'string', nullable: true)]
  80.     #[Groups(['user_read', 'mission_read','mission_list','message_read', 'mission_participant_write'])]
  81.     private ?string $cellPhone = null;
  83.     #[ORM\Column(type: 'boolean', nullable: true)]
  84.     #[Groups(['mission_list','user_read', 'mission_read','message_read', 'mission_participant_write'])]
  85.     private ?bool $enabled = false;
  87.      #[ORM\Column(type: 'boolean', nullable: true)]
  88.     private ?bool $external = false;
  90.     #[ORM\Column(type: 'decimal', precision: 10, scale: 2, nullable: true)]
  91.     #[Groups(['mission_list','user_read','message_read','mission_read'])]
  92.     private ?float $dailyRate = null;
  94.     #[ORM\Column(type: 'decimal', precision: 10, scale: 2, nullable: true)]
  95.     #[Groups(['mission_list','user_read','message_read','mission_read'])]
  96.     private ?float $resaleRate = null;
  98.     #[ORM\Column(type: 'smallint', nullable: true)]
  99.     private ?int $billingMethod = 0;
  101.     /**
  102.      * @Vich\UploadableField(mapping="sub_contractor_image", fileNameProperty="pictureName")
  103.      */
  104.     #[Assert\File(mimeTypes: ['image/png', 'image/jpeg', 'image/jpg','image/webp'], mimeTypesMessage: 'Les formats supportés sont : PNG, JPEG, JPG')]
  105.     private ?File $picture = null;
  107.     #[ORM\Column(type: 'string', nullable: true)]
  108.     #[Groups(['mission_list','user_read', 'mission_read','message_read','user_directory'])]
  110.     private ?string $pictureName = null;
  112.     #[ORM\Column(type: 'datetime', nullable: true)]
  113.     #[Groups(['mission_list','user_read','message_read'])]
  114.     private ?\DateTimeInterface $updatedAt = null;
  116.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  117.     #[Assert\NotBlank(message: 'Ce champ est requis')]
  118.     // #[Assert\Email(message: 'Cette adresse n\'est pas valide')]
  119.     #[Groups(['mission_list','user_read', 'mission_read','message_read', 'mission_participant_write'])]
  120.     private string $email = '';
  122.     #[ORM\Column(type: 'string', length: 180, nullable: true)]
  124.     private $OriginalEmail ;
  126.     #[ORM\Column(type: 'json')]
  127.     #[Groups(['user_read'])]
  128.     private array $roles = [];
  130.     #[ORM\Column(type: 'string')]
  131.     private string $password = '';
  133.     #[Assert\Length(min: 8, minMessage: 'Le mot de passe doit faire 8 charactères minimum')]
  134.     #[Assert\NotCompromisedPassword(message: 'Votre mot de passe est trop faible, merci d\'en choisir un plus fort', threshold: 50000)]
  135.     private ?string $plainPassword = null;
  137.     #[ORM\Column(type: 'datetime', nullable: true)]
  138.     private ?\DateTimeInterface $createdAt;
  140.     #[ORM\Column(type: 'datetime', nullable: true)]
  141.     private ?\DateTimeInterface $lastConnectionAt = null;
  143.     #[ORM\Column(type: 'string', nullable: true)]
  144.     private ?string $accountType;
  146.     #[ORM\ManyToOne(targetEntity: Company::class, inversedBy: 'users')]
  147.     #[Groups(['user_read','message_read'])]
  148.     private ?Company $company;
  150.     #[ORM\ManyToMany(inversedBy: 'otherUser',targetEntity: Company::class)]
  151.     private $otherCompany;
  153.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Message::class)]
  154.     private $messages;
  156.    
  157.     #[ORM\OneToOne(targetEntity: UserData::class, cascade: ['persist', 'remove'])]
  158.     private ?UserData $userData;
  161.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: FileMission::class)]
  162.     private $fileMissions;
  165.     #[ORM\ManyToMany(mappedBy: 'user', targetEntity: WorkflowAction::class)]
  166.     private $workflowAction;
  168.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InfoMission::class)]
  169.     private $infoMissions;
  171.     #[ORM\OneToMany(mappedBy: 'contact', targetEntity: Mission::class)]
  172.     private $missions;
  174.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Historique::class)]
  175.     private $historiques;
  177.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: CreditHistory::class)]
  178.     private $creditHistories;
  180.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: Campaign::class)]
  181.     private $campaigns;
  183.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SubContractorCompany::class, cascade: ["persist"])]
  184.     private $subContractorCompanies;
  186.     #[ORM\Column(type: 'json', nullable: true)]
  187.     #[Groups(['user_read'])]
  188.     private ?array $notificationType = [0,1,2];
  190.     #[ORM\Column(type: 'json', nullable: true)]
  191.     #[Groups(['user_read'])]
  192.     private ?array $notification = [0,1,2,3,4,5];
  194.     #[ORM\Column(type: 'json', nullable: true)]
  195.     #[Groups(['user_read'])]
  196.     private $freqNotification = [1];
  199.     #[ORM\Column(type: 'json', nullable: true)]
  200.     #[Groups(['user_read'])]
  201.     private $freqNotificationEverytime = [1,3,5,8];
  203.     #[ORM\Column(type: 'json', nullable: true)]
  204.     #[Groups(['user_read'])]
  205.     private $freqNotificationPerDay = [0,2];
  207.     #[ORM\Column(type: 'json', nullable: true)]
  208.     #[Groups(['user_read'])]
  209.     private $freqNotificationPerWeek = [6];
  211.     #[ORM\Column(type: 'json', nullable: true)]
  212.     #[Groups(['user_read'])]
  213.     private $freqNotificationPerMonth = [];
  215.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Device::class)]
  216.     private $devices;
  218.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Service::class)]
  219.     #[Groups(['user_read'])]
  220.     private $services;
  222.     #[ORM\ManyToMany(targetEntity: Job::class, mappedBy: 'user')]
  223.     #[Groups(['user_directory','user_read'])]
  225.     private $jobs;
  227.     #[ORM\Column(type: 'boolean', options: ['default' => false])]
  228.     private ?bool $isActiveNotification = false;
  230.     #[ORM\Column(type: 'boolean')]
  231.     #[Groups(['mission_list','user_read', 'mission_read', 'mission_participant_write'])]
  232.     private ?bool $deleted = false;
  234.     #[ORM\Column(type: 'boolean')]
  235.     private ?bool $referencingConfirmationNotification = false;
  237.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  238.     #[Groups(['user_read'])]
  239.     private $gender;
  241.     #[ORM\OneToMany(mappedBy: 'orderBy', targetEntity: BalanceTransactions::class)]
  242.     private $balanceTransactions;
  244.     #[ORM\Column(type: 'array', nullable: true)]
  245.     private $deviceConnectedList = [];
  247.     #[ORM\Column(type: 'array', nullable: true)]
  248.     private $mailAlias = [];
  250.     #[ORM\Column]
  251.     private ?bool $invisible = null;
  253.     #[ORM\Column(nullable: true)]
  254.     private ?\DateTimeImmutable $lastActivityAt = null;
  256.     #[ORM\Column(nullable: true)]
  257.     private ?bool $isLogged = null;
  259.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: MessageReaction::class)]
  260.     private Collection $messageReactions;
  262.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Emoji::class)]
  263.     private Collection $emoji;
  265.     #[ORM\OneToMany(mappedBy: 'orderedBy', targetEntity: CommandeLogging::class)]
  266.     private $commandeLoggings;
  269.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Support::class, orphanRemoval: true,cascade: ["persist"])]
  270.     private $supports;
  271.     
  273.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ConfidentialityContract::class)]
  274.     private Collection $confidentialityContracts;
  276.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: CampaignPendingToSend::class)]
  277.     private $campaignPendingToSends;
  280.     private $resetToken = null;
  282.     #[ORM\Column(type: 'boolean', nullable: true)]
  283.     private $isNewClient;
  285.     #[ORM\Column(type: 'datetime_immutable', nullable: true)]
  286.     private $autorizationDateAt;
  288.     #[ORM\Column(type: 'boolean', nullable: true)]
  290.     private $acceptPresentation;
  292.     #[ORM\Column(type: 'text', nullable: true)]  
  293.     #[Groups(['user_directory'])]
  294.     private $description;
  296.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  297.     #[Groups(['user_directory'])]
  298.     private $title;
  300.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  301.     private $oneTimeLoginToken;
  303.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  304.     private $state; 
  305.     
  306.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Portfolio::class)]
  307.     #[Groups(['user_directory'])]
  308.     private $portfolio; 
  310.     #[ORM\ManyToOne(targetEntity: User::class, inversedBy: 'children',cascade: ["persist"])]
  311.     private $parent;
  313.     #[ORM\OneToMany(mappedBy: 'parent', targetEntity: User::class,cascade: ["persist"])]
  314.     private $children;
  316.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SignedContract::class)]
  317.     private $signedContracts;
  319.     #[ORM\OneToMany(mappedBy: 'representative', targetEntity: Company::class)]
  320.     private $companiesRepresentative;
  321.     private $originalEmail = "";
  323.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: Product::class)]
  324.     private $products;
  326.     #[ORM\ManyToMany(targetEntity: WorkflowStep::class, mappedBy: 'userResponsable')]
  327.     private $workflowSteps;
  329.     //only for API
  330.     #[Groups(['user_read'])]
  331.     private $listAccount;
  333.     #[Groups(['user_read'])]
  334.     private $originalMailUser = "";
  336.     #[Groups(['user_read'])]
  337.     private $roleName ="";
  339.     #[Groups(['user_read'])]
  340.     private $lastActivityInMinute = 99999;
  341.     ///////
  343.     private $fullName;
  344.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  345.     #[Groups(['message_read', 'mission_read', 'message_write'])]
  347.     private $identifier;
  349.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: SharedResourcesCategory::class)]
  350.     private Collection $sharedResourcesCategories;
  353.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: CompanyResource::class)]
  354.     private Collection $companyResources;
  357.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: ResourceDeliverableHistory::class)]
  358.     private Collection $resourceDeliverableHistories;
  360.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FilesResourceDeliverableHistory::class)]
  361.     private Collection $filesResourceDeliverableHistories;
  363.     #[ORM\ManyToMany(targetEntity: FilePermissions::class, mappedBy: 'user')]
  364.     private Collection $filePermissions;
  366.     #[ORM\ManyToMany(targetEntity: FolderPermissions::class, mappedBy: 'user')]
  367.     private Collection $folderPermissions;
  369.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FolderPermissions::class)]
  370.     private Collection $folderPermissionsCreatedBy;
  372.     #[ORM\OneToMany(mappedBy: 'createdBy', targetEntity: FilePermissions::class)]
  373.     private Collection $filePermissionsCreatedBy;
  375.      #[ORM\OneToMany(mappedBy: 'user', targetEntity: noteUser::class, cascade: ["persist", "remove"], orphanRemoval: true)]
  376.     private ?Collection $noteUser;
  378.      #[ORM\OneToMany(mappedBy: 'user', targetEntity: AppPromotion::class)]
  379.      private Collection $appPromotions;
  381.      #[ORM\Column(length: 255, nullable: true)]
  382.      private ?string $myFlowEmail = null;
  383.     
  384.     
  385.     public function __construct()
  386.     {
  387.         $this->id = Uuid::v4()->toBase58();
  388.         $this->createdAt = new \DateTime('now');
  389.         $this->messages = new ArrayCollection();
  390.         $this->infoMissions = new ArrayCollection();
  391.         $this->missions = new ArrayCollection();
  392.         $this->historiques = new ArrayCollection();
  393.         $this->creditHistories = new ArrayCollection();
  394.         $this->campaigns = new ArrayCollection();
  395.         $this->subContractorCompanies = new ArrayCollection();
  396.         $this->devices = new ArrayCollection();
  397.         $this->services = new ArrayCollection();
  398.         $this->jobs = new ArrayCollection();
  399.         $this->balanceTransactions = new ArrayCollection();
  400.         $this->invisible = false;
  401.         $this->company = null;
  402.         $this->dailyRate = 0;
  403.         $this->resaleRate = 0;
  404.         $this->workflowAction = new ArrayCollection();
  406.         $this->messageReactions = new ArrayCollection();
  407.         $this->emoji = new ArrayCollection();
  408.         $this->commandeLoggings = new ArrayCollection();
  411.         $this->supports = new ArrayCollection();
  412.         $this->confidentialityContracts = new ArrayCollection();
  414.         $this->campaignPendingToSends = new ArrayCollection();
  415.         $this->fileMissions = new ArrayCollection();
  417.         $this->isNewClient = false;
  418.         $this->autorizationDateAt = new \DateTimeImmutable();
  419.         $this->state = 'enabled'; 
  420.         $this->portfolio = new ArrayCollection();
  421.         $this->otherCompany = new ArrayCollection();
  422.         $this->children = new ArrayCollection();
  423.         $this->signedContracts = new ArrayCollection();
  424.         $this->companiesRepresentative = new ArrayCollection();
  425.         $this->products = new ArrayCollection();
  426.         $this->workflowSteps = new ArrayCollection();
  427.         $this->sharedResourcesCategories = new ArrayCollection();
  428.         $this->companyResources = new ArrayCollection();
  429.         $this->resourceDeliverableHistories = new ArrayCollection();
  430.         $this->filesResourceDeliverableHistories = new ArrayCollection();
  431.         $this->filePermissions = new ArrayCollection();
  432.         $this->folderPermissions = new ArrayCollection();
  433.         $this->folderPermissionsCreatedBy = new ArrayCollection();
  434.         $this->filePermissionsCreatedBy = new ArrayCollection();
  435.         $this->noteUser = new ArrayCollection();
  436.         $this->appPromotions = new ArrayCollection();
  437.         $this->roles= ['ROLE_OBSERVER_EXTERNAL'];
  439.     }
  441.     public function getId(): ?string
  442.     {
  443.         return $this->id;
  444.     }
  445.     public function setId($id){
  446.         $this->id = $id;
  447.         return $this;
  448.     }
  450.     public function __toString(): string
  451.     {
  452.         return $this->getFirstname().' '.$this->getLastname();
  453.     }
  455.     public function getEmail(): ?string
  456.     {
  458.         if ($this->getOriginalEmail() != null) {
  459.             return $this->getOriginalEmail();
  460.         }
  462.         return $this->email;
  463.     }
  465.     public function getOriginalMailUser(): ?string
  466.     {
  467.         return $this->email;
  468.     }
  470.     //  public function getOriginalEmail(): ?string
  471.     // {
  472.     //     return $this->email;
  473.     // }
  475.     public function setEmail(string $email): self
  476.     {
  477.         $this->email = $email;
  479.         return $this;
  480.     }
  482.     /**
  483.      * A visual identifier that represents this user.
  484.      *
  485.      * @see UserInterface
  486.      */
  487.     public function getUserIdentifier(): string
  488.     {
  489.         return (string) $this->email;
  490.     }
  492.     /**
  493.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  494.      */
  495.     public function getUsername(): string
  496.     {
  497.         return (string) $this->email;
  498.     }
  500.     /**
  501.      * @see UserInterface
  502.      */
  503.     public function getRoles(): array
  504.     {
  505.         $roles = $this->roles;
  506.         // if (isset($_SESSION['_sf2_attributes']['role_current_user']) and null !== $_SESSION['_sf2_attributes']['role_current_user']) {
  507.         //    $roles[0]= $_SESSION['_sf2_attributes']['role_current_user'];
  508.         // }
  509.         // $roles[0]='ROLE_MANAGER';
  510.         // guarantee every user at least has ROLE_USER
  511.         $roles[] = 'ROLE_USER';
  513.         return array_unique($roles);
  514.     }
  515.     public function getOriginalRoles(): array 
  516.     {
  517.         $roles = $this->roles;
  518.         // $roles[0]='ROLE_MANAGER';
  519.         // guarantee every user at least has ROLE_USER
  520.         $roles[] = 'ROLE_USER';
  522.         return array_unique($roles);
  523.     }
  525.     public function setRoles(array $roles): self
  526.     {
  527.         $this->roles = $roles;
  529.         return $this;
  530.     }
  532.     /**
  533.      * @see PasswordAuthenticatedUserInterface
  534.      */
  535.     public function getPassword(): string
  536.     {
  537.         return $this->password;
  538.     }
  540.     public function setPassword(string $password): self
  541.     {
  542.         
  543.         $this->password = $password;
  545.         return $this;
  546.     }
  548.     /**
  549.      * Returning a salt is only needed, if you are not using a modern
  550.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  551.      *
  552.      * @see UserInterface
  553.      */
  554.     public function getSalt(): ?string
  555.     {
  556.         return null;
  557.     }
  559.     /**
  560.      * @see UserInterface
  561.      */
  562.     public function eraseCredentials()
  563.     {
  564.         // If you store any temporary, sensitive data on the user, clear it here
  565.         // $this->plainPassword = null;
  566.     }
  568.     /**
  569.      * @return string|null
  570.      */
  571.     public function getFirstname(): ?string
  572.     {
  573.         return $this->firstname;
  574.     }
  576.     /**
  577.      * @param mixed $firstname
  578.      */
  579.     public function setFirstname(?string $firstname): self
  580.     {
  581.         $this->firstname = $firstname;
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return string|null
  588.      */
  589.     public function getLastname(): ?string
  590.     {
  591.         return $this->lastname;
  592.     }
  594.     /**
  595.      * @param mixed $lastname
  596.      */
  597.     public function setLastname(?string $lastname): self
  598.     {
  599.         $this->lastname = $lastname;
  601.         return $this;
  602.     }
  604.     /**
  605.      * @return string|null
  606.      */
  607.     public function getCellPhone(): ?string
  608.     {
  609.         return $this->cellPhone;
  610.     }
  612.     /**
  613.      * @param mixed $cellPhone
  614.      */
  615.     public function setCellPhone(?string $cellPhone): self
  616.     {
  617.         $this->cellPhone = $cellPhone;
  619.         return $this;
  620.     }
  622.     /**
  623.      * @return bool
  624.      */
  625.     public function isEnabled(): bool
  626.     {
  627.         return $this->enabled;
  628.     }
  630.     /**
  631.      * @param int $enabled
  632.      */
  633.     public function setEnabled(bool $enabled): self
  634.     {
  635.         if (is_null($this->getParent()) and $enabled) {
  636.             foreach ($this->getChildren() as $userChild) {
  637.                 $userChild->setEnabled($enabled);
  638.             }
  639.         }
  640.         $this->enabled = $enabled;
  642.         return $this;
  643.     }
  645.     /**
  646.      * @return bool|null
  647.      */
  648.     public function isExternal(): ?bool
  649.     {
  650.         return $this->external;
  651.     }
  653.     /**
  654.      * @param int $external
  655.      */
  656.     public function setExternal(bool $external): self
  657.     {
  658.         $this->external = $external;
  660.         return $this;
  661.     }
  663.     /**
  664.      * @return mixed
  665.      */
  666.     public function getDailyRate(): ?string
  667.     {
  668.         return $this->dailyRate;
  669.     }
  671.     /**
  672.      * @param mixed $dailyRate
  673.      */
  674.     public function setDailyRate(?string $dailyRate): void
  675.     {
  676.         $this->dailyRate = $dailyRate;
  677.     }
  679.     /**
  680.      * @return mixed
  681.      */
  682.     public function getBillingMethod(): ?string
  683.     {
  684.         return $this->billingMethod;
  685.     }
  687.     /**
  688.      * @param mixed $billingMethod
  689.      */
  690.     public function setBillingMethod(?string $billingMethod): void
  691.     {
  692.         $this->billingMethod = $billingMethod;
  693.     }
  695.     public function serialize()
  696.     {
  697.         $this->picture = base64_encode($this->picture);
  698.     }
  700.     public function unserialize($serialized)
  701.     {
  702.         $this->picture = base64_decode($this->picture);
  703.     }
  705.     /**
  706.      * @return File|null
  707.      */
  708.     public function getPicture(): ?File
  709.     {
  710.         return $this->picture;
  711.     }
  713.     public function setPicture(?File $picture = null): void
  714.     {
  715.         $this->picture = $picture;
  717.         if (null !== $picture) {
  718.             // It is required that at least one field changes if you are using doctrine
  719.             // otherwise the event listeners won't be called and the file is lost
  720.             $this->updatedAt = new \DateTimeImmutable();
  721.         }
  722.     }
  724.     public function getUpdatedAt(): ?\DateTimeInterface
  725.     {
  726.         return $this->updatedAt;
  727.     }
  729.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  730.     {
  731.         $this->updatedAt = $updatedAt;
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return string|null
  738.      */
  739.     public function getPictureName(): ?string
  740.     {
  741.         return $this->pictureName;
  742.     }
  744.     /**
  745.      * @param string|null $pictureName
  746.      */
  747.     public function setPictureName(?string $pictureName): void
  748.     {
  749.         $this->pictureName = $pictureName;
  750.     }
  752.     /**
  753.      * @return \DateTimeInterface|null
  754.      */
  755.     public function getCreatedAt(): ?\DateTimeInterface
  756.     {
  757.         return $this->createdAt;
  758.     }
  760.     /**
  761.      * @param \DateTimeInterface|null $createdAt
  762.      */
  763.     public function setCreatedAt(?\DateTimeInterface $createdAt): void
  764.     {
  765.         $this->createdAt = $createdAt;
  766.     }
  768.     /**
  769.      * @return \DateTimeInterface|null
  770.      */
  771.     public function getLastConnectionAt(): ?\DateTimeInterface
  772.     {
  773.         return $this->lastConnectionAt;
  774.     }
  776.     /**
  777.      * @param \DateTimeInterface|null $lastConnectionAt
  778.      * @return User
  779.      */
  780.     public function setLastConnectionAt(?\DateTimeInterface $lastConnectionAt): User
  781.     {
  782.         $this->lastConnectionAt = $lastConnectionAt;
  783.         return $this;
  784.     }
  786.     public function getPlainPassword(): ?string
  787.     {
  788.         return $this->plainPassword;
  789.     }
  791.     public function setPlainPassword(?string $password): self
  792.     {
  793.         $this->plainPassword = $password;
  795.         return $this;
  796.     }
  798.     /**
  799.      * @return string|null
  800.      */
  801.     public function getAccountType(): ?string
  802.     {
  803.         return $this->accountType;
  804.     }
  806.     /**
  807.      * @param string|null $accountType
  808.      * @return User
  809.      */
  810.     public function setAccountType(?string $accountType): User
  811.     {
  812.         $this->accountType = $accountType;
  813.         return $this;
  814.     }
  816.     public function getCompany(): ?Company
  817.     {
  818.         return $this->company;
  819.     }
  821.     public function setCompany(?Company $company): self
  822.     {
  823.         $this->company = $company;
  825.         return $this;
  826.     }
  828.     /**
  829.      * @return Collection|Message[]
  830.      */
  831.     public function getMessages(): Collection
  832.     {
  833.         return $this->messages;
  834.     }
  836.     public function addMessage(Message $message): self
  837.     {
  838.         if (!$this->messages->contains($message)) {
  839.             $this->messages[] = $message;
  840.             $message->setUser($this);
  841.         }
  843.         return $this;
  844.     }
  846.     public function removeMessage(Message $message): self
  847.     {
  848.         if ($this->messages->removeElement($message)) {
  849.             // set the owning side to null (unless already changed)
  850.             if ($message->getUser() === $this) {
  851.                 $message->setUser(null);
  852.             }
  853.         }
  855.         return $this;
  856.     }
  858.     /**
  859.      * @return Collection|InfoMission[]
  860.      */
  861.     public function getInfoMissions(): Collection
  862.     {
  863.         return $this->infoMissions;
  864.     }
  866.     public function addInfoMission(InfoMission $infoMission): self
  867.     {
  868.         if (!$this->infoMissions->contains($infoMission)) {
  869.             $this->infoMissions[] = $infoMission;
  870.             $infoMission->setUser($this);
  871.         }
  873.         return $this;
  874.     }
  876.     public function removeInfoMission(InfoMission $infoMission): self
  877.     {
  878.         if ($this->infoMissions->removeElement($infoMission)) {
  879.             // set the owning side to null (unless already changed)
  880.             if ($infoMission->getUser() === $this) {
  881.                 $infoMission->setUser(null);
  882.             }
  883.         }
  885.         return $this;
  886.     }
  888.     /**
  889.      * @return Collection|Mission[]
  890.      */
  891.     public function getMissions(): Collection
  892.     {
  893.         return $this->missions;
  894.     }
  896.     public function addMission(Mission $mission): self
  897.     {
  898.         if (!$this->missions->contains($mission)) {
  899.             $this->missions[] = $mission;
  900.             $mission->setContact($this);
  901.         }
  903.         return $this;
  904.     }
  906.     public function removeMission(Mission $mission): self
  907.     {
  908.         if ($this->missions->removeElement($mission)) {
  909.             // set the owning side to null (unless already changed)
  910.             if ($mission->getContact() === $this) {
  911.                 $mission->setContact(null);
  912.             }
  913.         }
  915.         return $this;
  916.     }
  918.     /**
  919.      * @return Collection|Historique[]
  920.      */
  921.     public function getHistoriques(): Collection
  922.     {
  923.         return $this->historiques;
  924.     }
  926.     public function addHistorique(Historique $historique): self
  927.     {
  928.         if (!$this->historiques->contains($historique)) {
  929.             $this->historiques[] = $historique;
  930.             $historique->setUser($this);
  931.         }
  933.         return $this;
  934.     }
  936.     public function removeHistorique(Historique $historique): self
  937.     {
  938.         if ($this->historiques->removeElement($historique)) {
  939.             // set the owning side to null (unless already changed)
  940.             if ($historique->getUser() === $this) {
  941.                 $historique->setUser(null);
  942.             }
  943.         }
  945.         return $this;
  946.     }
  948.     /**
  949.      * @return Collection|SubContractorCompany[]
  950.      */
  951.     public function getSubContractorCompanies(): Collection
  952.     {
  953.         return $this->subContractorCompanies;
  954.     }
  956.     public function addSubContractorCompany(SubContractorCompany $subContractorCompany): self
  957.     {
  958.         if (!$this->subContractorCompanies->contains($subContractorCompany)) {
  959.             $this->subContractorCompanies[] = $subContractorCompany;
  960.             $subContractorCompany->setUser($this);
  961.         }
  963.         return $this;
  964.     }
  966.     public function removeSubContractorCompany(SubContractorCompany $subContractorCompany): self
  967.     {
  968.         if ($this->subContractorCompanies->removeElement($subContractorCompany)) {
  969.             // set the owning side to null (unless already changed)
  970.             if ($subContractorCompany->getUser() === $this) {
  971.                 $subContractorCompany->setUser(null);
  972.             }
  973.         }
  975.         return $this;
  976.     }
  978.     /**
  979.      * @return Collection|Device[]
  980.      */
  981.     public function getDevices(): Collection
  982.     {
  983.         return $this->devices;
  984.     }
  986.     public function addDevice(Device $device): self
  987.     {
  988.         if (!$this->devices->contains($device)) {
  989.             $this->devices[] = $device;
  990.             $device->setUser($this);
  991.         }
  993.         return $this;
  994.     }
  996.     public function removeDevice(Device $device): self
  997.     {
  998.         if ($this->devices->removeElement($device)) {
  999.             // set the owning side to null (unless already changed)
  1000.             if ($device->getUser() === $this) {
  1001.                 $device->setUser(null);
  1002.             }
  1003.         }
  1005.         return $this;
  1006.     }
  1008.     /**
  1009.      * @return Collection|Service[]
  1010.      */
  1011.     public function getServices(): Collection
  1012.     {
  1013.         return $this->services;
  1014.     }
  1016.     public function addService(Service $service): self
  1017.     {
  1018.         if (!$this->services->contains($service)) {
  1019.             $this->services[] = $service;
  1020.             $service->setUser($this);
  1021.         }
  1023.         return $this;
  1024.     }
  1026.     public function removeService(Service $service): self
  1027.     {
  1028.         if ($this->services->removeElement($service)) {
  1029.             // set the owning side to null (unless already changed)
  1030.             if ($service->getUser() === $this) {
  1031.                 $service->setUser(null);
  1032.             }
  1033.         }
  1035.         return $this;
  1036.     }
  1038.     /**
  1039.      * @return array|null
  1040.      */
  1041.     public function getNotificationType(): ?array
  1042.     {
  1043.         return $this->notificationType;
  1044.     }
  1046.     /**
  1047.      * @param array|null $notificationType
  1048.      */
  1049.     public function setNotificationType(?array $notificationType): void
  1050.     {
  1051.         $this->notificationType = $notificationType;
  1052.     }
  1054.     /**
  1055.      * @return array|null
  1056.      */
  1057.     public function getNotification(): ?array
  1058.     {
  1059.         return $this->notification;
  1060.     }
  1062.     /**
  1063.      * @param array|null $notification
  1064.      */
  1065.     public function setNotification(?array $notification): void
  1066.     {
  1067.         $this->notification = $notification;
  1068.     }
  1070.     /**
  1071.      * @return Collection|Job[]
  1072.      */
  1073.     public function getJobs(): Collection
  1074.     {
  1075.         return $this->jobs;
  1076.     }
  1078.     public function addJob(Job $job): self
  1079.     {
  1080.         if (!$this->jobs->contains($job)) {
  1081.             $this->jobs[] = $job;
  1082.             $job->addUser($this);
  1083.         }
  1085.         return $this;
  1086.     }
  1088.     public function removeJob(Job $job): self
  1089.     {
  1090.         if ($this->jobs->removeElement($job)) {
  1091.             $job->removeUser($this);
  1092.         }
  1094.         return $this;
  1095.     }
  1097.     public function getIsActiveNotification(): ?bool
  1098.     {
  1099.         return $this->isActiveNotification;
  1100.     }
  1102.     public function setIsActiveNotification(bool $isActiveNotification): self
  1103.     {
  1104.         $this->isActiveNotification = $isActiveNotification;
  1106.         return $this;
  1107.     }
  1109.     public function getDeleted(): ?bool
  1110.     {
  1111.         return $this->deleted;
  1112.     }
  1114.     public function setDeleted(bool $deleted): self
  1115.     {
  1116.         $this->deleted = $deleted;
  1118.         return $this;
  1119.     }
  1121.     
  1122.     /**
  1123.      * @return array|null
  1124.      */
  1125.     public function getFreqNotification(): ?array
  1126.     {
  1127.         return $this->freqNotification;
  1128.     }
  1130.     /**
  1131.      * @param int|null $freqNotification
  1132.      */
  1133.     public function setFreqNotification(?array $freqNotification): void
  1134.     {
  1135.         $this->freqNotification = $freqNotification;
  1136.     }
  1138.     /**
  1139.      * @return array|null
  1140.      */
  1141.     public function getFreqNotificationEverytime(): ?array
  1142.     {
  1143.         return $this->freqNotificationEverytime;
  1144.     }
  1146.     /**
  1147.      * @param int|null $freqNotification
  1148.      */
  1149.     public function setFreqNotificationEverytime(?array $freqNotificationEverytime): void
  1150.     {
  1151.         $this->freqNotificationEverytime = $freqNotificationEverytime;
  1152.     }
  1154.      /**
  1155.      * @return array|null
  1156.      */
  1157.     public function getFreqNotificationPerDay(): ?array
  1158.     {
  1159.         return $this->freqNotificationPerDay;
  1160.     }
  1162.     /**
  1163.      * @param int|null $freqNotification
  1164.      */
  1165.     public function setFreqNotificationPerDay(?array $freqNotificationPerDay): void
  1166.     {
  1167.         $this->freqNotificationPerDay = $freqNotificationPerDay;
  1168.     }
  1169.     /**
  1170.      * @return array|null
  1171.      */
  1172.     public function getFreqNotificationPerWeek(): ?array
  1173.     {
  1174.         return $this->freqNotificationPerWeek;
  1175.     }
  1177.     /**
  1178.      * @param int|null $freqNotification
  1179.      */
  1180.     public function setFreqNotificationPerWeek(?array $freqNotificationPerWeek): void
  1181.     {
  1182.         $this->freqNotificationPerWeek = $freqNotificationPerWeek;
  1183.     }
  1185.     /**
  1186.      * @return array|null
  1187.      */
  1188.     public function getFreqNotificationPerMonth(): ?array
  1189.     {
  1190.         return $this->freqNotificationPerMonth;
  1191.     }
  1193.     /**
  1194.      * @param int|null $freqNotification
  1195.      */
  1196.     public function setFreqNotificationPerMonth(?array $freqNotificationPerMonth): void
  1197.     {
  1198.         $this->freqNotificationPerMonth = $freqNotificationPerMonth;
  1199.     }
  1201.     /**
  1202.      * @return float|null
  1203.      */
  1204.     public function getResaleRate(): ?float
  1205.     {
  1206.         return $this->resaleRate;
  1207.     }
  1209.     /**
  1210.      * @param float|null $resaleRate
  1211.      */
  1212.     public function setResaleRate(?float $resaleRate): void
  1213.     {
  1215.         //mettre 30% si le prix de vente est 0 ou null 
  1216.         if (($this->getResaleRate() == null or $this->getResaleRate() == 0)) {
  1217.             if ($this->getDailyRate() != null and $this->getDailyRate() > 0) {
  1218.                 $this->resaleRate = $this->getDailyRate() + ($this->getDailyRate() * 0.3);
  1219.             }else{
  1220.                 $this->resaleRate = $resaleRate;
  1221.             }
  1222.         }else{
  1223.             $this->resaleRate = $resaleRate;
  1224.         }
  1225.     }
  1227.     public function getReferencingConfirmationNotification(): ?bool
  1228.     {
  1229.         return $this->referencingConfirmationNotification;
  1230.     }
  1232.     public function setReferencingConfirmationNotification(bool $referencingConfirmationNotification): self
  1233.     {
  1234.         $this->referencingConfirmationNotification = $referencingConfirmationNotification;
  1236.         return $this;
  1237.     }
  1239.     public function getGender(): ?string
  1240.     {
  1241.         return $this->gender;
  1242.     }
  1244.     public function setGender(?string $gender): self
  1245.     {
  1246.         $this->gender = $gender;
  1248.         return $this;
  1249.     }
  1251.     public function getFullName():?string
  1252.     {
  1253.         return $this->getFirstname()."  ". $this->getLastname();
  1254.     }
  1256.     /**
  1257.      * @return Collection|BalanceTransactions[]
  1258.      */
  1259.     public function getBalanceTransactions(): Collection
  1260.     {
  1261.         return $this->balanceTransactions;
  1262.     }
  1264.     public function addBalanceTransaction(BalanceTransactions $balanceTransaction): self
  1265.     {
  1266.         if (!$this->balanceTransactions->contains($balanceTransaction)) {
  1267.             $this->balanceTransactions[] = $balanceTransaction;
  1268.             $balanceTransaction->setOrderBy($this);
  1269.         }
  1271.         return $this;
  1272.     }
  1274.     public function removeBalanceTransaction(BalanceTransactions $balanceTransaction): self
  1275.     {
  1276.         if ($this->balanceTransactions->removeElement($balanceTransaction)) {
  1277.             // set the owning side to null (unless already changed)
  1278.             if ($balanceTransaction->getOrderBy() === $this) {
  1279.                 $balanceTransaction->setOrderBy(null);
  1280.             }
  1281.         }
  1283.         return $this;
  1284.     }
  1286.     public function getDeviceConnectedList(): ?array
  1287.     {
  1288.         return $this->deviceConnectedList;
  1289.     }
  1291.     public function setDeviceConnectedList(?array $deviceConnectedList): self
  1292.     {
  1293.         $this->deviceConnectedList = $deviceConnectedList;
  1295.         return $this;
  1296.     }
  1298.     public function isInvisible(): ?bool
  1299.     {
  1300.         return $this->invisible;
  1301.     }
  1303.     public function setInvisible(bool $invisible): static
  1304.     {
  1305.         $this->invisible = $invisible;
  1307.         return $this;
  1308.     }
  1310.     public function getLastActivityAt(): ?\DateTimeImmutable
  1311.     {
  1312.         return $this->lastActivityAt;
  1313.     }
  1315.     public function setLastActivityAt(?\DateTimeImmutable $lastActivityAt): static
  1316.     {
  1317.         $this->lastActivityAt = $lastActivityAt;
  1319.         return $this;
  1320.     }
  1322.     public function getLastActivityInMinute(){
  1323.         if($this->getLastActivityAt() != null){
  1324.             $now = new \DateTimeImmutable();
  1325.             $userLastActivity = $this->getLastActivityAt();
  1326.             $interval= $now->diff($userLastActivity);
  1327.             return $interval->days * 24 * 60 + $interval->h * 60 + $interval->i; 
  1328.         }
  1329.         return 9999;
  1330.     }
  1332.     public function isLogged(): ?bool
  1333.     {
  1334.         return $this->isLogged;
  1335.     }
  1337.     public function setIsLogged(?bool $isLogged): static
  1338.     {
  1339.         $this->isLogged = $isLogged;
  1341.         return $this;
  1342.     }
  1345.     public function getEnabled(): ?bool
  1346.     {
  1347.         return $this->enabled;
  1348.     }
  1350.     public function getExternal(): ?bool
  1351.     {
  1352.         return $this->external;
  1353.     }
  1355.     public function getInvisible(): ?bool
  1356.     {
  1357.         return $this->invisible;
  1358.     }
  1360.     public function getIsLogged(): ?bool
  1361.     {
  1362.         return $this->isLogged;
  1363.     }
  1365.     
  1367.     /**
  1368.      * @return Collection<int, MessageReaction>
  1369.      */
  1370.     public function getMessageReactions(): Collection
  1371.     {
  1372.         return $this->messageReactions;
  1373.     }
  1375.     public function addMessageReaction(MessageReaction $messageReaction): static
  1376.     {
  1377.         if (!$this->messageReactions->contains($messageReaction)) {
  1378.             $this->messageReactions->add($messageReaction);
  1379.             $messageReaction->setUser($this);
  1380.         }
  1382.         return $this;
  1383.     }
  1388.     public function removeMessageReaction(MessageReaction $messageReaction): static
  1389.     {
  1390.         if ($this->messageReactions->removeElement($messageReaction)) {
  1391.             // set the owning side to null (unless already changed)
  1392.             if ($messageReaction->getUser() === $this) {
  1393.                 $messageReaction->setUser(null);
  1395.             }
  1396.         }
  1398.         return $this;
  1399.     }
  1401.     /**
  1402.      * @return Collection<int, Emoji>
  1403.      */
  1404.     public function getEmoji(): Collection
  1405.     {
  1406.         return $this->emoji;
  1407.     }
  1409.     public function addEmoji(Emoji $emoji): static
  1410.     {
  1411.         if (!$this->emoji->contains($emoji)) {
  1412.             $this->emoji->add($emoji);
  1413.             $emoji->setUser($this);
  1414.         }
  1416.         return $this;
  1417.     }
  1420.     public function removeEmoji(Emoji $emoji): static
  1421.     {
  1422.         if ($this->emoji->removeElement($emoji)) {
  1423.             // set the owning side to null (unless already changed)
  1424.             if ($emoji->getUser() === $this) {
  1425.                 $emoji->setUser(null);
  1426.             }
  1427.         }
  1429.         return $this;
  1430.     }
  1432.     /**
  1433.      * @return Collection|WorkflowAction[]
  1434.      */
  1435.     public function getWorkflowAction(): Collection
  1436.     {
  1437.         return $this->workflowAction;
  1438.     }
  1440.     public function addWorkflowAction(WorkflowAction $workflowAction): self
  1441.     {
  1442.         if (!$this->workflowAction->contains($workflowAction)) {
  1443.             $this->workflowAction[] = $workflowAction;
  1444.             $workflowAction->setUser($this);
  1445.         }
  1447.         return $this;
  1448.     }
  1450.     public function removeWorkflowAction(WorkflowAction $workflowAction): self
  1451.     {
  1452.         if ($this->workflowAction->removeElement($workflowAction)) {
  1453.             // set the owning side to null (unless already changed)
  1454.             if ($workflowAction->getUser() === $this) {
  1455.                 $workflowAction->setUser(null);
  1456.             }
  1457.         }
  1459.         return $this;
  1460.     }
  1462.     public function getDefaultEmoji(){
  1463.         return [
  1464.             [
  1465.                 "emoji" => "👍️",
  1466.                 "emojiId"=>350,
  1467.                 "detail" => "thumbs up"
  1468.             ],
  1469.             [
  1470.                 "emoji" => "❤️",
  1471.                 "emojiId"=>153,
  1472.                 "detail" => "red heart"
  1473.             ],
  1474.             [
  1475.                 "emoji" => "😆",
  1476.                 "emojiId"=>5,
  1477.                 "detail" => "grinning squinting face"
  1478.             ],
  1479.             [
  1480.                 "emoji" => "😮",
  1481.                 "emojiId"=>86,
  1482.                 "detail" => "face with open mouth"
  1483.             ],
  1484.             [
  1485.                 "emoji" => "😢",
  1486.                 "emojiId"=>97,
  1487.                 "detail" => "crying face"
  1488.             ],
  1489.             [
  1490.                 "emoji" => "😡",
  1491.                 "emojiId"=>108,
  1492.                 "detail" => "enraged face"
  1493.             ],
  1494.         ];
  1495.     }
  1497.     /**
  1498.      * @return Collection|CommandeLogging[]
  1499.      */
  1500.     public function getCommandeLoggings(): Collection
  1501.     {
  1502.         return $this->commandeLoggings;
  1503.     }
  1505.     public function addCommandeLogging(CommandeLogging $commandeLogging): self
  1506.     {
  1507.         if (!$this->commandeLoggings->contains($commandeLogging)) {
  1508.             $this->commandeLoggings[] = $commandeLogging;
  1509.             $commandeLogging->setUser($this);
  1510.         }
  1512.         return $this;
  1513.     }
  1515.     public function removeCommandeLogging(CommandeLogging $commandeLogging): self
  1516.     {
  1517.         if ($this->commandeLoggings->removeElement($commandeLogging)) {
  1518.             // set the owning side to null (unless already changed)
  1519.             if ($commandeLogging->getUser() === $this) {
  1520.                 $commandeLogging->setUser(null);
  1521.             }
  1522.         }
  1524.         return $this;
  1525.     }
  1527.     public function getNewAdd(): ?bool
  1528.     {
  1529.         return $this->newAdd;
  1530.     }
  1532.     public function setNewAdd(?bool $newAdd): self
  1533.     {
  1534.         $this->newAdd = $newAdd;
  1536.         return $this;
  1537.     }
  1539.     /**
  1540.      * @return Collection|CreditHistory[]
  1541.      */
  1542.     public function getCreditHistories(): Collection
  1543.     {
  1544.         return $this->creditHistories;
  1545.     }
  1547.     public function addCreditHistory(CreditHistory $creditHistory): self
  1548.     {
  1549.         if (!$this->creditHistories->contains($creditHistory)) {
  1550.             $this->creditHistories[] = $creditHistory;
  1551.             $creditHistory->setOrderedBy($this);
  1552.         }
  1554.         return $this;
  1555.     }
  1557.     public function removeCreditHistory(CreditHistory $creditHistory): self
  1558.     {
  1559.         if ($this->creditHistories->removeElement($creditHistory)) {
  1560.             // set the owning side to null (unless already changed)
  1561.             if ($creditHistory->getOrderedBy() === $this) {
  1562.                 $creditHistory->setOrderedBy(null);
  1563.             }
  1564.         }
  1566.         return $this;
  1567.     }
  1569.     /**
  1570.      * @return Collection|Campaign[]
  1571.      */
  1572.     public function getCampaigns(): Collection
  1573.     {
  1574.         return $this->campaigns;
  1575.     }
  1577.     public function addCampaign(Campaign $campaign): self
  1578.     {
  1579.         if (!$this->campaigns->contains($campaign)) {
  1580.             $this->campaigns[] = $campaign;
  1581.             $campaign->setOrderedBy($this);
  1582.         }
  1584.         return $this;
  1585.     }
  1587.     public function removeCampaign(Campaign $campaign): self
  1588.     {
  1589.         if ($this->campaigns->removeElement($campaign)) {
  1590.             // set the owning side to null (unless already changed)
  1591.             if ($campaign->getOrderedBy() === $this) {
  1592.                 $campaign->setOrderedBy(null);
  1593.             }
  1594.         }
  1596.         return $this;
  1597.     }
  1599.     public function getShareMyEmail(): ?bool
  1600.     {
  1601.         return $this->shareMyEmail;
  1602.     }
  1604.     public function setShareMyEmail(?bool $shareMyEmail): self
  1605.     {
  1606.         $this->shareMyEmail = $shareMyEmail;
  1608.         return $this;
  1609.     }
  1611.     public function getShareMyPhone(): ?bool
  1612.     {
  1613.         return $this->shareMyPhone;
  1614.     }
  1616.     public function setShareMyPhone(?bool $shareMyPhone): self
  1617.     {
  1618.         $this->shareMyPhone = $shareMyPhone;
  1620.         return $this;
  1621.     }
  1624.     /**
  1625.      * @return Collection|Support[]
  1626.      */
  1627.     public function getSupports(): Collection
  1628.     {
  1629.         return $this->supports;
  1630.     }
  1632.     public function addSupport(Support $support): self
  1633.     {
  1634.         if (!$this->supports->contains($support)) {
  1635.             $this->supports[] = $support;
  1636.             $support->setUser($this);
  1637.         }
  1639.         return $this;
  1640.     }
  1642.     public function removeSupport(Support $support): self
  1643.     {
  1644.         if ($this->supports->removeElement($support)) {
  1645.             // set the owning side to null (unless already changed)
  1646.             if ($support->getUser() === $this) {
  1647.                 $support->setUser(null);
  1648.             }
  1649.         }
  1650.     }
  1653.     public function getResetToken(): ?ResetPasswordToken
  1654.     {
  1655.         return $this->resetToken;
  1656.     }
  1658.     public function setResetToken(?ResetPasswordToken  $resetToken): self
  1659.     {
  1660.         $this->resetToken = $resetToken;
  1663.         return $this;
  1664.     }
  1666.     /**
  1667.      * @return Collection<int, ConfidentialityContract>
  1668.      */
  1669.     public function getConfidentialityContracts(): Collection
  1670.     {
  1671.         return $this->confidentialityContracts;
  1672.     }
  1674.     public function addConfidentialityContract(ConfidentialityContract $confidentialityContract): static
  1675.     {
  1676.         if (!$this->confidentialityContracts->contains($confidentialityContract)) {
  1677.             $this->confidentialityContracts->add($confidentialityContract);
  1678.             $confidentialityContract->setUser($this);
  1679.         }
  1681.         return $this;
  1682.     }
  1684.     public function removeConfidentialityContract(ConfidentialityContract $confidentialityContract): static
  1685.     {
  1686.         if ($this->confidentialityContracts->removeElement($confidentialityContract)) {
  1687.             // set the owning side to null (unless already changed)
  1688.             if ($confidentialityContract->getUser() === $this) {
  1689.                 $confidentialityContract->setUser(null);
  1690.             }
  1691.         }
  1693.         return $this;
  1694.     }
  1696.     /**
  1697.      * @return Collection|CampaignPendingToSend[]
  1698.      */
  1699.     public function getCampaignPendingToSends(): Collection
  1700.     {
  1701.         return $this->campaignPendingToSends;
  1702.     }
  1704.     public function addCampaignPendingToSend(CampaignPendingToSend $campaignPendingToSend): self
  1705.     {
  1706.         if (!$this->campaignPendingToSends->contains($campaignPendingToSend)) {
  1707.             $this->campaignPendingToSends[] = $campaignPendingToSend;
  1708.             $campaignPendingToSend->setUser($this);
  1709.         }
  1711.         return $this;
  1712.     }
  1714.     public function removeCampaignPendingToSend(CampaignPendingToSend $campaignPendingToSend): self
  1715.     {
  1716.         if ($this->campaignPendingToSends->removeElement($campaignPendingToSend)) {
  1717.             // set the owning side to null (unless already changed)
  1718.             if ($campaignPendingToSend->getUser() === $this) {
  1719.                 $campaignPendingToSend->setUser(null);
  1720.             }
  1721.         }
  1723.         return $this;
  1725.     }
  1727.     public function isNewAdd(): ?bool
  1728.     {
  1729.         return $this->newAdd;
  1730.     }
  1732.     public function isShareMyEmail(): ?bool
  1733.     {
  1734.         return $this->shareMyEmail;
  1735.     }
  1737.     public function isShareMyPhone(): ?bool
  1738.     {
  1739.         return $this->shareMyPhone;
  1740.     }
  1742.     public function isIsActiveNotification(): ?bool
  1743.     {
  1744.         return $this->isActiveNotification;
  1745.     }
  1747.     public function isDeleted(): ?bool
  1748.     {
  1749.         return $this->deleted;
  1750.     }
  1752.     public function isReferencingConfirmationNotification(): ?bool
  1753.     {
  1754.         return $this->referencingConfirmationNotification;
  1755.     }
  1757.     public function isIsLogged(): ?bool
  1758.     {
  1759.         return $this->isLogged;
  1760.     }
  1762.     /**
  1763.      * @return Collection<int, FileMission>
  1764.      */
  1765.     public function getFileMissions(): Collection
  1766.     {
  1767.         return $this->fileMissions;
  1768.     }
  1770.     public function addFileMission(FileMission $fileMission): static
  1771.     {
  1772.         if (!$this->fileMissions->contains($fileMission)) {
  1773.             $this->fileMissions->add($fileMission);
  1774.             $fileMission->setUser($this);
  1775.         }
  1777.         return $this;
  1778.     }
  1780.     public function removeFileMission(FileMission $fileMission): static
  1781.     {
  1782.         if ($this->fileMissions->removeElement($fileMission)) {
  1783.             // set the owning side to null (unless already changed)
  1784.             if ($fileMission->getUser() === $this) {
  1785.                 $fileMission->setUser(null);
  1786.             }
  1787.         }
  1789.         return $this;
  1791.     }
  1793.     public function getIsNewClient(): ?bool
  1794.     {
  1795.         return $this->isNewClient;
  1796.     }
  1798.     public function setIsNewClient(?bool $isNewClient): self
  1799.     {
  1800.         $this->isNewClient = $isNewClient;
  1802.         return $this;
  1803.     }
  1805.     public function getAutorizationDateAt(): ?\DateTimeImmutable
  1806.     {
  1807.         return $this->autorizationDateAt;
  1808.     }
  1810.     public function setAutorizationDateAt(?\DateTimeImmutable $autorizationDateAt): self
  1811.     {
  1812.         $this->autorizationDateAt = $autorizationDateAt;
  1814.         return $this;
  1815.     }
  1817.     public function getUserData(): ?UserData
  1818.     {
  1819.         return $this->userData;
  1820.     }
  1822.     public function setUserData(?UserData $userData): self
  1823.     {
  1824.         $this->userData = $userData;
  1826.         return $this;
  1827.     }
  1829.     public function getAcceptPresentation(): ?bool
  1830.     {
  1831.         return $this->acceptPresentation;
  1832.     }
  1834.     public function setAcceptPresentation(?bool $acceptPresentation): self
  1835.     {
  1836.         $this->acceptPresentation = $acceptPresentation;
  1838.         return $this;
  1839.     }
  1841.     public function getDescription(): ?string
  1842.     {
  1843.         return $this->description;
  1844.     }
  1846.     public function setDescription(?string $description): self
  1847.     {
  1848.         $this->description = $description;
  1850.         return $this;
  1851.     }
  1853.     public function getTitle(): ?string
  1854.     {
  1855.         return $this->title;
  1856.     }
  1858.     public function setTitle(?string $title): self
  1859.     {
  1860.         $this->title = $title;
  1862.         return $this;
  1863.     }
  1865.     public function getOneTimeLoginToken(): ?string
  1866.     {
  1867.         return $this->oneTimeLoginToken;
  1868.     }
  1870.     public function setOneTimeLoginToken(?string $oneTimeLoginToken): self
  1871.     {
  1872.         $this->oneTimeLoginToken = $oneTimeLoginToken;
  1874.         return $this;
  1875.     }
  1878.     public function getState(): ?string
  1879.     {
  1880.         return $this->state;
  1881.     }
  1883.     public function setState(?string $state): self
  1884.     {
  1885.         $this->state = $state;
  1886.         return  $this; 
  1887.     }
  1889.     /**
  1890.      * @return Collection|Portfolio[]
  1891.      */
  1892.     public function getPortfolio(): Collection
  1893.     {
  1894.         return $this->portfolio;
  1895.     }
  1897.     public function addPortfolio(Portfolio $portfolio): self
  1898.     {
  1899.         if (!$this->portfolio->contains($portfolio)) {
  1900.             $this->portfolio[] = $portfolio;
  1901.             $portfolio->setUser($this);
  1902.         }
  1904.         return $this;
  1905.     }
  1907.     public function removePortfolio(Portfolio $portfolio): self
  1908.     {
  1909.         if ($this->portfolio->removeElement($portfolio)) {
  1910.             // set the owning side to null (unless already changed)
  1911.             if ($portfolio->getUser() === $this) {
  1912.                 $portfolio->setUser(null);
  1913.             }
  1914.         }
  1916.         return $this;
  1917.     }
  1919.     public function getSalary(): ?bool
  1920.     {
  1921.         return $this->salary;
  1922.     }
  1924.     public function setSalary(?bool $salary): self
  1925.     {
  1926.         $this->salary = $salary;
  1928.         return $this;
  1929.     }
  1931.     public function getAllCompany(): ?bool
  1932.     {
  1933.         return $this->allCompany;
  1934.     }
  1936.     public function setAllCompany(?bool $allCompany): self
  1937.     {
  1938.         $this->allCompany = $allCompany;
  1940.         return $this;
  1941.     }
  1943.     public function getManager(): ?bool
  1944.     {
  1945.         return $this->manager;
  1946.     }
  1948.     public function setManager(?bool $manager): self
  1949.     {
  1950.         $this->manager = $manager;
  1952.         return $this;
  1953.     }
  1955.     /**
  1956.      * @return Collection|Company[]
  1957.      */
  1958.     public function getOtherCompany(): Collection
  1959.     {
  1960.         return $this->otherCompany;
  1961.     }
  1963.     public function addOtherCompany(Company $otherCompany): self
  1964.     {
  1965.         if (!$this->otherCompany->contains($otherCompany)) {
  1966.             $this->otherCompany[] = $otherCompany;
  1967.         }
  1969.         return $this;
  1970.     }
  1972.     public function removeOtherCompany(Company $otherCompany): self
  1973.     {
  1974.         $this->otherCompany->removeElement($otherCompany);
  1976.         return $this;
  1977.     }
  1979.     
  1981.     public function getPartner(): ?bool
  1982.     {
  1983.         return $this->partner;
  1984.     }
  1986.     public function setPartner(?bool $partner): self
  1987.     {
  1988.         $this->partner = $partner;
  1990.         return $this;
  1991.     }
  1993.     public function getParent(): ?self
  1994.     {
  1995.         return $this->parent;
  1996.     }
  1998.     public function setParent(?self $parent): self
  1999.     {
  2000.         $this->parent = $parent;
  2002.         return $this;
  2003.     }
  2005.     /**
  2006.      * @return Collection|User[]
  2007.      */
  2008.     public function getChildren(): Collection
  2009.     {
  2010.         return $this->children;
  2011.     }
  2013.     public function addChild(User $child): self
  2014.     {
  2015.         if (!$this->children->contains($child)) {
  2016.             $this->children[] = $child;
  2017.             $child->setParent($this);
  2018.         }
  2020.         return $this;
  2021.     }
  2023.     public function removeChild(User $child): self
  2024.     {
  2025.         if ($this->children->removeElement($child)) {
  2026.             // set the owning side to null (unless already changed)
  2027.             if ($child->getParent() === $this) {
  2028.                 $child->setParent(null);
  2029.             }
  2030.         }
  2032.         return $this;
  2033.     }
  2036.     public function getOriginalEmail(): ?string
  2037.     {
  2038.         return $this->OriginalEmail;
  2039.     }
  2041.     public function setOriginalEmail(?string $OriginalEmail): self
  2042.     {
  2043.         $this->OriginalEmail = $OriginalEmail;
  2045.         return $this;
  2046.     }
  2048.     /**
  2049.      * @return Collection|SignedContract[]
  2050.      */
  2051.     public function getSignedContracts(): Collection
  2052.     {
  2053.         return $this->signedContracts;
  2054.     }
  2056.     public function addSignedContract(SignedContract $signedContract): self
  2057.     {
  2058.         if (!$this->signedContracts->contains($signedContract)) {
  2059.             $this->signedContracts[] = $signedContract;
  2060.             $signedContract->setUser($this);
  2061.         }
  2063.         return $this;
  2064.     }
  2066.     public function removeSignedContract(SignedContract $signedContract): self
  2067.     {
  2068.         if ($this->signedContracts->removeElement($signedContract)) {
  2069.             // set the owning side to null (unless already changed)
  2070.             if ($signedContract->getUser() === $this) {
  2071.                 $signedContract->setUser(null);
  2072.             }
  2073.         }
  2075.         return $this;
  2076.     }
  2078.     /**
  2079.      * @return Collection|Company[]
  2080.      */
  2081.     public function getCompaniesRepresentative(): Collection
  2082.     {
  2083.         return $this->companiesRepresentative;
  2084.     }
  2086.     public function addCompanyRepresentative(Company $companiesRepresentative): self
  2087.     {
  2088.         if (!$this->companiesRepresentative->contains($companiesRepresentative)) {
  2089.             $this->companiesRepresentative[] = $companiesRepresentative;
  2090.             $companiesRepresentative->setRepresentative($this);
  2091.         }
  2093.         return $this;
  2094.     }
  2096.     public function removeCompanyRepresentative(Company $companiesRepresentative): self
  2097.     {
  2098.         if ($this->companiesRepresentative->removeElement($companiesRepresentative)) {
  2099.             // set the owning side to null (unless already changed)
  2100.             if ($companiesRepresentative->getRepresentative() === $this) {
  2101.                 $companiesRepresentative->setRepresentative(null);
  2102.             }
  2103.         }
  2105.         return $this;
  2106.     }
  2109.     /**
  2110.      * @return Collection|Product[]
  2111.      */
  2112.     public function getProducts(): Collection
  2113.     {
  2114.         return $this->products;
  2115.     }
  2118.     public function addProduct(Product $product): self
  2119.     {
  2120.         if (!$this->products->contains($product)) {
  2121.             $this->products[] = $product;
  2122.             $product->setCreatedBy($this);
  2123.         }
  2125.         return $this;
  2126.     }
  2128.     public function removeProduct(Product $product): self
  2129.     {
  2130.         if ($this->products->removeElement($product)) {
  2131.             // set the owning side to null (unless already changed)
  2132.             if ($product->getCreatedBy() === $this) {
  2133.                 $product->setCreatedBy(null);
  2134.             }
  2135.         }
  2137.         return $this;
  2138.     }
  2140.     /**
  2141.      * @return Collection|WorkflowStep[]
  2142.      */
  2143.     public function getWorkflowSteps(): Collection
  2144.     {
  2145.         return $this->workflowSteps;
  2146.     }
  2148.     public function addWorkflowStep(WorkflowStep $workflowStep): self
  2149.     {
  2150.         if (!$this->workflowSteps->contains($workflowStep)) {
  2151.             $this->workflowSteps[] = $workflowStep;
  2152.             $workflowStep->addUserResponsable($this);
  2153.         }
  2155.         return $this;
  2156.     }
  2158.     public function removeWorkflowStep(WorkflowStep $workflowStep): self
  2159.     {
  2160.         if ($this->workflowSteps->removeElement($workflowStep)) {
  2161.             $workflowStep->removeUserResponsable($this);
  2162.         }
  2164.         return $this;
  2165.     }
  2167.     // for api only
  2168.         public function getListAccount()
  2169.         {
  2170.             return $this->listAccount;
  2171.         }
  2172.         public function setListAccount($listAccount){
  2173.             $this->listAccount = $listAccount;
  2174.             return $this;
  2175.         }
  2177.         public function getRoleName()
  2178.         {
  2179.             return $this->roleName;
  2180.         }
  2181.         public function setRoleName($roleName){
  2182.             $this->roleName = $roleName;
  2183.             return $this;
  2184.         }
  2186.         public function getIdentifier(): ?string
  2187.         {
  2188.             return $this->identifier;
  2189.         }
  2191.         public function setIdentifier(?string $identifier): self
  2192.         {
  2193.             $this->identifier = $identifier;
  2195.             return $this;
  2196.         }
  2198.         /**
  2199.          * @return Collection<int, SharedResourcesCategory>
  2200.          */
  2201.         public function getSharedResourcesCategories(): Collection
  2202.         {
  2203.             return $this->sharedResourcesCategories;
  2204.         }
  2206.         public function addSharedResourcesCategory(SharedResourcesCategory $sharedResourcesCategory): static
  2207.         {
  2208.             if (!$this->sharedResourcesCategories->contains($sharedResourcesCategory)) {
  2209.                 $this->sharedResourcesCategories->add($sharedResourcesCategory);
  2210.                 $sharedResourcesCategory->setCreatedBy($this);
  2211.             }
  2213.             return $this;
  2214.         }
  2216.         public function removeSharedResourcesCategory(SharedResourcesCategory $sharedResourcesCategory): static
  2217.         {
  2218.             if ($this->sharedResourcesCategories->removeElement($sharedResourcesCategory)) {
  2219.                 // set the owning side to null (unless already changed)
  2220.                 if ($sharedResourcesCategory->getCreatedBy() === $this) {
  2221.                     $sharedResourcesCategory->setCreatedBy(null);
  2222.                 }
  2223.             }
  2225.             return $this;
  2226.         }
  2228.         /**
  2229.          * @return Collection<int, CompanyResource>
  2230.          */
  2231.         public function getCompanyResources(): Collection
  2232.         {
  2233.             return $this->companyResources;
  2234.         }
  2236.         public function addCompanyResource(CompanyResource $companyResource): static
  2237.         {
  2238.             if (!$this->companyResources->contains($companyResource)) {
  2239.                 $this->companyResources->add($companyResource);
  2240.                 $companyResource->setCreatedBy($this);
  2241.             }
  2243.             return $this;
  2244.         }
  2246.         public function removeCompanyResource(CompanyResource $companyResource): static
  2247.         {
  2248.             if ($this->companyResources->removeElement($companyResource)) {
  2249.                 // set the owning side to null (unless already changed)
  2250.                 if ($companyResource->getCreatedBy() === $this) {
  2251.                     $companyResource->setCreatedBy(null);
  2252.                 }
  2253.             }
  2255.             return $this;
  2256.         }
  2258.         // public function getFilePermissions(): ?FilePermissions
  2259.         // {
  2260.         //     return $this->filePermissions;
  2261.         // }
  2263.         // public function setFilePermissions(?FilePermissions $filePermissions): static
  2264.         // {
  2265.         //     $this->filePermissions = $filePermissions;
  2267.         //     return $this;
  2268.         // }
  2270.         /**
  2271.          * @return Collection<int, ResourceDeliverableHistory>
  2272.          */
  2273.         public function getResourceDeliverableHistories(): Collection
  2274.         {
  2275.             return $this->resourceDeliverableHistories;
  2276.         }
  2278.         public function addResourceDeliverableHistory(ResourceDeliverableHistory $resourceDeliverableHistory): static
  2279.         {
  2280.             if (!$this->resourceDeliverableHistories->contains($resourceDeliverableHistory)) {
  2281.                 $this->resourceDeliverableHistories->add($resourceDeliverableHistory);
  2282.                 $resourceDeliverableHistory->setCreatedBy($this);
  2283.             }
  2285.             return $this;
  2286.         }
  2288.         public function removeResourceDeliverableHistory(ResourceDeliverableHistory $resourceDeliverableHistory): static
  2289.         {
  2290.             if ($this->resourceDeliverableHistories->removeElement($resourceDeliverableHistory)) {
  2291.                 // set the owning side to null (unless already changed)
  2292.                 if ($resourceDeliverableHistory->getCreatedBy() === $this) {
  2293.                     $resourceDeliverableHistory->setCreatedBy(null);
  2294.                 }
  2295.             }
  2297.             return $this;
  2298.         }
  2300.         /**
  2301.          * @return Collection<int, FilesResourceDeliverableHistory>
  2302.          */
  2303.         public function getFilesResourceDeliverableHistories(): Collection
  2304.         {
  2305.             return $this->filesResourceDeliverableHistories;
  2306.         }
  2308.         public function addFilesResourceDeliverableHistory(FilesResourceDeliverableHistory $filesResourceDeliverableHistory): static
  2309.         {
  2310.             if (!$this->filesResourceDeliverableHistories->contains($filesResourceDeliverableHistory)) {
  2311.                 $this->filesResourceDeliverableHistories->add($filesResourceDeliverableHistory);
  2312.                 $filesResourceDeliverableHistory->setCreatedBy($this);
  2313.             }
  2315.             return $this;
  2316.         }
  2318.         public function removeFilesResourceDeliverableHistory(FilesResourceDeliverableHistory $filesResourceDeliverableHistory): static
  2319.         {
  2320.             if ($this->filesResourceDeliverableHistories->removeElement($filesResourceDeliverableHistory)) {
  2321.                 // set the owning side to null (unless already changed)
  2322.                 if ($filesResourceDeliverableHistory->getCreatedBy() === $this) {
  2323.                     $filesResourceDeliverableHistory->setCreatedBy(null);
  2324.                 }
  2325.             }
  2327.             return $this;
  2328.         }
  2330.         /**
  2331.          * @return Collection<int, FilePermissions>
  2332.          */
  2333.         public function getFilePermissions(): Collection
  2334.         {
  2335.             return $this->filePermissions;
  2336.         }
  2338.         public function addFilePermission(FilePermissions $filePermission): static
  2339.         {
  2340.             if (!$this->filePermissions->contains($filePermission)) {
  2341.                 $this->filePermissions->add($filePermission);
  2342.                 $filePermission->addUser($this);
  2343.             }
  2345.             return $this;
  2346.         }
  2348.         public function removeFilePermission(FilePermissions $filePermission): static
  2349.         {
  2350.             if ($this->filePermissions->removeElement($filePermission)) {
  2351.                 $filePermission->removeUser($this);
  2352.             }
  2354.             return $this;
  2355.         }
  2357.         /**
  2358.          * @return Collection<int, FolderPermissions>
  2359.          */
  2360.         public function getFolderPermissions(): Collection
  2361.         {
  2362.             return $this->folderPermissions;
  2363.         }
  2365.         public function addFolderPermission(FolderPermissions $folderPermission): static
  2366.         {
  2367.             if (!$this->folderPermissions->contains($folderPermission)) {
  2368.                 $this->folderPermissions->add($folderPermission);
  2369.                 $folderPermission->addUser($this);
  2370.             }
  2372.             return $this;
  2373.         }
  2375.         public function removeFolderPermission(FolderPermissions $folderPermission): static
  2376.         {
  2377.             if ($this->folderPermissions->removeElement($folderPermission)) {
  2378.                 $folderPermission->removeUser($this);
  2379.             }
  2381.             return $this;
  2382.         }
  2384.         /**
  2385.          * @return Collection<int, FolderPermissions>
  2386.          */
  2387.         public function getFolderPermissionsCreatedBy(): Collection
  2388.         {
  2389.             return $this->folderPermissionsCreatedBy;
  2390.         }
  2392.         public function addFolderPermissionsCreatedBy(FolderPermissions $folderPermissionsCreatedBy): static
  2393.         {
  2394.             if (!$this->folderPermissionsCreatedBy->contains($folderPermissionsCreatedBy)) {
  2395.                 $this->folderPermissionsCreatedBy->add($folderPermissionsCreatedBy);
  2396.                 $folderPermissionsCreatedBy->setCreatedBy($this);
  2397.             }
  2399.             return $this;
  2400.         }
  2402.         public function removeFolderPermissionsCreatedBy(FolderPermissions $folderPermissionsCreatedBy): static
  2403.         {
  2404.             if ($this->folderPermissionsCreatedBy->removeElement($folderPermissionsCreatedBy)) {
  2405.                 // set the owning side to null (unless already changed)
  2406.                 if ($folderPermissionsCreatedBy->getCreatedBy() === $this) {
  2407.                     $folderPermissionsCreatedBy->setCreatedBy(null);
  2408.                 }
  2409.             }
  2411.             return $this;
  2412.         }
  2414.         /**
  2415.          * @return Collection<int, FilePermissions>
  2416.          */
  2417.         public function getFilePermissionsCreatedBy(): Collection
  2418.         {
  2419.             return $this->filePermissionsCreatedBy;
  2420.         }
  2422.         public function addFilePermissionsCreatedBy(FilePermissions $filePermissionsCreatedBy): static
  2423.         {
  2424.             if (!$this->filePermissionsCreatedBy->contains($filePermissionsCreatedBy)) {
  2425.                 $this->filePermissionsCreatedBy->add($filePermissionsCreatedBy);
  2426.                 $filePermissionsCreatedBy->setCreatedBy($this);
  2427.             }
  2429.             return $this;
  2430.         }
  2432.         public function removeFilePermissionsCreatedBy(FilePermissions $filePermissionsCreatedBy): static
  2433.         {
  2434.             if ($this->filePermissionsCreatedBy->removeElement($filePermissionsCreatedBy)) {
  2435.                 // set the owning side to null (unless already changed)
  2436.                 if ($filePermissionsCreatedBy->getCreatedBy() === $this) {
  2437.                     $filePermissionsCreatedBy->setCreatedBy(null);
  2438.                 }
  2439.             }
  2441.             return $this;
  2442.         }
  2444.         public function isAllCompany(): ?bool
  2445.         {
  2446.             return $this->allCompany;
  2447.         }
  2449.         public function isSalary(): ?bool
  2450.         {
  2451.             return $this->salary;
  2452.         }
  2454.         public function isManager(): ?bool
  2455.         {
  2456.             return $this->manager;
  2457.         }
  2459.         public function isPartner(): ?bool
  2460.         {
  2461.             return $this->partner;
  2462.         }
  2464.         public function getMailAlias(): ?array
  2465.         {
  2466.             return $this->mailAlias;
  2467.         }
  2469.         public function setMailAlias(?array $mailAlias): static
  2470.         {
  2471.             $this->mailAlias = $mailAlias;
  2473.             return $this;
  2474.         }
  2476.         public function isIsNewClient(): ?bool
  2477.         {
  2478.             return $this->isNewClient;
  2479.         }
  2481.         public function isAcceptPresentation(): ?bool
  2482.         {
  2483.             return $this->acceptPresentation;
  2484.         }
  2486.         public function addCompaniesRepresentative(Company $companiesRepresentative): static
  2487.         {
  2488.             if (!$this->companiesRepresentative->contains($companiesRepresentative)) {
  2489.                 $this->companiesRepresentative->add($companiesRepresentative);
  2490.                 $companiesRepresentative->setRepresentative($this);
  2491.             }
  2493.             return $this;
  2494.         }
  2496.         public function removeCompaniesRepresentative(Company $companiesRepresentative): static
  2497.         {
  2498.             if ($this->companiesRepresentative->removeElement($companiesRepresentative)) {
  2499.                 // set the owning side to null (unless already changed)
  2500.                 if ($companiesRepresentative->getRepresentative() === $this) {
  2501.                     $companiesRepresentative->setRepresentative(null);
  2502.                 }
  2503.             }
  2505.             return $this;
  2506.         }
  2508.         /**
  2509.          * @return Collection<int, noteUser>
  2510.          */
  2511.         public function getNoteUser(): Collection
  2512.         {
  2513.             return $this->noteUser;
  2514.         }
  2516.         public function addNoteUser(noteUser $noteUser): static
  2517.         {
  2518.             if (!$this->noteUser->contains($noteUser)) {
  2519.                 $this->noteUser->add($noteUser);
  2520.                 $noteUser->setUser($this);
  2521.             }
  2523.             return $this;
  2524.         }
  2526.         public function removeNoteUser(noteUser $noteUser): static
  2527.         {
  2528.             if ($this->noteUser->removeElement($noteUser)) {
  2529.                 // set the owning side to null (unless already changed)
  2530.                 if ($noteUser->getUser() === $this) {
  2531.                     $noteUser->setUser(null);
  2532.                 }
  2533.             }
  2535.             return $this;
  2536.         }
  2538.         /**
  2539.          * @return Collection<int, AppPromotion>
  2540.          */
  2541.         public function getAppPromotions(): Collection
  2542.         {
  2543.             return $this->appPromotions;
  2544.         }
  2546.         public function addAppPromotion(AppPromotion $appPromotion): static
  2547.         {
  2548.             if (!$this->appPromotions->contains($appPromotion)) {
  2549.                 $this->appPromotions->add($appPromotion);
  2550.                 $appPromotion->setUser($this);
  2551.             }
  2553.             return $this;
  2554.         }
  2556.         public function removeAppPromotion(AppPromotion $appPromotion): static
  2557.         {
  2558.             if ($this->appPromotions->removeElement($appPromotion)) {
  2559.                 // set the owning side to null (unless already changed)
  2560.                 if ($appPromotion->getUser() === $this) {
  2561.                     $appPromotion->setUser(null);
  2562.                 }
  2563.             }
  2565.             return $this;
  2566.         }
  2568.         public function isShareMyWhatsapp(): ?bool
  2569.         {
  2570.             return $this->shareMyWhatsapp;
  2571.         }
  2573.         public function setShareMyWhatsapp(?bool $shareMyWhatsapp): static
  2574.         {
  2575.             $this->shareMyWhatsapp = $shareMyWhatsapp;
  2577.             return $this;
  2578.         }
  2580.         public function getMyWhatsappLink(): ?string
  2581.         {
  2582.             return $this->myWhatsappLink;
  2583.         }
  2585.         public function setMyWhatsappLink(?string $myWhatsappLink): static
  2586.         {
  2587.             $this->myWhatsappLink = $myWhatsappLink;
  2589.             return $this;
  2590.         }
  2592.         public function getMyFlowEmail(): ?string
  2593.         {
  2594.             return $this->myFlowEmail;
  2595.         }
  2597.         public function setMyFlowEmail(?string $myFlowEmail): static
  2598.         {
  2599.             $this->myFlowEmail = $myFlowEmail;
  2601.             return $this;
  2602.         }
  2604.         
  2606.     
  2607. }