src/Entity/User.php line 16

  1. <?php
  3. namespace App\Entity;
  5. use Doctrine\Common\Collections\ArrayCollection;
  6. use Doctrine\Common\Collections\Collection;
  7. use Doctrine\DBAL\Types\Types;
  8. use Doctrine\ORM\Mapping as ORM;
  9. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  10. use Symfony\Component\Security\Core\User\UserInterface;
  12. #[ORM\Table(name:"til_user")]
  13. #[ORM\Entity(repositoryClass:"App\Repository\UserRepository")]
  14. class User implements UserInterface, PasswordAuthenticatedUserInterface
  15. {
  16.     public function __toString(){
  17.         return $this->getSurname().' '.$this->getName();
  18.     }
  20.     public function displayFullNameAndAccountType(){
  21.         return $this->getSurname().' '.$this->getName().' ('.$this->getAccountType()->__toString().')';
  22.     }
  24.     public function getCanViewPermissionCategory($categorySlug){
  25.         foreach($this->permissions as $jt){
  26.             if($jt->getPermission()->getCategory()->getSlug() == $categorySlug){
  27.                 if($jt->getValue() != "")
  28.                     return true;
  29.             }
  30.         }
  31.         return false;
  32.     }
  33.     
  34.     public function getCanViewPermission($permissionSlug){
  35.         foreach($this->permissions as $jt){
  36.             if($jt->getPermission()->getSlug() == $permissionSlug){
  37.                 if($jt->getValue() != "")
  38.                     return true;
  39.                 else
  40.                     return false;
  41.             }
  42.         }
  43.         return false;
  44.     }
  45.     
  46.     public function getCanEditPermission($permissionSlug){
  47.         foreach($this->permissions as $jt){
  48.             if($jt->getPermission()->getSlug() == $permissionSlug){
  49.                 if($jt->getValue() == "rw")
  50.                     return true;
  51.                 else
  52.                     return false;
  53.             }
  54.         }
  55.         return false;
  56.     }
  58.     public function getPermissionType($permissionSlug){
  59.         foreach($this->permissions as $jt){
  60.             if($jt->getPermission()->getSlug() == $permissionSlug)
  61.                 return $jt->getValue();
  62.         }
  63.         return "";
  64.     }
  66.     public function getUnreadNotifications(){
  67.         $count = 0;
  68.         foreach($this->getNotifications() as $n){
  69.             if($n->isPersonal() && !$n->isRead())
  70.                 $count++;
  71.         }
  72.         return $count;
  73.     }
  77.     public function printPdfName(){
  78.         return $this->surname.' '.substr($this->name, 0, 1);
  79.     }
  80.     
  81.     public function getHasProvince($facilityProvince){
  82.         if($this->getAccountType()->getSlug() == "kam"){
  83.             foreach ($this->coveredProvinces as $province){
  84.                 if($province->getId() == $facilityProvince)
  85.                     return true;
  86.             }
  87.         }
  88.         return false;
  89.     }
  91.     public function getSellName(){
  92.         if($this->getAccountType()->getSlug() == "kam" && $this->getName() != "Tillomed")
  93.             return $this->surname. ' ' .$this->name;
  94.         elseif($this->getAccountType()->getSlug() == "kam" && $this->getName() == "Tillomed")
  95.             return "Vacant";
  96.         else
  97.             return "Customer Service";
  98.     }
  100.     public function getIsEligible($feature){
  101.         switch($feature){
  102.             case 'alarmBtn':
  103.                 if($this->getAccountType()->getSlug() == 'supervisor_mario' 
  104.                     || strpos($this->getAccountType()->getSlug(), "commercial") !== false 
  105.                     || $this->getAccountType()->getSlug() == 'kam'
  106.                     || $this->getAccountType()->getSlug() == 'administration')
  107.                     return true;
  108.         }
  109.         return false;
  110.     }
  111.     
  112.     public function getActualOdometer($month, $year){
  113.         foreach($this->refundYears as $ry){
  114.             if($ry->getValue() == $year){
  115.                 foreach($ry->getRefundMonths() as $rm){
  116.                     if($rm->getValue() == $month)
  117.                         return $rm->getEndMonthOdometer();
  118.                 }
  119.             }
  120.         }
  121.         return 0;
  122.     }
  123.     
  124.     public function getActualKmPlusMinus($month, $year){
  125.         $odometer = $this->getActualOdometer($month, $year);
  126.         foreach($this->refundYears as $ry){
  127.             foreach($ry->getRefundMonths() as $rm){
  128.                
  129.                 return  $odometer - $l->getStartKm() - ($rm->getValue()*$l->getKmMonth());
  130.             }
  131.         }
  132.         foreach($this->leasings as $l){
  133.         }
  134.         return 0;
  135.     }
  136.     
  137.     public function getCurrentBudgetKamPercentage($date){
  138.         $year = $date->format("Y");
  139.         if($date->format("m") < 4)
  140.             $year--;
  141.         foreach($this->budgetKams as $bk){
  142.             if($bk->getBudgetTotal()->getYear() == $year)
  143.                 return $bk->getPercentage();
  144.         }
  145.         return "0";
  146.     }
  148.     public function getUnclosedPresenceMonth(){
  149.         $months = array();
  150.         foreach($this->presenceYears as $py){
  151.             foreach($py->getPresenceMonths() as $pm){
  152.                 if($pm->getStatus() < 2){
  153.                     array_push($months, $pm);
  154.                 }
  155.             }
  156.         }
  157.         return $months;
  158.     }
  160.     public function getMonthPresenceStats($month, $year, $startDate, $endDate, $filterType){
  161.         $presence = 0;
  162.         $rol = 0;
  163.         $holiday = 0;
  164.         $transfer = 0;
  165.         $permission = 0;
  166.         $illness = 0;
  167.         $meeting = 0;
  168.         $congress = 0;
  169.         foreach($this->presenceYears as $py){
  170.             if($filterType == "progressive"){
  171.                 if($month < 4 && ($py->getValue() == $year || $py->getValue() == $year - 1)){
  172.                     foreach($py->getPresenceMonths() as $pm){
  173.                         if(($py->getValue() == $year && $pm->getValue() <= $month) || ($py->getValue() == $year - 1 && $pm->getValue() >= 4)){
  174.                             foreach($pm->getPresenceDays() as $pd){
  175.                                 if($pd->getJobHours() > 0)
  176.                                     $presence++;
  177.                                 $rol += $pd->getRol();
  178.                                 $holiday += $pd->getHoliday();
  179.                                 $transfer += $pd->getIsTransfer();
  180.                                 $permission += $pd->getPermission();
  181.                                 $illness += $pd->getIllness();
  182.                                 $meeting += $pd->getIsMeeting();
  183.                                 $congress += $pd->getIsCongress();
  184.                             }
  185.                         }
  186.                     }
  187.                 }
  188.                 elseif($month >= 4 && $py->getValue() == $year){
  189.                     foreach($py->getPresenceMonths() as $pm){
  190.                         if($pm->getValue() >= 4 && $pm->getValue() <= $month){
  191.                             foreach($pm->getPresenceDays() as $pd){
  192.                                 if($pd->getJobHours() > 0)
  193.                                     $presence++;
  194.                                 $rol += $pd->getRol();
  195.                                 $holiday += $pd->getHoliday();
  196.                                 $transfer += $pd->getIsTransfer();
  197.                                 $permission += $pd->getPermission();
  198.                                 $illness += $pd->getIllness();
  199.                                 $meeting += $pd->getIsMeeting();
  200.                                 $congress += $pd->getIsCongress();
  201.                             }
  202.                         }
  203.                     }
  204.                 }
  205.             }
  206.             elseif($filterType == "monthly"){
  207.                 if($py->getValue() == $year){
  208.                     foreach($py->getPresenceMonths() as $pm){
  209.                         if($pm->getValue() == $month){
  210.                             foreach($pm->getPresenceDays() as $pd){
  211.                                 if($pd->getJobHours() > 0)
  212.                                     $presence++;
  213.                                 $rol += $pd->getRol();
  214.                                 $holiday += $pd->getHoliday();
  215.                                 $transfer += $pd->getIsTransfer();
  216.                                 $permission += $pd->getPermission();
  217.                                 $illness += $pd->getIllness();
  218.                                 $meeting += $pd->getIsMeeting();
  219.                                 $congress += $pd->getIsCongress();
  220.                             }
  221.                         }
  222.                     }
  223.                 }
  224.             }
  225.             else{
  226.                 if($py->getValue() >= $startDate->format("Y") and $py->getValue() <= $endDate->format("Y")){
  227.                     foreach($py->getPresenceMonths() as $pm){
  228.                         foreach($pm->getPresenceDays() as $pd){
  229.                             if($pd->getDate()->format("Ymd") >= $startDate->format("Ymd") && $pd->getDate()->format("Ymd") <= $endDate->format("Ymd")){
  230.                                 if($pd->getJobHours() > 0)
  231.                                     $presence++;
  232.                                 $rol += $pd->getRol();
  233.                                 $holiday += $pd->getHoliday();
  234.                                 $transfer += $pd->getIsTransfer();
  235.                                 $permission += $pd->getPermission();
  236.                                 $illness += $pd->getIllness();
  237.                                 $meeting += $pd->getIsMeeting();
  238.                                 $congress += $pd->getIsCongress();
  239.                             }
  240.                         }
  241.                     }
  242.                 }
  243.             }
  244.         }
  245.         return array($presence, $rol, $holiday, $transfer, $permission, $illness, $meeting, $congress);
  246.     }
  248.     public function getMonthRefundStats($month, $year, $filterType){
  249.         $types = array();
  250.         foreach($this->refundYears as $ry){
  251.             if($filterType == "progressive"){
  252.                 if($month < 4 && ($ry->getValue() == $year || $ry->getValue() == $year - 1)){
  253.                     foreach($ry->getRefundMonths() as $rm){
  254.                         if(($ry->getValue() == $year && $rm->getValue() <= $month) || ($ry->getValue() == $year - 1 && $rm->getValue() >= 4)){
  255.                             foreach($rm->getRefundDays() as $rd){
  256.                                 foreach($rd->getRefunds() as $r){
  257.                                     $index = $r->getRefundType()->getId();
  258.                                     if(array_key_exists($index, $types)) 
  259.                                         $types[$index] += $r->getValue(); 
  260.                                     else 
  261.                                         $types[$index] = $r->getValue();
  262.                                 }
  263.                             }
  264.                         }
  265.                     }
  266.                 }
  267.                 elseif($month >= 4 && $ry->getValue() == $year){
  268.                     foreach($ry->getRefundMonths() as $rm){
  269.                         if($rm->getValue() >= 4 && $rm->getValue() <= $month){
  270.                             foreach($rm->getRefundDays() as $rd){
  271.                                 foreach($rd->getRefunds() as $r){
  272.                                     $index = $r->getRefundType()->getId();
  273.                                     if(array_key_exists($index, $types)) 
  274.                                         $types[$index] += $r->getValue(); 
  275.                                     else 
  276.                                         $types[$index] = $r->getValue();
  277.                                 }
  278.                             }
  279.                         }
  280.                     }
  281.                 }
  282.             }
  283.             else{
  284.                 if($ry->getValue() == $year){
  285.                     foreach($ry->getRefundMonths() as $rm){
  286.                         if($rm->getValue() == $month){
  287.                             foreach($rm->getRefundDays() as $rd){
  288.                                 foreach($rd->getRefunds() as $r){
  289.                                     $index = $r->getRefundType()->getId();
  290.                                     if(array_key_exists($index, $types)) 
  291.                                         $types[$index] += $r->getValue(); 
  292.                                     else 
  293.                                         $types[$index] = $r->getValue();
  294.                                 }
  295.                             }
  296.                         }
  297.                     }
  298.                 }
  299.             }
  300.         }
  301.         return $types;
  302.     }
  304.     #[ORM\Column(name:"id", type:"bigint")]
  305.     #[ORM\Id]
  306.     #[ORM\GeneratedValue(strategy:"AUTO")]
  307.     private ?string $id;
  308.     
  309.     #[ORM\Column(name:"email", type:"string", length:191, unique:true, nullable:true)]
  310.     private ?string $email;
  311.     
  312.     #[ORM\Column(name:"name", type:"string", length:191)]
  313.     private ?string $name;
  314.     
  315.     #[ORM\Column(name:"surname", type:"string", length:191)]
  316.     private ?string $surname;
  317.     
  318.     #[ORM\Column(name:"password", type:"string", length:191, nullable:true)]
  319.     private ?string $password;
  320.     
  321.     #[ORM\Column(name:"directory_path", type:"string", length:191)]
  322.     private ?string $directoryPath;
  323.     
  324.     #[ORM\Column(name:"one_time_code", type:"string", length:191, nullable:true)]
  325.     private ?string $oneTimeCode;
  326.     
  327.     #[ORM\Column(name:"role", type:"string", length:191)]
  328.     private ?string $role = 'ROLE_USER';
  330.     #[ORM\Column(name:"expiration_one_time_code", type:"datetime", nullable:true)]
  331.     private ?\DateTimeInterface $expirationOneTimeCode;
  332.     
  333.     #[ORM\Column(name:"office_hours", type:"text", nullable:true)]
  334.     private ?string $officeHours;
  335.     
  336.     #[ORM\Column(name:"is_active", type:"boolean")]
  337.     private ?bool $active = false;
  338.     
  339.     #[ORM\Column(name:"is_admin_active", type:"boolean")]
  340.     private ?bool $adminActive = true;
  341.     
  342.     #[ORM\Column(name:"is_email_notification_active", type:"boolean")]
  343.     private ?bool $emailNotificationActive = false;
  344.     
  345.     #[ORM\Column(name:"is_alert_read", type:"boolean")]
  346.     private ?bool $alertRead = false;
  347.     
  348.     #[ORM\Column(name:"is_gdpr_sent", type:"boolean")]
  349.     private ?bool $gdprSent = false;
  350.     
  351.     // ONE TO ONE
  352.     #[ORM\OneToOne(targetEntity:"App\Entity\UserPrivacy", mappedBy:"user", cascade:['remove', 'persist'])]
  353.     private $privacy;
  354.     
  355.     #[ORM\OneToOne(targetEntity:"App\Entity\UserProfile", mappedBy:"user", cascade:['remove', 'persist'])]
  356.     private $profile;
  357.     
  358.     #[ORM\OneToOne(targetEntity:"App\Entity\Employee", mappedBy:"user")]
  359.     private $employee;
  361.     // MANY TO ONE
  362.     #[ORM\ManyToOne(targetEntity:"App\Entity\UserAccountType", inversedBy:"users")]
  363.     #[ORM\JoinColumn(name:"account_type_id", referencedColumnName:"id")]
  364.     private $accountType;
  366.     // ONE TO MANY
  367.     #[ORM\OneToMany(targetEntity:'App\Entity\Document', mappedBy:'owner')]
  368.     private $uploads;
  369.     
  370.     #[ORM\OneToMany(targetEntity:'App\Entity\Document', mappedBy:'user')]
  371.     private $documents;
  372.    
  373.     #[ORM\OneToMany(targetEntity:'App\Entity\Notification', mappedBy:'user')]
  374.     private $notifications;
  375.     
  376.     #[ORM\OneToMany(targetEntity:'App\Entity\Log', mappedBy:'user')]
  377.     private $logs;
  379.     #[ORM\OneToMany(targetEntity:'App\Entity\JoinTableUserTest', mappedBy:'user')]
  380.     private $tests;
  382.     #[ORM\OneToMany(targetEntity:'App\Entity\TestCode', mappedBy:'user')]
  383.     private $codes;
  384.     
  385.     #[ORM\OneToMany(targetEntity:'App\Entity\TestAnswer', mappedBy:'user')]
  386.     private $answers;
  387.     
  388.     #[ORM\OneToMany(targetEntity:'App\Entity\JoinTableUserPermission', mappedBy:'user')]
  389.     private $permissions;
  391.     public function __construct()
  392.     {
  393.         $this->uploads = new ArrayCollection();
  394.         $this->documents = new ArrayCollection();
  395.         $this->notifications = new ArrayCollection();
  396.         $this->logs = new ArrayCollection();
  397.         $this->departments = new ArrayCollection();
  398.         $this->tests = new ArrayCollection();
  399.         $this->codes = new ArrayCollection();
  400.         $this->answers = new ArrayCollection();
  401.         $this->permissions = new ArrayCollection();
  402.     }
  404.     /**
  405.      * @inheritdoc
  406.      */
  407.     public function getRoles(): array
  408.     {
  409.         switch($this->role){
  410.             case 'ROLE_ADMIN': return array('ROLE_ADMIN');
  411.             case 'ROLE_USER': return array('ROLE_USER');
  412.         }
  413.     }
  415.     public function getSalt(): ?string
  416.     {
  417.         return null;
  418.     }
  420.     /**
  421.      * @see UserInterface
  422.      */
  423.     public function eraseCredentials()
  424.     {
  425.     }
  427.     public function getUserIdentifier(): string
  428.     {
  429.         return (string) $this->email;
  430.     }
  432.     public function getUsername(): string
  433.     {
  434.         return null;
  435.     }
  437.     /**
  438.      * @see PasswordAuthenticatedUserInterface
  439.      */
  440.     public function getPassword(): string
  441.     {
  442.         return $this->password;
  443.     }
  445.     public function setPassword(string $password): self
  446.     {
  447.         $this->password = $password;
  449.         return $this;
  450.     }
  452.     public function getId(): ?string
  453.     {
  454.         return $this->id;
  455.     }
  457.     public function getEmail(): ?string
  458.     {
  459.         return $this->email;
  460.     }
  462.     public function setEmail(?string $email): static
  463.     {
  464.         $this->email = $email;
  466.         return $this;
  467.     }
  469.     public function getName(): ?string
  470.     {
  471.         return $this->name;
  472.     }
  474.     public function setName(string $name): static
  475.     {
  476.         $this->name = $name;
  478.         return $this;
  479.     }
  481.     public function getSurname(): ?string
  482.     {
  483.         return $this->surname;
  484.     }
  486.     public function setSurname(string $surname): static
  487.     {
  488.         $this->surname = $surname;
  490.         return $this;
  491.     }
  493.     public function getDirectoryPath(): ?string
  494.     {
  495.         return $this->directoryPath;
  496.     }
  498.     public function setDirectoryPath(string $directoryPath): static
  499.     {
  500.         $this->directoryPath = $directoryPath;
  502.         return $this;
  503.     }
  505.     public function getOneTimeCode(): ?string
  506.     {
  507.         return $this->oneTimeCode;
  508.     }
  510.     public function setOneTimeCode(?string $oneTimeCode): static
  511.     {
  512.         $this->oneTimeCode = $oneTimeCode;
  514.         return $this;
  515.     }
  517.     public function getRole(): ?string
  518.     {
  519.         return $this->role;
  520.     }
  522.     public function setRole(string $role): static
  523.     {
  524.         $this->role = $role;
  526.         return $this;
  527.     }
  529.     public function getExpirationOneTimeCode(): ?\DateTimeInterface
  530.     {
  531.         return $this->expirationOneTimeCode;
  532.     }
  534.     public function setExpirationOneTimeCode(?\DateTimeInterface $expirationOneTimeCode): static
  535.     {
  536.         $this->expirationOneTimeCode = $expirationOneTimeCode;
  538.         return $this;
  539.     }
  541.     public function getOfficeHours(): ?string
  542.     {
  543.         return $this->officeHours;
  544.     }
  546.     public function setOfficeHours(?string $officeHours): static
  547.     {
  548.         $this->officeHours = $officeHours;
  550.         return $this;
  551.     }
  553.     public function isActive(): ?bool
  554.     {
  555.         return $this->active;
  556.     }
  558.     public function setActive(bool $active): static
  559.     {
  560.         $this->active = $active;
  562.         return $this;
  563.     }
  565.     public function isAdminActive(): ?bool
  566.     {
  567.         return $this->adminActive;
  568.     }
  570.     public function setAdminActive(bool $adminActive): static
  571.     {
  572.         $this->adminActive = $adminActive;
  574.         return $this;
  575.     }
  577.     public function isEmailNotificationActive(): ?bool
  578.     {
  579.         return $this->emailNotificationActive;
  580.     }
  582.     public function setEmailNotificationActive(bool $emailNotificationActive): static
  583.     {
  584.         $this->emailNotificationActive = $emailNotificationActive;
  586.         return $this;
  587.     }
  589.     public function isAlertRead(): ?bool
  590.     {
  591.         return $this->alertRead;
  592.     }
  594.     public function setAlertRead(bool $alertRead): static
  595.     {
  596.         $this->alertRead = $alertRead;
  598.         return $this;
  599.     }
  601.     public function isGdprSent(): ?bool
  602.     {
  603.         return $this->gdprSent;
  604.     }
  606.     public function setGdprSent(bool $gdprSent): static
  607.     {
  608.         $this->gdprSent = $gdprSent;
  610.         return $this;
  611.     }
  613.     public function getPrivacy(): ?UserPrivacy
  614.     {
  615.         return $this->privacy;
  616.     }
  618.     public function setPrivacy(?UserPrivacy $privacy): static
  619.     {
  620.         // unset the owning side of the relation if necessary
  621.         if ($privacy === null && $this->privacy !== null) {
  622.             $this->privacy->setUser(null);
  623.         }
  625.         // set the owning side of the relation if necessary
  626.         if ($privacy !== null && $privacy->getUser() !== $this) {
  627.             $privacy->setUser($this);
  628.         }
  630.         $this->privacy = $privacy;
  632.         return $this;
  633.     }
  635.     public function getProfile(): ?UserProfile
  636.     {
  637.         return $this->profile;
  638.     }
  640.     public function setProfile(?UserProfile $profile): static
  641.     {
  642.         // unset the owning side of the relation if necessary
  643.         if ($profile === null && $this->profile !== null) {
  644.             $this->profile->setUser(null);
  645.         }
  647.         // set the owning side of the relation if necessary
  648.         if ($profile !== null && $profile->getUser() !== $this) {
  649.             $profile->setUser($this);
  650.         }
  652.         $this->profile = $profile;
  654.         return $this;
  655.     }
  657.     public function getEmployee(): ?Employee
  658.     {
  659.         return $this->employee;
  660.     }
  662.     public function setEmployee(?Employee $employee): static
  663.     {
  664.         // unset the owning side of the relation if necessary
  665.         if ($employee === null && $this->employee !== null) {
  666.             $this->employee->setUser(null);
  667.         }
  669.         // set the owning side of the relation if necessary
  670.         if ($employee !== null && $employee->getUser() !== $this) {
  671.             $employee->setUser($this);
  672.         }
  674.         $this->employee = $employee;
  676.         return $this;
  677.     }
  679.     public function getAccountType(): ?UserAccountType
  680.     {
  681.         return $this->accountType;
  682.     }
  684.     public function setAccountType(?UserAccountType $accountType): static
  685.     {
  686.         $this->accountType = $accountType;
  688.         return $this;
  689.     }
  691.     /**
  692.      * @return Collection<int, Document>
  693.      */
  694.     public function getUploads(): Collection
  695.     {
  696.         return $this->uploads;
  697.     }
  699.     public function addUpload(Document $upload): static
  700.     {
  701.         if (!$this->uploads->contains($upload)) {
  702.             $this->uploads->add($upload);
  703.             $upload->setOwner($this);
  704.         }
  706.         return $this;
  707.     }
  709.     public function removeUpload(Document $upload): static
  710.     {
  711.         if ($this->uploads->removeElement($upload)) {
  712.             // set the owning side to null (unless already changed)
  713.             if ($upload->getOwner() === $this) {
  714.                 $upload->setOwner(null);
  715.             }
  716.         }
  718.         return $this;
  719.     }
  721.     /**
  722.      * @return Collection<int, Document>
  723.      */
  724.     public function getDocuments(): Collection
  725.     {
  726.         return $this->documents;
  727.     }
  729.     public function addDocument(Document $document): static
  730.     {
  731.         if (!$this->documents->contains($document)) {
  732.             $this->documents->add($document);
  733.             $document->setUser($this);
  734.         }
  736.         return $this;
  737.     }
  739.     public function removeDocument(Document $document): static
  740.     {
  741.         if ($this->documents->removeElement($document)) {
  742.             // set the owning side to null (unless already changed)
  743.             if ($document->getUser() === $this) {
  744.                 $document->setUser(null);
  745.             }
  746.         }
  748.         return $this;
  749.     }
  751.     /**
  752.      * @return Collection<int, Notification>
  753.      */
  754.     public function getNotifications(): Collection
  755.     {
  756.         return $this->notifications;
  757.     }
  759.     public function addNotification(Notification $notification): static
  760.     {
  761.         if (!$this->notifications->contains($notification)) {
  762.             $this->notifications->add($notification);
  763.             $notification->setUser($this);
  764.         }
  766.         return $this;
  767.     }
  769.     public function removeNotification(Notification $notification): static
  770.     {
  771.         if ($this->notifications->removeElement($notification)) {
  772.             // set the owning side to null (unless already changed)
  773.             if ($notification->getUser() === $this) {
  774.                 $notification->setUser(null);
  775.             }
  776.         }
  778.         return $this;
  779.     }
  781.     /**
  782.      * @return Collection<int, Log>
  783.      */
  784.     public function getLogs(): Collection
  785.     {
  786.         return $this->logs;
  787.     }
  789.     public function addLog(Log $log): static
  790.     {
  791.         if (!$this->logs->contains($log)) {
  792.             $this->logs->add($log);
  793.             $log->setUser($this);
  794.         }
  796.         return $this;
  797.     }
  799.     public function removeLog(Log $log): static
  800.     {
  801.         if ($this->logs->removeElement($log)) {
  802.             // set the owning side to null (unless already changed)
  803.             if ($log->getUser() === $this) {
  804.                 $log->setUser(null);
  805.             }
  806.         }
  808.         return $this;
  809.     }
  811.     /**
  812.      * @return Collection<int, HospitalDepartmentReferent>
  813.      */
  814.     public function getDepartments(): Collection
  815.     {
  816.         return $this->departments;
  817.     }
  819.     public function addDepartment(HospitalDepartmentReferent $department): static
  820.     {
  821.         if (!$this->departments->contains($department)) {
  822.             $this->departments->add($department);
  823.             $department->setUser($this);
  824.         }
  826.         return $this;
  827.     }
  829.     public function removeDepartment(HospitalDepartmentReferent $department): static
  830.     {
  831.         if ($this->departments->removeElement($department)) {
  832.             // set the owning side to null (unless already changed)
  833.             if ($department->getUser() === $this) {
  834.                 $department->setUser(null);
  835.             }
  836.         }
  838.         return $this;
  839.     }
  841.     /**
  842.      * @return Collection<int, JoinTableUserTest>
  843.      */
  844.     public function getTests(): Collection
  845.     {
  846.         return $this->tests;
  847.     }
  849.     public function addTest(JoinTableUserTest $test): static
  850.     {
  851.         if (!$this->tests->contains($test)) {
  852.             $this->tests->add($test);
  853.             $test->setUser($this);
  854.         }
  856.         return $this;
  857.     }
  859.     public function removeTest(JoinTableUserTest $test): static
  860.     {
  861.         if ($this->tests->removeElement($test)) {
  862.             // set the owning side to null (unless already changed)
  863.             if ($test->getUser() === $this) {
  864.                 $test->setUser(null);
  865.             }
  866.         }
  868.         return $this;
  869.     }
  871.     /**
  872.      * @return Collection<int, TestCode>
  873.      */
  874.     public function getCodes(): Collection
  875.     {
  876.         return $this->codes;
  877.     }
  879.     public function addCode(TestCode $code): static
  880.     {
  881.         if (!$this->codes->contains($code)) {
  882.             $this->codes->add($code);
  883.             $code->setUser($this);
  884.         }
  886.         return $this;
  887.     }
  889.     public function removeCode(TestCode $code): static
  890.     {
  891.         if ($this->codes->removeElement($code)) {
  892.             // set the owning side to null (unless already changed)
  893.             if ($code->getUser() === $this) {
  894.                 $code->setUser(null);
  895.             }
  896.         }
  898.         return $this;
  899.     }
  901.     /**
  902.      * @return Collection<int, TestAnswer>
  903.      */
  904.     public function getAnswers(): Collection
  905.     {
  906.         return $this->answers;
  907.     }
  909.     public function addAnswer(TestAnswer $answer): static
  910.     {
  911.         if (!$this->answers->contains($answer)) {
  912.             $this->answers->add($answer);
  913.             $answer->setUser($this);
  914.         }
  916.         return $this;
  917.     }
  919.     public function removeAnswer(TestAnswer $answer): static
  920.     {
  921.         if ($this->answers->removeElement($answer)) {
  922.             // set the owning side to null (unless already changed)
  923.             if ($answer->getUser() === $this) {
  924.                 $answer->setUser(null);
  925.             }
  926.         }
  928.         return $this;
  929.     }
  931.     /**
  932.      * @return Collection<int, JoinTableUserPermission>
  933.      */
  934.     public function getPermissions(): Collection
  935.     {
  936.         return $this->permissions;
  937.     }
  939.     public function addPermission(JoinTableUserPermission $permission): static
  940.     {
  941.         if (!$this->permissions->contains($permission)) {
  942.             $this->permissions->add($permission);
  943.             $permission->setUser($this);
  944.         }
  946.         return $this;
  947.     }
  949.     public function removePermission(JoinTableUserPermission $permission): static
  950.     {
  951.         if ($this->permissions->removeElement($permission)) {
  952.             // set the owning side to null (unless already changed)
  953.             if ($permission->getUser() === $this) {
  954.                 $permission->setUser(null);
  955.             }
  956.         }
  958.         return $this;
  959.     }
  961. }