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 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.     }
  195.     
  196.     /**
  197.      * @ORM\Column(name="id", type="bigint")
  198.      * @ORM\Id
  199.      * @ORM\GeneratedValue(strategy="AUTO")
  200.      */
  201.     protected $id;
  202.     
  203.     /**
  204.      * @ORM\Column(name="email", type="string", length=191, unique=true)
  205.      */
  206.     protected $email;
  207.     
  208.     /**
  209.      * @ORM\Column(name="password", type="string", length=191, nullable=true)
  210.      */
  211.     protected $password;
  212.     
  213.     /**
  214.      * @ORM\Column(name="role", type="string", length=191)
  215.      */
  216.     protected $role = "ROLE_USER";
  217.     
  218.     /**
  219.      * @ORM\Column(name="one_time_code", type="string", length=191, nullable=true)
  220.      */
  221.     protected $oneTimeCode;
  222.     
  223.     /**
  224.      * @ORM\Column(name="expiration_one_time_code", type="datetime", nullable=true)
  225.      */
  226.     protected $expirationOneTimeCode;
  227.         
  228.     /**
  229.      * @ORM\Column(name="is_active", type="boolean")
  230.      */
  231.     protected $active = false;
  233.     /**
  234.      * @ORM\Column(name="is_company_active", type="boolean")
  235.      */
  236.     protected $companyActive = true;
  237.         
  238.     /**
  239.      * @ORM\Column(name="is_admin_active", type="boolean")
  240.      */
  241.     protected $adminActive = true;
  242.     
  243.     /**
  244.      * @ORM\Column(name="exclude_auto_assign", type="boolean")
  245.      */
  246.     protected $excludeAutoAssign = false;
  247.     
  248.     /**
  249.      * @ORM\Column(name="is_economic_visible", type="boolean")
  250.      */
  251.     protected $economicVisible = true;
  252.     
  253.     /**
  254.      * @ORM\Column(name="can_exchange_tickets", type="boolean")
  255.      */
  256.     protected $canExchangeTickets = false;
  257.     
  258.     /**
  259.      * @ORM\Column(name="is_assign_email_active", type="boolean")
  260.      */
  261.     protected $assignEmailActive = true;
  262.     
  263.     // OneToOne
  264.         /**
  265.         * @ORM\OneToOne(targetEntity="App\Entity\Slave\UserProfile", mappedBy="user")
  266.         */
  267.         private $profile;
  268.     //
  270.     // ManyToOne
  271.         /**
  272.          * @ORM\ManyToOne(targetEntity="App\Entity\Slave\AccountType", inversedBy="users")
  273.          * @ORM\JoinColumn(name="account_type_id", referencedColumnName="id")
  274.          */
  275.         private $accountType;
  276.     //
  278.     // OneToMany
  279.         /**
  280.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserDocument", mappedBy="user")
  281.          */
  282.         private $documents;
  283.         
  284.         /**
  285.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="user")
  286.          */
  287.         private $holidays;
  288.         
  289.         /**
  290.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\UserHoliday", mappedBy="substitute")
  291.          */
  292.         private $substitutions;
  294.         /**
  295.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserWarehouse", mappedBy="user")
  296.          */
  297.         private $warehouses;
  299.         /**
  300.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TechnicianArea", mappedBy="user")
  301.          */
  302.         private $technicianAreas;
  303.         
  304.         /**
  305.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\JoinTableUserSupplier", mappedBy="user")
  306.          */
  307.         private $suppliers;
  308.         
  309.         /**
  310.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransferLog", mappedBy="user")
  311.          */
  312.         private $transferLogs;
  314.         /**
  315.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userFrom")
  316.          */
  317.         private $transfersUserFrom;
  319.         /**
  320.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductTransfer", mappedBy="userTo")
  321.          */
  322.         private $transfersUserTo;
  324.         /**
  325.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Ticket", mappedBy="technician")
  326.          */
  327.         private $tickets;
  329.         /**
  330.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="technician")
  331.          */
  332.         private $interventions;
  333.         
  334.         /**
  335.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\Intervention", mappedBy="operator")
  336.          */
  337.         private $operatorInterventions;
  339.         /**
  340.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductRequest", mappedBy="technician")
  341.          */
  342.         private $productRequests;        
  344.         /**
  345.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\TicketReminder", mappedBy="technician")
  346.          */
  347.         private $reminders;
  348.         
  349.         /**
  350.          * @ORM\OneToMany(targetEntity="App\Entity\Slave\ProductLog", mappedBy="user")
  351.          */
  352.         private $productLogs;
  353.     //
  355.     // ManyToMany
  356.         /**
  357.          * @ORM\ManyToMany(targetEntity="App\Entity\Slave\Supplier", inversedBy="autoAssignUsers")
  358.          * @ORM\JoinTable(name="eposm_s_join_table_user_supplier_auto_assign")
  359.          */
  360.         private $autoAssignSuppliers;
  362.         public function __construct()
  363.         {
  364.             $this->documents = new ArrayCollection();
  365.             $this->holidays = new ArrayCollection();
  366.             $this->substitutions = new ArrayCollection();
  367.             $this->warehouses = new ArrayCollection();
  368.             $this->technicianAreas = new ArrayCollection();
  369.             $this->suppliers = new ArrayCollection();
  370.             $this->transferLogs = new ArrayCollection();
  371.             $this->transfersUserFrom = new ArrayCollection();
  372.             $this->transfersUserTo = new ArrayCollection();
  373.             $this->tickets = new ArrayCollection();
  374.             $this->interventions = new ArrayCollection();
  375.             $this->productRequests = new ArrayCollection();
  376.             $this->operatorInterventions = new ArrayCollection();
  377.             $this->autoAssignSuppliers = new ArrayCollection();
  378.             $this->reminders = new ArrayCollection();
  379.             $this->productLogs = new ArrayCollection();
  380.         }
  381.     //
  383.     /**
  384.      * @inheritdoc
  385.      */
  386.     public function getRoles(): array
  387.     {
  388.         switch($this->role){
  389.             case 'ROLE_USER': return array('ROLE_USER');
  390.         };
  391.     }
  393.     public function getSalt(): ?string
  394.     {
  395.         return null;
  396.     }
  398.     /**
  399.      * @see UserInterface
  400.      */
  401.     public function eraseCredentials()
  402.     {
  403.     }
  404.     
  405.     public function getUserIdentifier(): string
  406.     {
  407.         return (string) $this->email;
  408.     }
  410.     public function getUsername(): string
  411.     {
  412.         return (string) $this->email;
  413.     }
  415.     public function getPassword(): ?string
  416.     {
  417.         return $this->password;
  418.     }
  420.     public function setPassword(?string $password): static
  421.     {
  422.         $this->password = $password;
  424.         return $this;
  425.     }
  427.     public function getId(): ?string
  428.     {
  429.         return $this->id;
  430.     }
  432.     public function getEmail(): ?string
  433.     {
  434.         return $this->email;
  435.     }
  437.     public function setEmail(string $email): static
  438.     {
  439.         $this->email = $email;
  441.         return $this;
  442.     }
  444.     public function getRole(): ?string
  445.     {
  446.         return $this->role;
  447.     }
  449.     public function setRole(string $role): static
  450.     {
  451.         $this->role = $role;
  453.         return $this;
  454.     }
  456.     public function getOneTimeCode(): ?string
  457.     {
  458.         return $this->oneTimeCode;
  459.     }
  461.     public function setOneTimeCode(?string $oneTimeCode): static
  462.     {
  463.         $this->oneTimeCode = $oneTimeCode;
  465.         return $this;
  466.     }
  468.     public function getExpirationOneTimeCode(): ?\DateTimeInterface
  469.     {
  470.         return $this->expirationOneTimeCode;
  471.     }
  473.     public function setExpirationOneTimeCode(?\DateTimeInterface $expirationOneTimeCode): static
  474.     {
  475.         $this->expirationOneTimeCode = $expirationOneTimeCode;
  477.         return $this;
  478.     }
  480.     public function isActive(): ?bool
  481.     {
  482.         return $this->active;
  483.     }
  485.     public function setActive(bool $active): static
  486.     {
  487.         $this->active = $active;
  489.         return $this;
  490.     }
  492.     public function isCompanyActive(): ?bool
  493.     {
  494.         return $this->companyActive;
  495.     }
  497.     public function setCompanyActive(bool $companyActive): static
  498.     {
  499.         $this->companyActive = $companyActive;
  501.         return $this;
  502.     }
  504.     public function isAdminActive(): ?bool
  505.     {
  506.         return $this->adminActive;
  507.     }
  509.     public function setAdminActive(bool $adminActive): static
  510.     {
  511.         $this->adminActive = $adminActive;
  513.         return $this;
  514.     }
  516.     public function isExcludeAutoAssign(): ?bool
  517.     {
  518.         return $this->excludeAutoAssign;
  519.     }
  521.     public function setExcludeAutoAssign(bool $excludeAutoAssign): static
  522.     {
  523.         $this->excludeAutoAssign = $excludeAutoAssign;
  525.         return $this;
  526.     }
  528.     public function isEconomicVisible(): ?bool
  529.     {
  530.         return $this->economicVisible;
  531.     }
  533.     public function setEconomicVisible(bool $economicVisible): static
  534.     {
  535.         $this->economicVisible = $economicVisible;
  537.         return $this;
  538.     }
  540.     public function isCanExchangeTickets(): ?bool
  541.     {
  542.         return $this->canExchangeTickets;
  543.     }
  545.     public function setCanExchangeTickets(bool $canExchangeTickets): static
  546.     {
  547.         $this->canExchangeTickets = $canExchangeTickets;
  549.         return $this;
  550.     }
  552.     public function getProfile(): ?UserProfile
  553.     {
  554.         return $this->profile;
  555.     }
  557.     public function setProfile(?UserProfile $profile): static
  558.     {
  559.         // unset the owning side of the relation if necessary
  560.         if ($profile === null && $this->profile !== null) {
  561.             $this->profile->setUser(null);
  562.         }
  564.         // set the owning side of the relation if necessary
  565.         if ($profile !== null && $profile->getUser() !== $this) {
  566.             $profile->setUser($this);
  567.         }
  569.         $this->profile = $profile;
  571.         return $this;
  572.     }
  574.     public function getAccountType(): ?AccountType
  575.     {
  576.         return $this->accountType;
  577.     }
  579.     public function setAccountType(?AccountType $accountType): static
  580.     {
  581.         $this->accountType = $accountType;
  583.         return $this;
  584.     }
  586.     /**
  587.      * @return Collection<int, UserDocument>
  588.      */
  589.     public function getDocuments(): Collection
  590.     {
  591.         return $this->documents;
  592.     }
  594.     public function addDocument(UserDocument $document): static
  595.     {
  596.         if (!$this->documents->contains($document)) {
  597.             $this->documents->add($document);
  598.             $document->setUser($this);
  599.         }
  601.         return $this;
  602.     }
  604.     public function removeDocument(UserDocument $document): static
  605.     {
  606.         if ($this->documents->removeElement($document)) {
  607.             // set the owning side to null (unless already changed)
  608.             if ($document->getUser() === $this) {
  609.                 $document->setUser(null);
  610.             }
  611.         }
  613.         return $this;
  614.     }
  616.     /**
  617.      * @return Collection<int, UserHoliday>
  618.      */
  619.     public function getHolidays(): Collection
  620.     {
  621.         return $this->holidays;
  622.     }
  624.     public function addHoliday(UserHoliday $holiday): static
  625.     {
  626.         if (!$this->holidays->contains($holiday)) {
  627.             $this->holidays->add($holiday);
  628.             $holiday->setUser($this);
  629.         }
  631.         return $this;
  632.     }
  634.     public function removeHoliday(UserHoliday $holiday): static
  635.     {
  636.         if ($this->holidays->removeElement($holiday)) {
  637.             // set the owning side to null (unless already changed)
  638.             if ($holiday->getUser() === $this) {
  639.                 $holiday->setUser(null);
  640.             }
  641.         }
  643.         return $this;
  644.     }
  646.     /**
  647.      * @return Collection<int, UserHoliday>
  648.      */
  649.     public function getSubstitutions(): Collection
  650.     {
  651.         return $this->substitutions;
  652.     }
  654.     public function addSubstitution(UserHoliday $substitution): static
  655.     {
  656.         if (!$this->substitutions->contains($substitution)) {
  657.             $this->substitutions->add($substitution);
  658.             $substitution->setSubstitute($this);
  659.         }
  661.         return $this;
  662.     }
  664.     public function removeSubstitution(UserHoliday $substitution): static
  665.     {
  666.         if ($this->substitutions->removeElement($substitution)) {
  667.             // set the owning side to null (unless already changed)
  668.             if ($substitution->getSubstitute() === $this) {
  669.                 $substitution->setSubstitute(null);
  670.             }
  671.         }
  673.         return $this;
  674.     }
  676.     /**
  677.      * @return Collection<int, JoinTableUserWarehouse>
  678.      */
  679.     public function getWarehouses(): Collection
  680.     {
  681.         return $this->warehouses;
  682.     }
  684.     public function addWarehouse(JoinTableUserWarehouse $warehouse): static
  685.     {
  686.         if (!$this->warehouses->contains($warehouse)) {
  687.             $this->warehouses->add($warehouse);
  688.             $warehouse->setUser($this);
  689.         }
  691.         return $this;
  692.     }
  694.     public function removeWarehouse(JoinTableUserWarehouse $warehouse): static
  695.     {
  696.         if ($this->warehouses->removeElement($warehouse)) {
  697.             // set the owning side to null (unless already changed)
  698.             if ($warehouse->getUser() === $this) {
  699.                 $warehouse->setUser(null);
  700.             }
  701.         }
  703.         return $this;
  704.     }
  706.     /**
  707.      * @return Collection<int, TechnicianArea>
  708.      */
  709.     public function getTechnicianAreas(): Collection
  710.     {
  711.         return $this->technicianAreas;
  712.     }
  714.     public function addTechnicianArea(TechnicianArea $technicianArea): static
  715.     {
  716.         if (!$this->technicianAreas->contains($technicianArea)) {
  717.             $this->technicianAreas->add($technicianArea);
  718.             $technicianArea->setUser($this);
  719.         }
  721.         return $this;
  722.     }
  724.     public function removeTechnicianArea(TechnicianArea $technicianArea): static
  725.     {
  726.         if ($this->technicianAreas->removeElement($technicianArea)) {
  727.             // set the owning side to null (unless already changed)
  728.             if ($technicianArea->getUser() === $this) {
  729.                 $technicianArea->setUser(null);
  730.             }
  731.         }
  733.         return $this;
  734.     }
  736.     /**
  737.      * @return Collection<int, JoinTableUserSupplier>
  738.      */
  739.     public function getSuppliers(): Collection
  740.     {
  741.         return $this->suppliers;
  742.     }
  744.     public function addSupplier(JoinTableUserSupplier $supplier): static
  745.     {
  746.         if (!$this->suppliers->contains($supplier)) {
  747.             $this->suppliers->add($supplier);
  748.             $supplier->setUser($this);
  749.         }
  751.         return $this;
  752.     }
  754.     public function removeSupplier(JoinTableUserSupplier $supplier): static
  755.     {
  756.         if ($this->suppliers->removeElement($supplier)) {
  757.             // set the owning side to null (unless already changed)
  758.             if ($supplier->getUser() === $this) {
  759.                 $supplier->setUser(null);
  760.             }
  761.         }
  763.         return $this;
  764.     }
  766.     /**
  767.      * @return Collection<int, ProductTransferLog>
  768.      */
  769.     public function getTransferLogs(): Collection
  770.     {
  771.         return $this->transferLogs;
  772.     }
  774.     public function addTransferLog(ProductTransferLog $transferLog): static
  775.     {
  776.         if (!$this->transferLogs->contains($transferLog)) {
  777.             $this->transferLogs->add($transferLog);
  778.             $transferLog->setUser($this);
  779.         }
  781.         return $this;
  782.     }
  784.     public function removeTransferLog(ProductTransferLog $transferLog): static
  785.     {
  786.         if ($this->transferLogs->removeElement($transferLog)) {
  787.             // set the owning side to null (unless already changed)
  788.             if ($transferLog->getUser() === $this) {
  789.                 $transferLog->setUser(null);
  790.             }
  791.         }
  793.         return $this;
  794.     }
  796.     /**
  797.      * @return Collection<int, ProductTransfer>
  798.      */
  799.     public function getTransfersUserFrom(): Collection
  800.     {
  801.         return $this->transfersUserFrom;
  802.     }
  804.     public function addTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  805.     {
  806.         if (!$this->transfersUserFrom->contains($transfersUserFrom)) {
  807.             $this->transfersUserFrom->add($transfersUserFrom);
  808.             $transfersUserFrom->setUserFrom($this);
  809.         }
  811.         return $this;
  812.     }
  814.     public function removeTransfersUserFrom(ProductTransfer $transfersUserFrom): static
  815.     {
  816.         if ($this->transfersUserFrom->removeElement($transfersUserFrom)) {
  817.             // set the owning side to null (unless already changed)
  818.             if ($transfersUserFrom->getUserFrom() === $this) {
  819.                 $transfersUserFrom->setUserFrom(null);
  820.             }
  821.         }
  823.         return $this;
  824.     }
  826.     /**
  827.      * @return Collection<int, ProductTransfer>
  828.      */
  829.     public function getTransfersUserTo(): Collection
  830.     {
  831.         return $this->transfersUserTo;
  832.     }
  834.     public function addTransfersUserTo(ProductTransfer $transfersUserTo): static
  835.     {
  836.         if (!$this->transfersUserTo->contains($transfersUserTo)) {
  837.             $this->transfersUserTo->add($transfersUserTo);
  838.             $transfersUserTo->setUserTo($this);
  839.         }
  841.         return $this;
  842.     }
  844.     public function removeTransfersUserTo(ProductTransfer $transfersUserTo): static
  845.     {
  846.         if ($this->transfersUserTo->removeElement($transfersUserTo)) {
  847.             // set the owning side to null (unless already changed)
  848.             if ($transfersUserTo->getUserTo() === $this) {
  849.                 $transfersUserTo->setUserTo(null);
  850.             }
  851.         }
  853.         return $this;
  854.     }
  856.     /**
  857.      * @return Collection<int, Ticket>
  858.      */
  859.     public function getTickets(): Collection
  860.     {
  861.         return $this->tickets;
  862.     }
  864.     public function addTicket(Ticket $ticket): static
  865.     {
  866.         if (!$this->tickets->contains($ticket)) {
  867.             $this->tickets->add($ticket);
  868.             $ticket->setTechnician($this);
  869.         }
  871.         return $this;
  872.     }
  874.     public function removeTicket(Ticket $ticket): static
  875.     {
  876.         if ($this->tickets->removeElement($ticket)) {
  877.             // set the owning side to null (unless already changed)
  878.             if ($ticket->getTechnician() === $this) {
  879.                 $ticket->setTechnician(null);
  880.             }
  881.         }
  883.         return $this;
  884.     }
  886.     /**
  887.      * @return Collection<int, Intervention>
  888.      */
  889.     public function getInterventions(): Collection
  890.     {
  891.         return $this->interventions;
  892.     }
  894.     public function addIntervention(Intervention $intervention): static
  895.     {
  896.         if (!$this->interventions->contains($intervention)) {
  897.             $this->interventions->add($intervention);
  898.             $intervention->setTechnician($this);
  899.         }
  901.         return $this;
  902.     }
  904.     public function removeIntervention(Intervention $intervention): static
  905.     {
  906.         if ($this->interventions->removeElement($intervention)) {
  907.             // set the owning side to null (unless already changed)
  908.             if ($intervention->getTechnician() === $this) {
  909.                 $intervention->setTechnician(null);
  910.             }
  911.         }
  913.         return $this;
  914.     }
  916.     /**
  917.      * @return Collection<int, Intervention>
  918.      */
  919.     public function getOperatorInterventions(): Collection
  920.     {
  921.         return $this->operatorInterventions;
  922.     }
  924.     public function addOperatorIntervention(Intervention $operatorIntervention): static
  925.     {
  926.         if (!$this->operatorInterventions->contains($operatorIntervention)) {
  927.             $this->operatorInterventions->add($operatorIntervention);
  928.             $operatorIntervention->setOperator($this);
  929.         }
  931.         return $this;
  932.     }
  934.     public function removeOperatorIntervention(Intervention $operatorIntervention): static
  935.     {
  936.         if ($this->operatorInterventions->removeElement($operatorIntervention)) {
  937.             // set the owning side to null (unless already changed)
  938.             if ($operatorIntervention->getOperator() === $this) {
  939.                 $operatorIntervention->setOperator(null);
  940.             }
  941.         }
  943.         return $this;
  944.     }
  946.     /**
  947.      * @return Collection<int, ProductRequest>
  948.      */
  949.     public function getProductRequests(): Collection
  950.     {
  951.         return $this->productRequests;
  952.     }
  954.     public function addProductRequest(ProductRequest $productRequest): static
  955.     {
  956.         if (!$this->productRequests->contains($productRequest)) {
  957.             $this->productRequests->add($productRequest);
  958.             $productRequest->setTechnician($this);
  959.         }
  961.         return $this;
  962.     }
  964.     public function removeProductRequest(ProductRequest $productRequest): static
  965.     {
  966.         if ($this->productRequests->removeElement($productRequest)) {
  967.             // set the owning side to null (unless already changed)
  968.             if ($productRequest->getTechnician() === $this) {
  969.                 $productRequest->setTechnician(null);
  970.             }
  971.         }
  973.         return $this;
  974.     }
  976.     /**
  977.      * @return Collection<int, TicketReminder>
  978.      */
  979.     public function getReminders(): Collection
  980.     {
  981.         return $this->reminders;
  982.     }
  984.     public function addReminder(TicketReminder $reminder): static
  985.     {
  986.         if (!$this->reminders->contains($reminder)) {
  987.             $this->reminders->add($reminder);
  988.             $reminder->setTechnician($this);
  989.         }
  991.         return $this;
  992.     }
  994.     public function removeReminder(TicketReminder $reminder): static
  995.     {
  996.         if ($this->reminders->removeElement($reminder)) {
  997.             // set the owning side to null (unless already changed)
  998.             if ($reminder->getTechnician() === $this) {
  999.                 $reminder->setTechnician(null);
  1000.             }
  1001.         }
  1003.         return $this;
  1004.     }
  1006.     /**
  1007.      * @return Collection<int, ProductLog>
  1008.      */
  1009.     public function getProductLogs(): Collection
  1010.     {
  1011.         return $this->productLogs;
  1012.     }
  1014.     public function addProductLog(ProductLog $productLog): static
  1015.     {
  1016.         if (!$this->productLogs->contains($productLog)) {
  1017.             $this->productLogs->add($productLog);
  1018.             $productLog->setUser($this);
  1019.         }
  1021.         return $this;
  1022.     }
  1024.     public function removeProductLog(ProductLog $productLog): static
  1025.     {
  1026.         if ($this->productLogs->removeElement($productLog)) {
  1027.             // set the owning side to null (unless already changed)
  1028.             if ($productLog->getUser() === $this) {
  1029.                 $productLog->setUser(null);
  1030.             }
  1031.         }
  1033.         return $this;
  1034.     }
  1036.     /**
  1037.      * @return Collection<int, Supplier>
  1038.      */
  1039.     public function getAutoAssignSuppliers(): Collection
  1040.     {
  1041.         return $this->autoAssignSuppliers;
  1042.     }
  1044.     public function addAutoAssignSupplier(Supplier $autoAssignSupplier): static
  1045.     {
  1046.         if (!$this->autoAssignSuppliers->contains($autoAssignSupplier)) {
  1047.             $this->autoAssignSuppliers->add($autoAssignSupplier);
  1048.         }
  1050.         return $this;
  1051.     }
  1053.     public function removeAutoAssignSupplier(Supplier $autoAssignSupplier): static
  1054.     {
  1055.         $this->autoAssignSuppliers->removeElement($autoAssignSupplier);
  1057.         return $this;
  1058.     }
  1060.     public function isAssignEmailActive(): ?bool
  1061.     {
  1062.         return $this->assignEmailActive;
  1063.     }
  1065.     public function setAssignEmailActive(bool $assignEmailActive): static
  1066.     {
  1067.         $this->assignEmailActive = $assignEmailActive;
  1069.         return $this;
  1070.     }
  1073. }