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.     }
  22.     
  23.     public function getNameShort(){
  24.         return $this->profile->getSurname().' '.substr($this->profile->getName(), 0, 1).'.'; 
  25.     }
  27.     public function displayNameAndCountTickets(){
  28.         return $this->profile->getSurname().' '.$this->profile->getName().' ('.$this->countTicketsUnderManagement('actual').' / '.$this->countTicketsUnderManagement('suspension').')';
  29.     }
  31.     public function getPermissionType($permissionSlug){
  32.         foreach($this->getAccountType()->getPermissions() as $jt){
  33.             if($jt->getPermission()->getSlug() == $permissionSlug)
  34.                 return $jt->getRw();
  35.         }
  36.         return "";
  37.     }
  39.     public function getPermissionWarehouse($warehouseId){
  40.         foreach($this->getWarehouses() as $jt){
  41.             if($jt->getWarehouse()->getId() == $warehouseId)
  42.                 return $jt->getPermission();
  43.         }
  44.         return "";
  45.     }
  47.     public function getPermissionTransfer($transferId){
  48.         foreach($this->getTransfersUserFrom() as $tf){
  49.             if($this->getPermissionWarehouse($tf->getWarehouseFrom()) == "RW" || $this->getPermissionWarehouse($tf->getWarehouseTo()) == "RW");
  50.                 return true;
  51.         }
  52.         foreach($this->getTransfersUserTo() as $tt){
  53.             if($this->getPermissionWarehouse($tt->getWarehouseFrom()) == "RW" || $this->getPermissionWarehouse($tt->getWarehouseTo()) == "RW");
  54.                 return true;
  55.         }
  56.         return false;
  57.     }
  59.     public function getPermissionTicket($ticketId){
  60.         if($this->getAccountTypology() != 'technician')
  61.             return true;
  62.         else{
  63.             foreach($this->getTickets() as $t){
  64.                 if($t->getId() == $ticketId)
  65.                     return true;
  66.             }
  67.         }
  68.         return false;
  69.     }
  71.     public function getAccountTypology(){
  72.         switch($this->getAccountType()->getCategory()->getSlug()){
  73.             case 'agency':
  74.             case 'administration':
  75.             case 'commercial':
  76.             case 'warehouse':
  77.                 return $this->getAccountType()->getCategory()->getSlug();
  78.                 break;
  79.             case 'tech-internal':
  80.             case 'tech-external':
  81.                 return 'technician';
  82.                 break;
  83.             default: break;
  84.         }
  85.     }
  87.     public function canMakeTicketActions($type, $settingBackOfficeValue){
  88.         switch($type){
  89.             case 'technician':
  90.                 if($this->getAccountTypology() == 'technician' || (($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse') && $settingBackOfficeValue))
  91.                     return true;
  92.                 break;
  93.             case 'only_backoffice':
  94.                 if(($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse') && $settingBackOfficeValue)
  95.                     return true;
  96.                 break;
  97.             case 'agency_warehouse':
  98.                 if($this->getAccountTypology() == 'agency' || $this->getAccountTypology() == 'warehouse')
  99.                     return true;
  100.                 break;
  101.             default: break;
  102.         }
  103.         return false;
  104.     }
  106.     public function getCanDelete(){
  107.         if(sizeof($this->warehouses) > 0) return false;
  108.         if(sizeof($this->technicianAreas) > 0) return false;
  109.         if(sizeof($this->tickets) > 0) return false;
  110.         if(sizeof($this->interventions) > 0) return false;
  111.         return true;
  112.     }
  113.     
  114.     public function isInHolidayAtDate($date){
  115.         $holidays = array();
  116.         foreach($this->getHolidays() as $h){
  117.             if($date->format('Ymd') >= $h->getDateFrom()->format('Ymd') && $date->format('Ymd') <= $h->getDateTo()->format('Ymd'))
  118.                 return true;
  119.         }
  120.         return false;
  121.     }
  123.     public function getActualHoliday(){
  124.         $today = new \Datetime();
  125.         $holidays = array();
  126.         foreach($this->getHolidays() as $h){
  127.             if($today->format('Ymd') >= $h->getDateFrom()->format('Ymd') && $today->format('Ymd') <= $h->getDateTo()->format('Ymd'))
  128.                 return $h;
  129.         }
  130.         return false;
  131.     }
  133.     public function canRead($area){
  134.         foreach($this->getAccountType()->getPermissions() as $jt){
  135.             if($area == $jt->getPermission()->getSlug()){
  136.                 return true;
  137.                 break;
  138.             }
  139.         }
  140.     }
  141.     
  142.     public function canWrite($area){
  143.         foreach($this->getAccountType()->getPermissions() as $jt){
  144.             if($area == $jt->getPermission()->getSlug() && $jt->getRW() == 'RW'){
  145.                 return true;
  146.                 break;
  147.             }
  148.         }
  149.     }
  150.     
  151.     public function canViewTab($tabSlug){
  152.         foreach($this->getAccountType()->getPermissions() as $jt){
  153.             if(str_contains($jt->getPermission()->getSlug(), $tabSlug)){
  154.                 return true;
  155.                 break;
  156.             }
  157.         }
  158.         return false;
  159.     }
  161.     public function countTicketsUnderManagement($type){
  162.         $count = 0;
  163.         foreach($this->getTickets() as $ticket){
  164.             switch($type){
  165.                 case 'actual': if($ticket->getStatus()->getSlug() == 'assigned' || $ticket->getStatus()->getSlug() == 'taken_charge') $count++; break;
  166.                 case 'suspension': if($ticket->getStatus()->getSlug() == 'suspension_request' || $ticket->getStatus()->getSlug() == 'suspended') $count++; break;
  167.                 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;
  168.                 case 'closed': if($ticket->getStatus()->getSlug() == 'closed' || $ticket->getStatus()->getSlug() == 'closed_portal') $count++; break;
  169.                 default: break;
  170.             }
  171.         }
  172.         return $count;
  173.     }
  174.     
  175.     public function mainWarehouse(){
  176.         if(sizeof($this->getWarehouses()) == 1)
  177.             return $this->getWarehouses()[0]->getWarehouse();
  178.         foreach($this->getWarehouses() as $jtuw){
  179.             if($jtuw->isMain())
  180.                 return $jtuw->getWarehouse();
  181.         }
  182.         return null;
  183.     }
  184.     
  185.     /**
  186.      * @ORM\Column(name="id", type="bigint")
  187.      * @ORM\Id
  188.      * @ORM\GeneratedValue(strategy="AUTO")
  189.      */
  190.     protected $id;
  191.     
  192.     /**
  193.      * @ORM\Column(name="email", type="string", length=191, unique=true)
  194.      */
  195.     protected $email;
  196.     
  197.     /**
  198.      * @ORM\Column(name="password", type="string", length=191, nullable=true)
  199.      */
  200.     protected $password;
  201.     
  202.     /**
  203.      * @ORM\Column(name="role", type="string", length=191)
  204.      */
  205.     protected $role = "ROLE_USER";
  206.     
  207.     /**
  208.      * @ORM\Column(name="one_time_code", type="string", length=191, nullable=true)
  209.      */
  210.     protected $oneTimeCode;
  211.     
  212.     /**
  213.      * @ORM\Column(name="expiration_one_time_code", type="datetime", nullable=true)
  214.      */
  215.     protected $expirationOneTimeCode;
  216.         
  217.     /**
  218.      * @ORM\Column(name="is_active", type="boolean")
  219.      */
  220.     protected $active = false;
  222.     /**
  223.      * @ORM\Column(name="is_company_active", type="boolean")
  224.      */
  225.     protected $companyActive = true;
  226.         
  227.     /**
  228.      * @ORM\Column(name="is_admin_active", type="boolean")
  229.      */
  230.     protected $adminActive = true;
  231.     
  232.     /**
  233.      * @ORM\Column(name="exclude_auto_assign", type="boolean")
  234.      */
  235.     protected $excludeAutoAssign = false;
  236.     
  237.     /**
  238.      * @ORM\Column(name="is_economic_visible", type="boolean")
  239.      */
  240.     protected $economicVisible = true;
  241.     
  242.     // OneToOne
  243.         /**
  244.         * @ORM\OneToOne(targetEntity="App\Entity\Slave\UserProfile", mappedBy="user")
  245.         */
  246.         private $profile;
  247.     //
  249.     // ManyToOne
  250.         /**
  251.          * @ORM\ManyToOne(targetEntity="App\Entity\Slave\AccountType", inversedBy="users")
  252.          * @ORM\JoinColumn(name="account_type_id", referencedColumnName="id")
  253.          */
  254.         private $accountType;
  255.     //
  257.     // OneToMany
  258.         /**
  259.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserDocument", mappedBy="user")
  260.          */
  261.         private $documents;
  262.         
  263.         /**
  264.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="user")
  265.          */
  266.         private $holidays;
  267.         
  268.         /**
  269.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="substitute")
  270.          */
  271.         private $substitutions;
  273.         /**
  274.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserWarehouse", mappedBy="user")
  275.          */
  276.         private $warehouses;
  278.         /**
  279.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TechnicianArea", mappedBy="user")
  280.          */
  281.         private $technicianAreas;
  282.         
  283.         /**
  284.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserSupplier", mappedBy="user")
  285.          */
  286.         private $suppliers;
  287.         
  288.         /**
  289.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransferLog", mappedBy="user")
  290.          */
  291.         private $transferLogs;
  293.         /**
  294.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userFrom")
  295.          */
  296.         private $transfersUserFrom;
  298.         /**
  299.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userTo")
  300.          */
  301.         private $transfersUserTo;
  303.         /**
  304.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Ticket", mappedBy="technician")
  305.          */
  306.         private $tickets;
  308.         /**
  309.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="technician")
  310.          */
  311.         private $interventions;
  312.         
  313.         /**
  314.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="operator")
  315.          */
  316.         private $operatorInterventions;
  318.         /**
  319.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductRequest", mappedBy="technician")
  320.          */
  321.         private $productRequests;        
  323.         /**
  324.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TicketReminder", mappedBy="technician")
  325.          */
  326.         private $reminders;
  327.     //
  329.     // ManyToMany
  330.         /**
  331.          * @ORM\ManyToMany(targetEntity="App\Entity\Slave\Supplier", inversedBy="autoAssignUsers")
  332.          * @ORM\JoinTable(name="eposm_s_join_table_user_supplier_auto_assign")
  333.          */
  334.         private $autoAssignSuppliers;
  336.         public function __construct()
  337.         {
  338.             $this->documents = new ArrayCollection();
  339.             $this->holidays = new ArrayCollection();
  340.             $this->substitutions = new ArrayCollection();
  341.             $this->warehouses = new ArrayCollection();
  342.             $this->technicianAreas = new ArrayCollection();
  343.             $this->suppliers = new ArrayCollection();
  344.             $this->transferLogs = new ArrayCollection();
  345.             $this->transfersUserFrom = new ArrayCollection();
  346.             $this->transfersUserTo = new ArrayCollection();
  347.             $this->tickets = new ArrayCollection();
  348.             $this->interventions = new ArrayCollection();
  349.             $this->productRequests = new ArrayCollection();
  350.             $this->operatorInterventions = new ArrayCollection();
  351.             $this->autoAssignSuppliers = new ArrayCollection();
  352.             $this->reminders = new ArrayCollection();
  353.         }
  354.     //
  357.     /**
  358.      * @inheritdoc
  359.      */
  360.     public function getRoles(): array
  361.     {
  362.         switch($this->role){
  363.             case 'ROLE_USER': return array('ROLE_USER');
  364.         };
  365.     }
  367.     public function getSalt(): ?string
  368.     {
  369.         return null;
  370.     }
  372.     /**
  373.      * @see UserInterface
  374.      */
  375.     public function eraseCredentials()
  376.     {
  377.     }
  378.     
  379.     public function getUserIdentifier(): string
  380.     {
  381.         return (string) $this->email;
  382.     }
  384.     public function getUsername(): string
  385.     {
  386.         return (string) $this->email;
  387.     }
  389.     public function getPassword(): ?string
  390.     {
  391.         return $this->password;
  392.     }
  394.     public function setPassword(?string $password): self
  395.     {
  396.         $this->password = $password;
  398.         return $this;
  399.     }
  401.     public function getId(): ?string
  402.     {
  403.         return $this->id;
  404.     }
  406.     public function getEmail(): ?string
  407.     {
  408.         return $this->email;
  409.     }
  411.     public function setEmail(string $email): self
  412.     {
  413.         $this->email = $email;
  415.         return $this;
  416.     }
  418.     public function getRole(): ?string
  419.     {
  420.         return $this->role;
  421.     }
  423.     public function setRole(string $role): self
  424.     {
  425.         $this->role = $role;
  427.         return $this;
  428.     }
  430.     public function getOneTimeCode(): ?string
  431.     {
  432.         return $this->oneTimeCode;
  433.     }
  435.     public function setOneTimeCode(?string $oneTimeCode): static
  436.     {
  437.         $this->oneTimeCode = $oneTimeCode;
  439.         return $this;
  440.     }
  442.     public function getExpirationOneTimeCode(): ?\DateTimeInterface
  443.     {
  444.         return $this->expirationOneTimeCode;
  445.     }
  447.     public function setExpirationOneTimeCode(?\DateTimeInterface $expirationOneTimeCode): static
  448.     {
  449.         $this->expirationOneTimeCode = $expirationOneTimeCode;
  451.         return $this;
  452.     }
  454.     public function isActive(): ?bool
  455.     {
  456.         return $this->active;
  457.     }
  459.     public function setActive(bool $active): static
  460.     {
  461.         $this->active = $active;
  463.         return $this;
  464.     }
  466.     public function isCompanyActive(): ?bool
  467.     {
  468.         return $this->companyActive;
  469.     }
  471.     public function setCompanyActive(bool $companyActive): static
  472.     {
  473.         $this->companyActive = $companyActive;
  475.         return $this;
  476.     }
  478.     public function isAdminActive(): ?bool
  479.     {
  480.         return $this->adminActive;
  481.     }
  483.     public function setAdminActive(bool $adminActive): static
  484.     {
  485.         $this->adminActive = $adminActive;
  487.         return $this;
  488.     }
  490.     public function isExcludeAutoAssign(): ?bool
  491.     {
  492.         return $this->excludeAutoAssign;
  493.     }
  495.     public function setExcludeAutoAssign(bool $excludeAutoAssign): static
  496.     {
  497.         $this->excludeAutoAssign = $excludeAutoAssign;
  499.         return $this;
  500.     }
  502.     public function isEconomicVisible(): ?bool
  503.     {
  504.         return $this->economicVisible;
  505.     }
  507.     public function setEconomicVisible(bool $economicVisible): static
  508.     {
  509.         $this->economicVisible = $economicVisible;
  511.         return $this;
  512.     }
  514.     public function getProfile(): ?UserProfile
  515.     {
  516.         return $this->profile;
  517.     }
  519.     public function setProfile(?UserProfile $profile): static
  520.     {
  521.         // unset the owning side of the relation if necessary
  522.         if ($profile === null && $this->profile !== null) {
  523.             $this->profile->setUser(null);
  524.         }
  526.         // set the owning side of the relation if necessary
  527.         if ($profile !== null && $profile->getUser() !== $this) {
  528.             $profile->setUser($this);
  529.         }
  531.         $this->profile = $profile;
  533.         return $this;
  534.     }
  536.     public function getAccountType(): ?AccountType
  537.     {
  538.         return $this->accountType;
  539.     }
  541.     public function setAccountType(?AccountType $accountType): static
  542.     {
  543.         $this->accountType = $accountType;
  545.         return $this;
  546.     }
  548.     /**
  549.      * @return Collection<int, UserDocument>
  550.      */
  551.     public function getDocuments(): Collection
  552.     {
  553.         return $this->documents;
  554.     }
  556.     public function addDocument(UserDocument $document): static
  557.     {
  558.         if (!$this->documents->contains($document)) {
  559.             $this->documents->add($document);
  560.             $document->setUser($this);
  561.         }
  563.         return $this;
  564.     }
  566.     public function removeDocument(UserDocument $document): static
  567.     {
  568.         if ($this->documents->removeElement($document)) {
  569.             // set the owning side to null (unless already changed)
  570.             if ($document->getUser() === $this) {
  571.                 $document->setUser(null);
  572.             }
  573.         }
  575.         return $this;
  576.     }
  578.     /**
  579.      * @return Collection<int, UserHoliday>
  580.      */
  581.     public function getHolidays(): Collection
  582.     {
  583.         return $this->holidays;
  584.     }
  586.     public function addHoliday(UserHoliday $holiday): static
  587.     {
  588.         if (!$this->holidays->contains($holiday)) {
  589.             $this->holidays->add($holiday);
  590.             $holiday->setUser($this);
  591.         }
  593.         return $this;
  594.     }
  596.     public function removeHoliday(UserHoliday $holiday): static
  597.     {
  598.         if ($this->holidays->removeElement($holiday)) {
  599.             // set the owning side to null (unless already changed)
  600.             if ($holiday->getUser() === $this) {
  601.                 $holiday->setUser(null);
  602.             }
  603.         }
  605.         return $this;
  606.     }
  608.     /**
  609.      * @return Collection<int, UserHoliday>
  610.      */
  611.     public function getSubstitutions(): Collection
  612.     {
  613.         return $this->substitutions;
  614.     }
  616.     public function addSubstitution(UserHoliday $substitution): static
  617.     {
  618.         if (!$this->substitutions->contains($substitution)) {
  619.             $this->substitutions->add($substitution);
  620.             $substitution->setSubstitute($this);
  621.         }
  623.         return $this;
  624.     }
  626.     public function removeSubstitution(UserHoliday $substitution): static
  627.     {
  628.         if ($this->substitutions->removeElement($substitution)) {
  629.             // set the owning side to null (unless already changed)
  630.             if ($substitution->getSubstitute() === $this) {
  631.                 $substitution->setSubstitute(null);
  632.             }
  633.         }
  635.         return $this;
  636.     }
  638.     /**
  639.      * @return Collection<int, JoinTableUserWarehouse>
  640.      */
  641.     public function getWarehouses(): Collection
  642.     {
  643.         return $this->warehouses;
  644.     }
  646.     public function addWarehouse(JoinTableUserWarehouse $warehouse): static
  647.     {
  648.         if (!$this->warehouses->contains($warehouse)) {
  649.             $this->warehouses->add($warehouse);
  650.             $warehouse->setUser($this);
  651.         }
  653.         return $this;
  654.     }
  656.     public function removeWarehouse(JoinTableUserWarehouse $warehouse): static
  657.     {
  658.         if ($this->warehouses->removeElement($warehouse)) {
  659.             // set the owning side to null (unless already changed)
  660.             if ($warehouse->getUser() === $this) {
  661.                 $warehouse->setUser(null);
  662.             }
  663.         }
  665.         return $this;
  666.     }
  668.     /**
  669.      * @return Collection<int, TechnicianArea>
  670.      */
  671.     public function getTechnicianAreas(): Collection
  672.     {
  673.         return $this->technicianAreas;
  674.     }
  676.     public function addTechnicianArea(TechnicianArea $technicianArea): static
  677.     {
  678.         if (!$this->technicianAreas->contains($technicianArea)) {
  679.             $this->technicianAreas->add($technicianArea);
  680.             $technicianArea->setUser($this);
  681.         }
  683.         return $this;
  684.     }
  686.     public function removeTechnicianArea(TechnicianArea $technicianArea): static
  687.     {
  688.         if ($this->technicianAreas->removeElement($technicianArea)) {
  689.             // set the owning side to null (unless already changed)
  690.             if ($technicianArea->getUser() === $this) {
  691.                 $technicianArea->setUser(null);
  692.             }
  693.         }
  695.         return $this;
  696.     }
  698.     /**
  699.      * @return Collection<int, JoinTableUserSupplier>
  700.      */
  701.     public function getSuppliers(): Collection
  702.     {
  703.         return $this->suppliers;
  704.     }
  706.     public function addSupplier(JoinTableUserSupplier $supplier): static
  707.     {
  708.         if (!$this->suppliers->contains($supplier)) {
  709.             $this->suppliers->add($supplier);
  710.             $supplier->setUser($this);
  711.         }
  713.         return $this;
  714.     }
  716.     public function removeSupplier(JoinTableUserSupplier $supplier): static
  717.     {
  718.         if ($this->suppliers->removeElement($supplier)) {
  719.             // set the owning side to null (unless already changed)
  720.             if ($supplier->getUser() === $this) {
  721.                 $supplier->setUser(null);
  722.             }
  723.         }
  725.         return $this;
  726.     }
  728.     /**
  729.      * @return Collection<int, ProductTransferLog>
  730.      */
  731.     public function getTransferLogs(): Collection
  732.     {
  733.         return $this->transferLogs;
  734.     }
  736.     public function addTransferLog(ProductTransferLog $transferLog): static
  737.     {
  738.         if (!$this->transferLogs->contains($transferLog)) {
  739.             $this->transferLogs->add($transferLog);
  740.             $transferLog->setUser($this);
  741.         }
  743.         return $this;
  744.     }
  746.     public function removeTransferLog(ProductTransferLog $transferLog): static
  747.     {
  748.         if ($this->transferLogs->removeElement($transferLog)) {
  749.             // set the owning side to null (unless already changed)
  750.             if ($transferLog->getUser() === $this) {
  751.                 $transferLog->setUser(null);
  752.             }
  753.         }
  755.         return $this;
  756.     }
  758.     /**
  759.      * @return Collection<int, ProductTransfer>
  760.      */
  761.     public function getTransfersUserFrom(): Collection
  762.     {
  763.         return $this->transfersUserFrom;
  764.     }
  766.     public function addTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  767.     {
  768.         if (!$this->transfersUserFrom->contains($transfersUserFrom)) {
  769.             $this->transfersUserFrom->add($transfersUserFrom);
  770.             $transfersUserFrom->setUserFrom($this);
  771.         }
  773.         return $this;
  774.     }
  776.     public function removeTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  777.     {
  778.         if ($this->transfersUserFrom->removeElement($transfersUserFrom)) {
  779.             // set the owning side to null (unless already changed)
  780.             if ($transfersUserFrom->getUserFrom() === $this) {
  781.                 $transfersUserFrom->setUserFrom(null);
  782.             }
  783.         }
  785.         return $this;
  786.     }
  788.     /**
  789.      * @return Collection<int, ProductTransfer>
  790.      */
  791.     public function getTransfersUserTo(): Collection
  792.     {
  793.         return $this->transfersUserTo;
  794.     }
  796.     public function addTransfersUserTo(ProductTransfer $transfersUserTo): static
  797.     {
  798.         if (!$this->transfersUserTo->contains($transfersUserTo)) {
  799.             $this->transfersUserTo->add($transfersUserTo);
  800.             $transfersUserTo->setUserTo($this);
  801.         }
  803.         return $this;
  804.     }
  806.     public function removeTransfersUserTo(ProductTransfer $transfersUserTo): static
  807.     {
  808.         if ($this->transfersUserTo->removeElement($transfersUserTo)) {
  809.             // set the owning side to null (unless already changed)
  810.             if ($transfersUserTo->getUserTo() === $this) {
  811.                 $transfersUserTo->setUserTo(null);
  812.             }
  813.         }
  815.         return $this;
  816.     }
  818.     /**
  819.      * @return Collection<int, Ticket>
  820.      */
  821.     public function getTickets(): Collection
  822.     {
  823.         return $this->tickets;
  824.     }
  826.     public function addTicket(Ticket $ticket): static
  827.     {
  828.         if (!$this->tickets->contains($ticket)) {
  829.             $this->tickets->add($ticket);
  830.             $ticket->setTechnician($this);
  831.         }
  833.         return $this;
  834.     }
  836.     public function removeTicket(Ticket $ticket): static
  837.     {
  838.         if ($this->tickets->removeElement($ticket)) {
  839.             // set the owning side to null (unless already changed)
  840.             if ($ticket->getTechnician() === $this) {
  841.                 $ticket->setTechnician(null);
  842.             }
  843.         }
  845.         return $this;
  846.     }
  848.     /**
  849.      * @return Collection<int, Intervention>
  850.      */
  851.     public function getInterventions(): Collection
  852.     {
  853.         return $this->interventions;
  854.     }
  856.     public function addIntervention(Intervention $intervention): static
  857.     {
  858.         if (!$this->interventions->contains($intervention)) {
  859.             $this->interventions->add($intervention);
  860.             $intervention->setTechnician($this);
  861.         }
  863.         return $this;
  864.     }
  866.     public function removeIntervention(Intervention $intervention): static
  867.     {
  868.         if ($this->interventions->removeElement($intervention)) {
  869.             // set the owning side to null (unless already changed)
  870.             if ($intervention->getTechnician() === $this) {
  871.                 $intervention->setTechnician(null);
  872.             }
  873.         }
  875.         return $this;
  876.     }
  878.     /**
  879.      * @return Collection<int, ProductRequest>
  880.      */
  881.     public function getProductRequests(): Collection
  882.     {
  883.         return $this->productRequests;
  884.     }
  886.     public function addProductRequest(ProductRequest $productRequest): static
  887.     {
  888.         if (!$this->productRequests->contains($productRequest)) {
  889.             $this->productRequests->add($productRequest);
  890.             $productRequest->setTechnician($this);
  891.         }
  893.         return $this;
  894.     }
  896.     public function removeProductRequest(ProductRequest $productRequest): static
  897.     {
  898.         if ($this->productRequests->removeElement($productRequest)) {
  899.             // set the owning side to null (unless already changed)
  900.             if ($productRequest->getTechnician() === $this) {
  901.                 $productRequest->setTechnician(null);
  902.             }
  903.         }
  905.         return $this;
  906.     }
  908.     /**
  909.      * @return Collection<int, Intervention>
  910.      */
  911.     public function getOperatorInterventions(): Collection
  912.     {
  913.         return $this->operatorInterventions;
  914.     }
  916.     public function addOperatorIntervention(Intervention $operatorIntervention): static
  917.     {
  918.         if (!$this->operatorInterventions->contains($operatorIntervention)) {
  919.             $this->operatorInterventions->add($operatorIntervention);
  920.             $operatorIntervention->setOperator($this);
  921.         }
  923.         return $this;
  924.     }
  926.     public function removeOperatorIntervention(Intervention $operatorIntervention): static
  927.     {
  928.         if ($this->operatorInterventions->removeElement($operatorIntervention)) {
  929.             // set the owning side to null (unless already changed)
  930.             if ($operatorIntervention->getOperator() === $this) {
  931.                 $operatorIntervention->setOperator(null);
  932.             }
  933.         }
  935.         return $this;
  936.     }
  938.     /**
  939.      * @return Collection<int, Supplier>
  940.      */
  941.     public function getAutoAssignSuppliers(): Collection
  942.     {
  943.         return $this->autoAssignSuppliers;
  944.     }
  946.     public function addAutoAssignSupplier(Supplier $autoAssignSupplier): static
  947.     {
  948.         if (!$this->autoAssignSuppliers->contains($autoAssignSupplier)) {
  949.             $this->autoAssignSuppliers->add($autoAssignSupplier);
  950.         }
  952.         return $this;
  953.     }
  955.     public function removeAutoAssignSupplier(Supplier $autoAssignSupplier): static
  956.     {
  957.         $this->autoAssignSuppliers->removeElement($autoAssignSupplier);
  959.         return $this;
  960.     }
  962.     /**
  963.      * @return Collection<int, TicketReminder>
  964.      */
  965.     public function getReminders(): Collection
  966.     {
  967.         return $this->reminders;
  968.     }
  970.     public function addReminder(TicketReminder $reminder): static
  971.     {
  972.         if (!$this->reminders->contains($reminder)) {
  973.             $this->reminders->add($reminder);
  974.             $reminder->setTechnician($this);
  975.         }
  977.         return $this;
  978.     }
  980.     public function removeReminder(TicketReminder $reminder): static
  981.     {
  982.         if ($this->reminders->removeElement($reminder)) {
  983.             // set the owning side to null (unless already changed)
  984.             if ($reminder->getTechnician() === $this) {
  985.                 $reminder->setTechnician(null);
  986.             }
  987.         }
  989.         return $this;
  990.     }
  992. }