src/Entity/Slave/User.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity\Slave;
  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\UserInterface;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. /**
  13.  * @ORM\Table(name="eposm_s_user")
  14.  * @ORM\Entity(repositoryClass="App\Repository\Slave\UserRepository")
  15.  * @ORM\HasLifecycleCallbacks()
  16.  */
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     public function __toString(){
  20.                                                                                                                                                                                                                                                                                                                                                                                                                                 return $this->profile->getSurname().' '.$this->profile->getName(); 
  21.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  23.     public function getPlainName(){
  24.         $user = $this->profile->getSurname().' '.$this->profile->getName();
  25.         $user = preg_replace('/ò/', 'o', $user);
  26.         $user = preg_replace('/à/', 'a', $user);
  27.         $user = preg_replace('/è/', 'e', $user);
  28.         $user = preg_replace('/ù/', 'u', $user);
  29.         $user = preg_replace('/é/', 'e', $user);
  30.         $user = preg_replace('/ì/', 'i', $user);
  31.         return $user;
  32.     }
  33.     
  34.     public function getNameShort(){
  35.         return $this->profile->getSurname().' '.substr($this->profile->getName(), 0, 1).'.'; 
  36.     }
  38.     public function displayNameAndCountTickets(){
  39.                                                                                                                                                                                                                                                                                                                                                                                                                                 return $this->profile->getSurname().' '.$this->profile->getName().' ('.$this->countTicketsUnderManagement('actual').' / '.$this->countTicketsUnderManagement('suspension').')';
  40.                                                                                                                                                                                                                                                                                                                                                                                                                             }
  42.     public function getPermissionType($permissionSlug){
  43.         foreach($this->getAccountType()->getPermissions() as $jt){
  44.             if($jt->getPermission()->getSlug() == $permissionSlug)
  45.                 return $jt->getRw();
  46.         }
  47.         return "";
  48.     }
  50.     public function getPermissionWarehouse($warehouseId){
  51.         foreach($this->getWarehouses() as $jt){
  52.             if($jt->getWarehouse()->getId() == $warehouseId)
  53.                 return $jt->getPermission();
  54.         }
  55.         return "";
  56.     }
  58.     public function getPermissionTransfer($transferId){
  59.         foreach($this->getTransfersUserFrom() as $tf){
  60.             if($this->getPermissionWarehouse($tf->getWarehouseFrom()) == "RW" || $this->getPermissionWarehouse($tf->getWarehouseTo()) == "RW");
  61.                 return true;
  62.         }
  63.         foreach($this->getTransfersUserTo() as $tt){
  64.             if($this->getPermissionWarehouse($tt->getWarehouseFrom()) == "RW" || $this->getPermissionWarehouse($tt->getWarehouseTo()) == "RW");
  65.                 return true;
  66.         }
  67.         return false;
  68.     }
  70.     public function getPermissionTicket($ticketId){
  71.         if($this->getAccountTypology() != 'technician')
  72.             return true;
  73.         else{
  74.             foreach($this->getTickets() as $t){
  75.                 if($t->getId() == $ticketId)
  76.                     return true;
  77.             }
  78.         }
  79.         return false;
  80.     }
  82.     public function getAccountTypology(){
  83.         switch($this->getAccountType()->getCategory()->getSlug()){
  84.             case 'agency':
  85.             case 'administration':
  86.             case 'commercial':
  87.             case 'warehouse':
  88.                 return $this->getAccountType()->getCategory()->getSlug();
  89.                 break;
  90.             case 'tech-internal':
  91.             case 'tech-external':
  92.                 return 'technician';
  93.                 break;
  94.             default: break;
  95.         }
  96.     }
  98.     public function canMakeTicketActions($type, $settingBackOfficeValue){
  99.         switch($type){
  100.             case 'technician':
  101.                 if($this->getAccountTypology() == 'technician' || (($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse') && $settingBackOfficeValue))
  102.                     return true;
  103.                 break;
  104.             case 'only_backoffice':
  105.                 if(($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse') && $settingBackOfficeValue)
  106.                     return true;
  107.                 break;
  108.             case 'agency_warehouse':
  109.                 if($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse')
  110.                     return true;
  111.                 break;
  112.             default: break;
  113.         }
  114.         return false;
  115.     }
  117.     public function getCanDelete(){
  118.         if(sizeof($this->warehouses) > 0) return false;
  119.         if(sizeof($this->technicianAreas) > 0) return false;
  120.         if(sizeof($this->tickets) > 0) return false;
  121.         if(sizeof($this->interventions) > 0) return false;
  122.         return true;
  123.     }
  124.     
  125.     public function isInHolidayAtDate($date){
  126.         $holidays = array();
  127.         foreach($this->getHolidays() as $h){
  128.             if($date->format('Ymd') >= $h->getDateFrom()->format('Ymd') && $date->format('Ymd') <= $h->getDateTo()->format('Ymd'))
  129.                 return true;
  130.         }
  131.         return false;
  132.     }
  134.     public function getActualHoliday(){
  135.         $today = new \Datetime();
  136.         $holidays = array();
  137.         foreach($this->getHolidays() as $h){
  138.             if($today->format('Ymd') >= $h->getDateFrom()->format('Ymd') && $today->format('Ymd') <= $h->getDateTo()->format('Ymd'))
  139.                 return $h;
  140.         }
  141.         return false;
  142.     }
  144.     public function canRead($area){
  145.         foreach($this->getAccountType()->getPermissions() as $jt){
  146.             if($area == $jt->getPermission()->getSlug()){
  147.                 return true;
  148.                 break;
  149.             }
  150.         }
  151.     }
  152.     
  153.     public function canWrite($area){
  154.         foreach($this->getAccountType()->getPermissions() as $jt){
  155.             if($area == $jt->getPermission()->getSlug() && $jt->getRW() == 'RW'){
  156.                 return true;
  157.                 break;
  158.             }
  159.         }
  160.     }
  161.     
  162.     public function canViewTab($tabSlug){
  163.         foreach($this->getAccountType()->getPermissions() as $jt){
  164.             if(str_contains($jt->getPermission()->getSlug(), $tabSlug)){
  165.                 return true;
  166.                 break;
  167.             }
  168.         }
  169.         return false;
  170.     }
  172.     public function countTicketsUnderManagement($type){
  173.         $count = 0;
  174.         foreach($this->getTickets() as $ticket){
  175.             switch($type){
  176.                 case 'actual': if($ticket->getStatus()->getSlug() == 'assigned' || $ticket->getStatus()->getSlug() == 'taken_charge') $count++; break;
  177.                 case 'suspension': if($ticket->getStatus()->getSlug() == 'suspension_request' || $ticket->getStatus()->getSlug() == 'suspended') $count++; break;
  178.                 case 'actual_and_suspension': if($ticket->getStatus()->getSlug() == 'assigned' || $ticket->getStatus()->getSlug() == 'taken_charge' || $ticket->getStatus()->getSlug() == 'suspension_request' || $ticket->getStatus()->getSlug() == 'suspended') $count++; break;
  179.                 case 'closed': if($ticket->getStatus()->getSlug() == 'closed' || $ticket->getStatus()->getSlug() == 'closed_portal') $count++; break;
  180.                 default: break;
  181.             }
  182.         }
  183.         return $count;
  184.     }
  185.     
  186.     public function mainWarehouse(){
  187.         if(sizeof($this->getWarehouses()) == 1)
  188.             return $this->getWarehouses()[0]->getWarehouse();
  189.         foreach($this->getWarehouses() as $jtuw){
  190.             if($jtuw->isMain())
  191.                 return $jtuw->getWarehouse();
  192.         }
  193.         return null;
  194.     }
  196.     public function getTechnicianSelectableWarehouses(){
  197.         $warehouses = array();
  198.         foreach($this->getWarehouses() as $jtuw){
  199.             if($jtuw->getPermission() == 'RW' && !$jtuw->getWarehouse()->isHeadquarter())
  200.                 $warehouses[] = $jtuw->getWarehouse();
  201.         }
  202.         return $warehouses;
  203.     }
  204.     
  205.     /**
  206.      * @ORM\Column(name="id", type="bigint")
  207.      * @ORM\Id
  208.      * @ORM\GeneratedValue(strategy="AUTO")
  209.      */
  210.     protected $id;
  211.     
  212.     /**
  213.      * @ORM\Column(name="email", type="string", length=191, unique=true)
  214.      */
  215.     protected $email;
  216.     
  217.     /**
  218.      * @ORM\Column(name="password", type="string", length=191, nullable=true)
  219.      */
  220.     protected $password;
  221.     
  222.     /**
  223.      * @ORM\Column(name="role", type="string", length=191)
  224.      */
  225.     protected $role = "ROLE_USER";
  226.     
  227.     /**
  228.      * @ORM\Column(name="one_time_code", type="string", length=191, nullable=true)
  229.      */
  230.     protected $oneTimeCode;
  231.     
  232.     /**
  233.      * @ORM\Column(name="expiration_one_time_code", type="datetime", nullable=true)
  234.      */
  235.     protected $expirationOneTimeCode;
  236.     
  237.     /**
  238.      * @ORM\Column(name="product_transfer_download_method", type="string", length=191)
  239.      */
  240.     protected $productTransferDownloadMethod = 'all';
  241.         
  242.     /**
  243.      * @ORM\Column(name="is_active", type="boolean")
  244.      */
  245.     protected $active = false;
  247.     /**
  248.      * @ORM\Column(name="is_company_active", type="boolean")
  249.      */
  250.     protected $companyActive = true;
  251.         
  252.     /**
  253.      * @ORM\Column(name="is_admin_active", type="boolean")
  254.      */
  255.     protected $adminActive = true;
  256.     
  257.     /**
  258.      * @ORM\Column(name="exclude_auto_assign", type="boolean")
  259.      */
  260.     protected $excludeAutoAssign = false;
  261.     
  262.     /**
  263.      * @ORM\Column(name="is_economic_visible", type="boolean")
  264.      */
  265.     protected $economicVisible = true;
  266.     
  267.     /**
  268.      * @ORM\Column(name="can_exchange_tickets", type="boolean")
  269.      */
  270.     protected $canExchangeTickets = false;
  271.     
  272.     /**
  273.      * @ORM\Column(name="is_assign_email_active", type="boolean")
  274.      */
  275.     protected $assignEmailActive = true;
  277.     /**
  278.      * @ORM\Column(name="is_send_material_direct", type="boolean")
  279.      */
  280.     protected $sendMaterialDirect = false;
  281.     
  282.     // OneToOne
  283.         /**
  284.         * @ORM\OneToOne(targetEntity="App\Entity\Slave\UserProfile", mappedBy="user")
  285.         */
  286.         private $profile;
  287.     //
  289.     // ManyToOne
  290.         /**
  291.          * @ORM\ManyToOne(targetEntity="App\Entity\Slave\AccountType", inversedBy="users")
  292.          * @ORM\JoinColumn(name="account_type_id", referencedColumnName="id")
  293.          */
  294.         private $accountType;
  295.     //
  297.     // OneToMany
  298.         /**
  299.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserDocument", mappedBy="user")
  300.          */
  301.         private $documents;
  302.         
  303.         /**
  304.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="user")
  305.          */
  306.         private $holidays;
  307.         
  308.         /**
  309.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="substitute")
  310.          */
  311.         private $substitutions;
  313.         /**
  314.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserWarehouse", mappedBy="user")
  315.          */
  316.         private $warehouses;
  318.         /**
  319.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TechnicianArea", mappedBy="user")
  320.          */
  321.         private $technicianAreas;
  322.         
  323.         /**
  324.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserSupplier", mappedBy="user")
  325.          */
  326.         private $suppliers;
  327.         
  328.         /**
  329.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransferLog", mappedBy="user")
  330.          */
  331.         private $transferLogs;
  333.         /**
  334.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userFrom")
  335.          */
  336.         private $transfersUserFrom;
  338.         /**
  339.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userTo")
  340.          */
  341.         private $transfersUserTo;
  343.         /**
  344.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Ticket", mappedBy="technician")
  345.          */
  346.         private $tickets;
  348.         /**
  349.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="technician")
  350.          */
  351.         private $interventions;
  352.         
  353.         /**
  354.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="operator")
  355.          */
  356.         private $operatorInterventions;
  358.         /**
  359.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductRequest", mappedBy="technician")
  360.          */
  361.         private $productRequests;        
  363.         /**
  364.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TicketReminder", mappedBy="technician")
  365.          */
  366.         private $reminders;
  367.         
  368.         /**
  369.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductLog", mappedBy="user")
  370.          */
  371.         private $productLogs;
  372.     //
  374.     // ManyToMany
  375.         /**
  376.          * @ORM\ManyToMany(targetEntity="App\Entity\Slave\Supplier", inversedBy="autoAssignUsers")
  377.          * @ORM\JoinTable(name="eposm_s_join_table_user_supplier_auto_assign")
  378.          */
  379.         private $autoAssignSuppliers;
  381.         public function __construct()
  382.         {
  383.             $this->documents = new ArrayCollection();
  384.             $this->holidays = new ArrayCollection();
  385.             $this->substitutions = new ArrayCollection();
  386.             $this->warehouses = new ArrayCollection();
  387.             $this->technicianAreas = new ArrayCollection();
  388.             $this->suppliers = new ArrayCollection();
  389.             $this->transferLogs = new ArrayCollection();
  390.             $this->transfersUserFrom = new ArrayCollection();
  391.             $this->transfersUserTo = new ArrayCollection();
  392.             $this->tickets = new ArrayCollection();
  393.             $this->interventions = new ArrayCollection();
  394.             $this->operatorInterventions = new ArrayCollection();
  395.             $this->productRequests = new ArrayCollection();
  396.             $this->reminders = new ArrayCollection();
  397.             $this->productLogs = new ArrayCollection();
  398.             $this->autoAssignSuppliers = new ArrayCollection();
  399.         }
  400.     //
  402.     /**
  403.      * @inheritdoc
  404.      */
  405.     public function getRoles(): array
  406.     {
  407.         switch($this->role){
  408.             case 'ROLE_USER': return array('ROLE_USER');
  409.         };
  410.     }
  412.     public function getSalt(): ?string
  413.     {
  414.         return null;
  415.     }
  417.     /**
  418.      * @see UserInterface
  419.      */
  420.     public function eraseCredentials()
  421.     {
  422.     }
  423.     
  424.     public function getUserIdentifier(): string
  425.     {
  426.         return (string) $this->email;
  427.     }
  429.     public function getUsername(): string
  430.     {
  431.         return (string) $this->email;
  432.     }
  434.     public function getPassword(): ?string
  435.     {
  436.         return $this->password;
  437.     }
  439.     public function setPassword(?string $password): static
  440.     {
  441.         $this->password = $password;
  443.         return $this;
  444.     }
  446.     public function getId(): ?string
  447.     {
  448.         return $this->id;
  449.     }
  451.     public function getEmail(): ?string
  452.     {
  453.         return $this->email;
  454.     }
  456.     public function setEmail(string $email): static
  457.     {
  458.         $this->email = $email;
  460.         return $this;
  461.     }
  463.     public function getRole(): ?string
  464.     {
  465.         return $this->role;
  466.     }
  468.     public function setRole(string $role): static
  469.     {
  470.         $this->role = $role;
  472.         return $this;
  473.     }
  475.     public function getOneTimeCode(): ?string
  476.     {
  477.         return $this->oneTimeCode;
  478.     }
  480.     public function setOneTimeCode(?string $oneTimeCode): static
  481.     {
  482.         $this->oneTimeCode = $oneTimeCode;
  484.         return $this;
  485.     }
  487.     public function getExpirationOneTimeCode(): ?\DateTimeInterface
  488.     {
  489.         return $this->expirationOneTimeCode;
  490.     }
  492.     public function setExpirationOneTimeCode(?\DateTimeInterface $expirationOneTimeCode): static
  493.     {
  494.         $this->expirationOneTimeCode = $expirationOneTimeCode;
  496.         return $this;
  497.     }
  499.     public function getProductTransferDownloadMethod(): ?string
  500.     {
  501.         return $this->productTransferDownloadMethod;
  502.     }
  504.     public function setProductTransferDownloadMethod(string $productTransferDownloadMethod): static
  505.     {
  506.         $this->productTransferDownloadMethod = $productTransferDownloadMethod;
  508.         return $this;
  509.     }
  511.     public function isActive(): ?bool
  512.     {
  513.         return $this->active;
  514.     }
  516.     public function setActive(bool $active): static
  517.     {
  518.         $this->active = $active;
  520.         return $this;
  521.     }
  523.     public function isCompanyActive(): ?bool
  524.     {
  525.         return $this->companyActive;
  526.     }
  528.     public function setCompanyActive(bool $companyActive): static
  529.     {
  530.         $this->companyActive = $companyActive;
  532.         return $this;
  533.     }
  535.     public function isAdminActive(): ?bool
  536.     {
  537.         return $this->adminActive;
  538.     }
  540.     public function setAdminActive(bool $adminActive): static
  541.     {
  542.         $this->adminActive = $adminActive;
  544.         return $this;
  545.     }
  547.     public function isExcludeAutoAssign(): ?bool
  548.     {
  549.         return $this->excludeAutoAssign;
  550.     }
  552.     public function setExcludeAutoAssign(bool $excludeAutoAssign): static
  553.     {
  554.         $this->excludeAutoAssign = $excludeAutoAssign;
  556.         return $this;
  557.     }
  559.     public function isEconomicVisible(): ?bool
  560.     {
  561.         return $this->economicVisible;
  562.     }
  564.     public function setEconomicVisible(bool $economicVisible): static
  565.     {
  566.         $this->economicVisible = $economicVisible;
  568.         return $this;
  569.     }
  571.     public function isCanExchangeTickets(): ?bool
  572.     {
  573.         return $this->canExchangeTickets;
  574.     }
  576.     public function setCanExchangeTickets(bool $canExchangeTickets): static
  577.     {
  578.         $this->canExchangeTickets = $canExchangeTickets;
  580.         return $this;
  581.     }
  583.     public function isAssignEmailActive(): ?bool
  584.     {
  585.         return $this->assignEmailActive;
  586.     }
  588.     public function setAssignEmailActive(bool $assignEmailActive): static
  589.     {
  590.         $this->assignEmailActive = $assignEmailActive;
  592.         return $this;
  593.     }
  595.     public function isSendMaterialDirect(): ?bool
  596.     {
  597.         return $this->sendMaterialDirect;
  598.     }
  600.     public function setSendMaterialDirect(bool $sendMaterialDirect): static
  601.     {
  602.         $this->sendMaterialDirect = $sendMaterialDirect;
  604.         return $this;
  605.     }
  607.     public function getProfile(): ?UserProfile
  608.     {
  609.         return $this->profile;
  610.     }
  612.     public function setProfile(?UserProfile $profile): static
  613.     {
  614.         // unset the owning side of the relation if necessary
  615.         if ($profile === null && $this->profile !== null) {
  616.             $this->profile->setUser(null);
  617.         }
  619.         // set the owning side of the relation if necessary
  620.         if ($profile !== null && $profile->getUser() !== $this) {
  621.             $profile->setUser($this);
  622.         }
  624.         $this->profile = $profile;
  626.         return $this;
  627.     }
  629.     public function getAccountType(): ?AccountType
  630.     {
  631.         return $this->accountType;
  632.     }
  634.     public function setAccountType(?AccountType $accountType): static
  635.     {
  636.         $this->accountType = $accountType;
  638.         return $this;
  639.     }
  641.     /**
  642.      * @return Collection<int, UserDocument>
  643.      */
  644.     public function getDocuments(): Collection
  645.     {
  646.         return $this->documents;
  647.     }
  649.     public function addDocument(UserDocument $document): static
  650.     {
  651.         if (!$this->documents->contains($document)) {
  652.             $this->documents->add($document);
  653.             $document->setUser($this);
  654.         }
  656.         return $this;
  657.     }
  659.     public function removeDocument(UserDocument $document): static
  660.     {
  661.         if ($this->documents->removeElement($document)) {
  662.             // set the owning side to null (unless already changed)
  663.             if ($document->getUser() === $this) {
  664.                 $document->setUser(null);
  665.             }
  666.         }
  668.         return $this;
  669.     }
  671.     /**
  672.      * @return Collection<int, UserHoliday>
  673.      */
  674.     public function getHolidays(): Collection
  675.     {
  676.         return $this->holidays;
  677.     }
  679.     public function addHoliday(UserHoliday $holiday): static
  680.     {
  681.         if (!$this->holidays->contains($holiday)) {
  682.             $this->holidays->add($holiday);
  683.             $holiday->setUser($this);
  684.         }
  686.         return $this;
  687.     }
  689.     public function removeHoliday(UserHoliday $holiday): static
  690.     {
  691.         if ($this->holidays->removeElement($holiday)) {
  692.             // set the owning side to null (unless already changed)
  693.             if ($holiday->getUser() === $this) {
  694.                 $holiday->setUser(null);
  695.             }
  696.         }
  698.         return $this;
  699.     }
  701.     /**
  702.      * @return Collection<int, UserHoliday>
  703.      */
  704.     public function getSubstitutions(): Collection
  705.     {
  706.         return $this->substitutions;
  707.     }
  709.     public function addSubstitution(UserHoliday $substitution): static
  710.     {
  711.         if (!$this->substitutions->contains($substitution)) {
  712.             $this->substitutions->add($substitution);
  713.             $substitution->setSubstitute($this);
  714.         }
  716.         return $this;
  717.     }
  719.     public function removeSubstitution(UserHoliday $substitution): static
  720.     {
  721.         if ($this->substitutions->removeElement($substitution)) {
  722.             // set the owning side to null (unless already changed)
  723.             if ($substitution->getSubstitute() === $this) {
  724.                 $substitution->setSubstitute(null);
  725.             }
  726.         }
  728.         return $this;
  729.     }
  731.     /**
  732.      * @return Collection<int, JoinTableUserWarehouse>
  733.      */
  734.     public function getWarehouses(): Collection
  735.     {
  736.         return $this->warehouses;
  737.     }
  739.     public function addWarehouse(JoinTableUserWarehouse $warehouse): static
  740.     {
  741.         if (!$this->warehouses->contains($warehouse)) {
  742.             $this->warehouses->add($warehouse);
  743.             $warehouse->setUser($this);
  744.         }
  746.         return $this;
  747.     }
  749.     public function removeWarehouse(JoinTableUserWarehouse $warehouse): static
  750.     {
  751.         if ($this->warehouses->removeElement($warehouse)) {
  752.             // set the owning side to null (unless already changed)
  753.             if ($warehouse->getUser() === $this) {
  754.                 $warehouse->setUser(null);
  755.             }
  756.         }
  758.         return $this;
  759.     }
  761.     /**
  762.      * @return Collection<int, TechnicianArea>
  763.      */
  764.     public function getTechnicianAreas(): Collection
  765.     {
  766.         return $this->technicianAreas;
  767.     }
  769.     public function addTechnicianArea(TechnicianArea $technicianArea): static
  770.     {
  771.         if (!$this->technicianAreas->contains($technicianArea)) {
  772.             $this->technicianAreas->add($technicianArea);
  773.             $technicianArea->setUser($this);
  774.         }
  776.         return $this;
  777.     }
  779.     public function removeTechnicianArea(TechnicianArea $technicianArea): static
  780.     {
  781.         if ($this->technicianAreas->removeElement($technicianArea)) {
  782.             // set the owning side to null (unless already changed)
  783.             if ($technicianArea->getUser() === $this) {
  784.                 $technicianArea->setUser(null);
  785.             }
  786.         }
  788.         return $this;
  789.     }
  791.     /**
  792.      * @return Collection<int, JoinTableUserSupplier>
  793.      */
  794.     public function getSuppliers(): Collection
  795.     {
  796.         return $this->suppliers;
  797.     }
  799.     public function addSupplier(JoinTableUserSupplier $supplier): static
  800.     {
  801.         if (!$this->suppliers->contains($supplier)) {
  802.             $this->suppliers->add($supplier);
  803.             $supplier->setUser($this);
  804.         }
  806.         return $this;
  807.     }
  809.     public function removeSupplier(JoinTableUserSupplier $supplier): static
  810.     {
  811.         if ($this->suppliers->removeElement($supplier)) {
  812.             // set the owning side to null (unless already changed)
  813.             if ($supplier->getUser() === $this) {
  814.                 $supplier->setUser(null);
  815.             }
  816.         }
  818.         return $this;
  819.     }
  821.     /**
  822.      * @return Collection<int, ProductTransferLog>
  823.      */
  824.     public function getTransferLogs(): Collection
  825.     {
  826.         return $this->transferLogs;
  827.     }
  829.     public function addTransferLog(ProductTransferLog $transferLog): static
  830.     {
  831.         if (!$this->transferLogs->contains($transferLog)) {
  832.             $this->transferLogs->add($transferLog);
  833.             $transferLog->setUser($this);
  834.         }
  836.         return $this;
  837.     }
  839.     public function removeTransferLog(ProductTransferLog $transferLog): static
  840.     {
  841.         if ($this->transferLogs->removeElement($transferLog)) {
  842.             // set the owning side to null (unless already changed)
  843.             if ($transferLog->getUser() === $this) {
  844.                 $transferLog->setUser(null);
  845.             }
  846.         }
  848.         return $this;
  849.     }
  851.     /**
  852.      * @return Collection<int, ProductTransfer>
  853.      */
  854.     public function getTransfersUserFrom(): Collection
  855.     {
  856.         return $this->transfersUserFrom;
  857.     }
  859.     public function addTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  860.     {
  861.         if (!$this->transfersUserFrom->contains($transfersUserFrom)) {
  862.             $this->transfersUserFrom->add($transfersUserFrom);
  863.             $transfersUserFrom->setUserFrom($this);
  864.         }
  866.         return $this;
  867.     }
  869.     public function removeTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  870.     {
  871.         if ($this->transfersUserFrom->removeElement($transfersUserFrom)) {
  872.             // set the owning side to null (unless already changed)
  873.             if ($transfersUserFrom->getUserFrom() === $this) {
  874.                 $transfersUserFrom->setUserFrom(null);
  875.             }
  876.         }
  878.         return $this;
  879.     }
  881.     /**
  882.      * @return Collection<int, ProductTransfer>
  883.      */
  884.     public function getTransfersUserTo(): Collection
  885.     {
  886.         return $this->transfersUserTo;
  887.     }
  889.     public function addTransfersUserTo(ProductTransfer $transfersUserTo): static
  890.     {
  891.         if (!$this->transfersUserTo->contains($transfersUserTo)) {
  892.             $this->transfersUserTo->add($transfersUserTo);
  893.             $transfersUserTo->setUserTo($this);
  894.         }
  896.         return $this;
  897.     }
  899.     public function removeTransfersUserTo(ProductTransfer $transfersUserTo): static
  900.     {
  901.         if ($this->transfersUserTo->removeElement($transfersUserTo)) {
  902.             // set the owning side to null (unless already changed)
  903.             if ($transfersUserTo->getUserTo() === $this) {
  904.                 $transfersUserTo->setUserTo(null);
  905.             }
  906.         }
  908.         return $this;
  909.     }
  911.     /**
  912.      * @return Collection<int, Ticket>
  913.      */
  914.     public function getTickets(): Collection
  915.     {
  916.         return $this->tickets;
  917.     }
  919.     public function addTicket(Ticket $ticket): static
  920.     {
  921.         if (!$this->tickets->contains($ticket)) {
  922.             $this->tickets->add($ticket);
  923.             $ticket->setTechnician($this);
  924.         }
  926.         return $this;
  927.     }
  929.     public function removeTicket(Ticket $ticket): static
  930.     {
  931.         if ($this->tickets->removeElement($ticket)) {
  932.             // set the owning side to null (unless already changed)
  933.             if ($ticket->getTechnician() === $this) {
  934.                 $ticket->setTechnician(null);
  935.             }
  936.         }
  938.         return $this;
  939.     }
  941.     /**
  942.      * @return Collection<int, Intervention>
  943.      */
  944.     public function getInterventions(): Collection
  945.     {
  946.         return $this->interventions;
  947.     }
  949.     public function addIntervention(Intervention $intervention): static
  950.     {
  951.         if (!$this->interventions->contains($intervention)) {
  952.             $this->interventions->add($intervention);
  953.             $intervention->setTechnician($this);
  954.         }
  956.         return $this;
  957.     }
  959.     public function removeIntervention(Intervention $intervention): static
  960.     {
  961.         if ($this->interventions->removeElement($intervention)) {
  962.             // set the owning side to null (unless already changed)
  963.             if ($intervention->getTechnician() === $this) {
  964.                 $intervention->setTechnician(null);
  965.             }
  966.         }
  968.         return $this;
  969.     }
  971.     /**
  972.      * @return Collection<int, Intervention>
  973.      */
  974.     public function getOperatorInterventions(): Collection
  975.     {
  976.         return $this->operatorInterventions;
  977.     }
  979.     public function addOperatorIntervention(Intervention $operatorIntervention): static
  980.     {
  981.         if (!$this->operatorInterventions->contains($operatorIntervention)) {
  982.             $this->operatorInterventions->add($operatorIntervention);
  983.             $operatorIntervention->setOperator($this);
  984.         }
  986.         return $this;
  987.     }
  989.     public function removeOperatorIntervention(Intervention $operatorIntervention): static
  990.     {
  991.         if ($this->operatorInterventions->removeElement($operatorIntervention)) {
  992.             // set the owning side to null (unless already changed)
  993.             if ($operatorIntervention->getOperator() === $this) {
  994.                 $operatorIntervention->setOperator(null);
  995.             }
  996.         }
  998.         return $this;
  999.     }
  1001.     /**
  1002.      * @return Collection<int, ProductRequest>
  1003.      */
  1004.     public function getProductRequests(): Collection
  1005.     {
  1006.         return $this->productRequests;
  1007.     }
  1009.     public function addProductRequest(ProductRequest $productRequest): static
  1010.     {
  1011.         if (!$this->productRequests->contains($productRequest)) {
  1012.             $this->productRequests->add($productRequest);
  1013.             $productRequest->setTechnician($this);
  1014.         }
  1016.         return $this;
  1017.     }
  1019.     public function removeProductRequest(ProductRequest $productRequest): static
  1020.     {
  1021.         if ($this->productRequests->removeElement($productRequest)) {
  1022.             // set the owning side to null (unless already changed)
  1023.             if ($productRequest->getTechnician() === $this) {
  1024.                 $productRequest->setTechnician(null);
  1025.             }
  1026.         }
  1028.         return $this;
  1029.     }
  1031.     /**
  1032.      * @return Collection<int, TicketReminder>
  1033.      */
  1034.     public function getReminders(): Collection
  1035.     {
  1036.         return $this->reminders;
  1037.     }
  1039.     public function addReminder(TicketReminder $reminder): static
  1040.     {
  1041.         if (!$this->reminders->contains($reminder)) {
  1042.             $this->reminders->add($reminder);
  1043.             $reminder->setTechnician($this);
  1044.         }
  1046.         return $this;
  1047.     }
  1049.     public function removeReminder(TicketReminder $reminder): static
  1050.     {
  1051.         if ($this->reminders->removeElement($reminder)) {
  1052.             // set the owning side to null (unless already changed)
  1053.             if ($reminder->getTechnician() === $this) {
  1054.                 $reminder->setTechnician(null);
  1055.             }
  1056.         }
  1058.         return $this;
  1059.     }
  1061.     /**
  1062.      * @return Collection<int, ProductLog>
  1063.      */
  1064.     public function getProductLogs(): Collection
  1065.     {
  1066.         return $this->productLogs;
  1067.     }
  1069.     public function addProductLog(ProductLog $productLog): static
  1070.     {
  1071.         if (!$this->productLogs->contains($productLog)) {
  1072.             $this->productLogs->add($productLog);
  1073.             $productLog->setUser($this);
  1074.         }
  1076.         return $this;
  1077.     }
  1079.     public function removeProductLog(ProductLog $productLog): static
  1080.     {
  1081.         if ($this->productLogs->removeElement($productLog)) {
  1082.             // set the owning side to null (unless already changed)
  1083.             if ($productLog->getUser() === $this) {
  1084.                 $productLog->setUser(null);
  1085.             }
  1086.         }
  1088.         return $this;
  1089.     }
  1091.     /**
  1092.      * @return Collection<int, Supplier>
  1093.      */
  1094.     public function getAutoAssignSuppliers(): Collection
  1095.     {
  1096.         return $this->autoAssignSuppliers;
  1097.     }
  1099.     public function addAutoAssignSupplier(Supplier $autoAssignSupplier): static
  1100.     {
  1101.         if (!$this->autoAssignSuppliers->contains($autoAssignSupplier)) {
  1102.             $this->autoAssignSuppliers->add($autoAssignSupplier);
  1103.         }
  1105.         return $this;
  1106.     }
  1108.     public function removeAutoAssignSupplier(Supplier $autoAssignSupplier): static
  1109.     {
  1110.         $this->autoAssignSuppliers->removeElement($autoAssignSupplier);
  1112.         return $this;
  1113.     }
  1115. }