src/Entity/User.php line 17

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\Common\Collections\ArrayCollection;
  7. use Doctrine\Common\Collections\Collection;
  8. use Doctrine\Common\Collections\Criteria;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  12. use Symfony\Component\Serializer\Annotation\Groups;
  14. /**
  15.  * @ORM\Entity(repositoryClass=UserRepository::class)
  16.  */
  17. class User implements UserInterface, PasswordAuthenticatedUserInterface
  18. {
  19.     /**
  20.      * @ORM\Id
  21.      * @ORM\GeneratedValue
  22.      * @ORM\Column(type="integer")
  23.      * @Groups({
  24.      *     "user.core",
  25.      *     "user:core",
  26.      *     "user@core"
  27.      * })
  28.      */
  29.     private $id;
  31.     /**
  32.      * @ORM\Column(type="string", length=180, unique=true)
  33.      * @Groups({
  34.      *      "user.core",
  35.      *      "user:core",
  36.      *      "user@core"
  37.      *  })
  38.      */
  39.     private $email;
  41.     /**
  42.      * @ORM\Column(type="json")
  43.      * @Groups({
  44.      *      "user.core",
  45.      *      "user:core",
  46.      *      "user@core"
  47.      *  })
  48.      */
  49.     private $roles = [];
  51.     /**
  52.      * @var string The hashed password
  53.      * @ORM\Column(type="string")
  54.      */
  55.     private $password;
  57.     /**
  58.      * @var string The hashed password
  59.      * @ORM\Column(type="string", length=64, nullable=true )
  60.      * Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
  61.      * @Groups({
  62.      *      "user.core",
  63.      *      "user:core",
  64.      *      "user@core",
  65.      *      "worker.manage.base.timesheet.payments"
  66.      *  })
  67.      */
  69.     private $name;
  71.     /**
  72.      * @var string The hashed password
  73.      * @ORM\Column(type="string", length=64, nullable=true )
  74.      * Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
  75.      * @Groups({
  76.      *       "user.core",
  77.      *       "user:core",
  78.      *       "user@core",
  79.      *       "worker.manage.base.timesheet.payments"
  80.      *   })
  81.      */
  83.     private $surname;
  85.     /**
  86.      * Private Prop no column based
  87.      * @var string The hashed password
  88.      * @Groups({
  89.      *       "user.core",
  90.      *       "user:core",
  91.      *       "user@core"
  92.      *   })
  93.      */
  95.     private $full_name;
  97.     public function getFullName(): string
  98.     {
  99.         return "{$this->getName()} {$this->getSurname()}";
  100.     }
  102.     /**
  103.      * @ORM\OneToMany(targetEntity=ProjectAddendumCosts::class, mappedBy="added_by")
  104.      */
  105.     private $projectAddendumCosts;
  106.     
  108.     /**
  109.      * @deprecated use user_rights
  110.      * @ORM\ManyToMany(targetEntity=AccessRoles::class, inversedBy="users")
  111.      * @Groups({"user.manage", "user.accessed.roles"})
  112.      */
  113.     private $user_accessed_roles;
  115.     /**
  116.      * @ORM\OneToMany(targetEntity=WorkerTimesheetPayments::class, mappedBy="payer")
  117.      */
  118.     private $workerTimesheetPayments;
  120.     /**
  121.      * @ORM\OneToMany(targetEntity=ProjectOrderFeedback::class, mappedBy="user")
  122.      */
  123.     private $projectOrderFeedback;
  125.     /**
  126.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="author")
  127.      */
  128.     private $projectOrders;
  130.     /**
  131.      * @ORM\Column(type="boolean", nullable=true)
  132.      * @Groups({"user.core", "user:core", "user@core"})
  133.      */
  134.     private $login_refused;
  136.     /**
  137.      * @ORM\Column(type="string", length=255, nullable=true)
  138.      * @Groups({"user.core", "user:core", "user@core"})
  139.      */
  140.     private $login_refused_message;
  142.     /**
  143.      * @ORM\Column(type="datetime", nullable=true)
  144.      */
  145.     private $invisible_since;
  147.     /**
  148.      * @ORM\OneToMany(targetEntity=UserRights::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
  149.      * @Groups({"user.rights"})
  150.      */
  151.     private $user_rights;
  153.     /**
  154.      * @ORM\OneToMany(targetEntity=Inventory::class, mappedBy="involved_by")
  155.      */
  156.     private $inventories;
  158.     /**
  159.      * @ORM\OneToMany(targetEntity=SupplierOrders::class, mappedBy="order_by")
  160.      */
  161.     private $supplierOrders;
  163.     /**
  164.      * @ORM\OneToMany(targetEntity=UserScopedItem::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
  165.      * @Groups({"user.scoped.items"})
  166.      */
  167.     private $user_scoped_items;
  169.     /**
  170.      * @deprecated use workerActivity instead
  171.      * @ORM\OneToOne(targetEntity=Worker::class, mappedBy="user", cascade={"persist", "remove"})
  172.      * @Groups({"user.worker"})
  173.      */
  174.     private $worker;
  176.     /**
  177.      * @ORM\OneToMany(targetEntity=UserCalculationPermission::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
  178.      * @Groups({"user.calculate.permissions"})
  179.      */
  180.     private $user_calculation_permissions;
  182.     /**
  183.      * @ORM\Column(type="datetime_immutable", nullable=true)
  184.      * @Groups({"user.core", "user:core", "user@core"})
  185.      */
  186.     private $is_password_updated_at;
  188.     /**
  189.      * @ORM\ManyToOne(targetEntity=UserPositions::class, inversedBy="users")
  190.      * @Groups({"user.position"})
  191.      */
  192.     private $user_position;
  194.     /**
  195.      * @ORM\Column(type="integer", nullable=true)
  196.      * @Groups({"user.core", "user:core", "user@core"})
  197.      */
  198.     private $idle_timer_timeout;
  200.     /**
  201.      * @ORM\OneToMany(targetEntity=WorkerActivities::class, mappedBy="user")
  202.      * @Groups({
  203.      *          "user.worker.activities",
  204.      *          "user@worker_activities"
  205.      *     })"})
  206.      */
  207.     private $worker_activities;
  209.     /**
  210.      * NO COLUMN BASED
  211.      * @Groups({
  212.      *     "user.as.worker.latest.activity"
  213.      * })
  214.     }
  215.      */
  216.     private $user_as_worker_latest_activity;
  218.     /**
  219.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="requester")
  220.      */
  221.     private $purchase_requests_requester;
  223.     /**
  224.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="approver")
  225.      */
  226.     private $purchase_requests_approver;
  228.     /**
  229.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositionHistoryRead::class, mappedBy="user")
  230.      */
  231.     private $purchase_request_position_history_reads;
  233.     /**
  234.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistoryRead::class, mappedBy="user")
  235.      */
  236.     private $purchase_request_history_reads;
  238.     /**
  239.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistories::class, mappedBy="owner")
  240.      */
  241.     private $purchaseRequestHistories;
  243.     /**
  244.      * @ORM\OneToMany(targetEntity=PurchaseRequestUserFavorites::class, mappedBy="user")
  245.      */
  246.     private $purchaseRequestUserFavorites;
  248.     /**
  249.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="approver")
  250.      */
  251.     private $purchase_request_positions_approver;
  253.     /**
  254.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="rejecter")
  255.      */
  256.     private $purchase_request_positions_rejecter;
  258.     /**
  259.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="rejecter")
  260.      */
  261.     private $purchase_request_rejecter;
  263.     /**
  264.      * @ORM\OneToMany(targetEntity=Warehouses::class, mappedBy="creator")
  265.      */
  266.     private $warehouses;
  268.     /**
  269.      * @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issued_by")
  270.      */
  271.     private $stock_out_issues;
  273.     /**
  274.      * @ORM\OneToMany(targetEntity=StockIssuePositions::class, mappedBy="deliverer")
  275.      */
  276.     private $delivered_stock_issue_positions;
  278.     /**
  279.      * @return mixed
  280.      */
  281.     public function getUserAsWorkerLatestActivity()
  282.     {
  284.         $criteria = Criteria::create();
  285.         // $criteria->where(Criteria::expr()->isNull('exit_at'));
  286.         $criteria->orderBy(['id' => Criteria::ASC]);// ->setMaxResults(1);
  288.         /**@var WorkerActivities $latestActivity*/
  289.         $latestActivity = $this->getWorkerActivities()->matching($criteria)->last();
  290.         #dd($latestActivity);
  292.         $this->latest_activity = $latestActivity ?? null;
  296.         return $this->latest_activity;
  297.     }
  301.     public function __construct()
  302.     {
  303.         $this->projectAddendumCosts = new ArrayCollection();
  304.         $this->user_accessed_roles = new ArrayCollection();
  305.         $this->workerTimesheetPayments = new ArrayCollection();
  306.         $this->projectOrderFeedback = new ArrayCollection();
  307.         $this->projectOrders = new ArrayCollection();
  308.         $this->user_rights = new ArrayCollection();
  309.         $this->inventories = new ArrayCollection();
  310.         $this->supplierOrders = new ArrayCollection();
  311.         $this->user_scoped_items = new ArrayCollection();
  312.         $this->user_calculation_permissions = new ArrayCollection();
  313.         $this->worker_activities = new ArrayCollection();
  314.         $this->purchase_requests_requester = new ArrayCollection();
  315.         $this->purchase_requests_approver = new ArrayCollection();
  316.         $this->purchase_request_position_history_reads = new ArrayCollection();
  317.         $this->purchase_request_history_reads = new ArrayCollection();
  318.         $this->purchaseRequestHistories = new ArrayCollection();
  319.         $this->purchaseRequestUserFavorites = new ArrayCollection();
  320.         $this->purchase_request_positions_approver = new ArrayCollection();
  321.         $this->purchase_request_positions_rejecter = new ArrayCollection();
  322.         $this->purchase_request_rejecter = new ArrayCollection();
  323.         $this->warehouses = new ArrayCollection();
  324.         $this->stock_out_issues = new ArrayCollection();
  325.         $this->delivered_stock_issue_positions = new ArrayCollection();
  326.     }
  328.     public function getId(): ?int
  329.     {
  330.         return $this->id;
  331.     }
  333.     public function getEmail(): ?string
  334.     {
  335.         return $this->email;
  336.     }
  338.     public function setEmail(string $email): self
  339.     {
  340.         $this->email = $email;
  342.         return $this;
  343.     }
  345.     /**
  346.      * A visual identifier that represents this user.
  347.      *
  348.      * @see UserInterface
  349.      */
  350.     public function getUserIdentifier(): string
  351.     {
  352.         return (string) $this->email;
  353.     }
  355.     /**
  356.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  357.      */
  358.     public function getUsername(): string
  359.     {
  360.         return (string) $this->email;
  361.     }
  363.     /**
  364.      * @see UserInterface
  365.      */
  366.     public function getRoles(): array
  367.     {
  368.         $roles = $this->roles;
  369.         // guarantee every user at least has ROLE_USER
  370.         $roles[] = 'ROLE_USER';
  372.         return array_unique($roles);
  373.     }
  375.     public function setRoles(array $roles): self
  376.     {
  377.         $this->roles = $roles;
  379.         return $this;
  380.     }
  382.     /**
  383.      * @see PasswordAuthenticatedUserInterface
  384.      */
  385.     public function getPassword(): string
  386.     {
  387.         return $this->password;
  388.     }
  390.     public function setPassword(string $password): self
  391.     {
  392.         $this->password = $password;
  394.         return $this;
  395.     }
  397.     public function getName(): ?string
  398.     {
  399.         return $this->name;
  400.     }
  402.     public function setName( string $name): self
  403.     {
  404.         $this->name = $name;
  406.         return $this;
  407.     }
  409.     public function getSurname(): ?string
  410.     {
  411.         return $this->surname;
  412.     }
  414.     public function setSurname(string $surname): self
  415.     {
  416.         $this->surname = $surname;
  418.         return $this;
  419.     }
  421.     /**
  422.      * Returning a salt is only needed, if you are not using a modern
  423.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  424.      *
  425.      * @see UserInterface
  426.      */
  427.     public function getSalt(): ?string
  428.     {
  429.         return null;
  430.     }
  432.     /**
  433.      * @see UserInterface
  434.      */
  435.     public function eraseCredentials()
  436.     {
  437.         // If you store any temporary, sensitive data on the user, clear it here
  438.         // $this->plainPassword = null;
  439.     }
  441.     /**
  442.      * @return Collection<int, ProjectAddendumCosts>
  443.      */
  444.     public function getProjectAddendumCosts(): Collection
  445.     {
  446.         return $this->projectAddendumCosts;
  447.     }
  449.     public function addProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  450.     {
  451.         if (!$this->projectAddendumCosts->contains($projectAddendumCost)) {
  452.             $this->projectAddendumCosts[] = $projectAddendumCost;
  453.             $projectAddendumCost->setAddedBy($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  460.     {
  461.         if ($this->projectAddendumCosts->removeElement($projectAddendumCost)) {
  462.             // set the owning side to null (unless already changed)
  463.             if ($projectAddendumCost->getAddedBy() === $this) {
  464.                 $projectAddendumCost->setAddedBy(null);
  465.             }
  466.         }
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection<int, AccessRoles>
  473.      *     @deprecated use user_rights
  474.      */
  475.     public function getUserAccessedRoles(): Collection
  476.     {
  477.         return $this->user_accessed_roles;
  478.     }
  480.     /**
  481.      * @deprecated use user_rights
  482.     */
  483.     public function addUserAccessedRole(AccessRoles $userAccessedRole): self
  484.     {
  485.         if (!$this->user_accessed_roles->contains($userAccessedRole)) {
  486.             $this->user_accessed_roles[] = $userAccessedRole;
  487.         }
  489.         return $this;
  490.     }
  492.     /**
  493.      * @deprecated use user_rights
  494.     */
  495.     public function removeUserAccessedRole(AccessRoles $userAccessedRole): self
  496.     {
  497.         $this->user_accessed_roles->removeElement($userAccessedRole);
  499.         return $this;
  500.     }
  502.     /**
  503.      * @return Collection<int, WorkerTimesheetPayments>
  504.      */
  505.     public function getWorkerTimesheetPayments(): Collection
  506.     {
  507.         return $this->workerTimesheetPayments;
  508.     }
  510.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  511.     {
  512.         if (!$this->workerTimesheetPayments->contains($workerTimesheetPayment)) {
  513.             $this->workerTimesheetPayments[] = $workerTimesheetPayment;
  514.             $workerTimesheetPayment->setPayer($this);
  515.         }
  517.         return $this;
  518.     }
  520.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  521.     {
  522.         if ($this->workerTimesheetPayments->removeElement($workerTimesheetPayment)) {
  523.             // set the owning side to null (unless already changed)
  524.             if ($workerTimesheetPayment->getPayer() === $this) {
  525.                 $workerTimesheetPayment->setPayer(null);
  526.             }
  527.         }
  529.         return $this;
  530.     }
  532.     /**
  533.      * @return Collection<int, ProjectOrderFeedback>
  534.      */
  535.     public function getProjectOrderFeedback(): Collection
  536.     {
  537.         return $this->projectOrderFeedback;
  538.     }
  540.     public function addProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  541.     {
  542.         if (!$this->projectOrderFeedback->contains($projectOrderFeedback)) {
  543.             $this->projectOrderFeedback[] = $projectOrderFeedback;
  544.             $projectOrderFeedback->setUser($this);
  545.         }
  547.         return $this;
  548.     }
  550.     public function removeProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  551.     {
  552.         if ($this->projectOrderFeedback->removeElement($projectOrderFeedback)) {
  553.             // set the owning side to null (unless already changed)
  554.             if ($projectOrderFeedback->getUser() === $this) {
  555.                 $projectOrderFeedback->setUser(null);
  556.             }
  557.         }
  559.         return $this;
  560.     }
  562.     /**
  563.      * @return Collection<int, ProjectOrders>
  564.      */
  565.     public function getProjectOrders(): Collection
  566.     {
  567.         return $this->projectOrders;
  568.     }
  570.     public function addProjectOrder(ProjectOrders $projectOrder): self
  571.     {
  572.         if (!$this->projectOrders->contains($projectOrder)) {
  573.             $this->projectOrders[] = $projectOrder;
  574.             $projectOrder->setAuthor($this);
  575.         }
  577.         return $this;
  578.     }
  580.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  581.     {
  582.         if ($this->projectOrders->removeElement($projectOrder)) {
  583.             // set the owning side to null (unless already changed)
  584.             if ($projectOrder->getAuthor() === $this) {
  585.                 $projectOrder->setAuthor(null);
  586.             }
  587.         }
  589.         return $this;
  590.     }
  592.     public function isLoginRefused(): ?bool
  593.     {
  594.         return $this->login_refused;
  595.     }
  597.     public function setRefusedLogin(?bool $login_refused): self
  598.     {
  599.         $this->login_refused = $login_refused;
  601.         return $this;
  602.     }
  604.     public function getLoginRefusedMessage(): ?string
  605.     {
  606.         return $this->login_refused_message;
  607.     }
  609.     public function setLoginRefusedMessage(?string $login_refused_message): self
  610.     {
  611.         $this->login_refused_message = $login_refused_message;
  613.         return $this;
  614.     }
  616.     public function getInvisibleSince(): ?\DateTimeInterface
  617.     {
  618.         return $this->invisible_since;
  619.     }
  621.     public function setInvisibleSince(?\DateTimeInterface $invisible_since): self
  622.     {
  623.         $this->invisible_since = $invisible_since;
  625.         return $this;
  626.     }
  628.     /**
  629.      * @return Collection<int, UserRights>
  630.      */
  631.     public function getUserRights(): Collection
  632.     {
  633.         return $this->user_rights;
  634.     }
  636.     public function addUserRight(UserRights $userRight): self
  637.     {
  638.         if (!$this->user_rights->contains($userRight)) {
  639.             $this->user_rights[] = $userRight;
  640.             $userRight->setUser($this);
  641.         }
  643.         return $this;
  644.     }
  646.     public function removeUserRight(UserRights $userRight): self
  647.     {
  648.         if ($this->user_rights->removeElement($userRight)) {
  649.             // set the owning side to null (unless already changed)
  650.             if ($userRight->getUser() === $this) {
  651.                 $userRight->setUser(null);
  652.             }
  653.         }
  655.         return $this;
  656.     }
  658.     /**
  659.      * @return Collection<int, Inventory>
  660.      */
  661.     public function getInventories(): Collection
  662.     {
  663.         return $this->inventories;
  664.     }
  666.     public function addInventory(Inventory $inventory): self
  667.     {
  668.         if (!$this->inventories->contains($inventory)) {
  669.             $this->inventories[] = $inventory;
  670.             $inventory->setInvolvedBy($this);
  671.         }
  673.         return $this;
  674.     }
  676.     public function removeInventory(Inventory $inventory): self
  677.     {
  678.         if ($this->inventories->removeElement($inventory)) {
  679.             // set the owning side to null (unless already changed)
  680.             if ($inventory->getInvolvedBy() === $this) {
  681.                 $inventory->setInvolvedBy(null);
  682.             }
  683.         }
  685.         return $this;
  686.     }
  688.     /**
  689.      * @return Collection<int, SupplierOrders>
  690.      */
  691.     public function getSupplierOrders(): Collection
  692.     {
  693.         return $this->supplierOrders;
  694.     }
  696.     public function addSupplierOrder(SupplierOrders $supplierOrder): self
  697.     {
  698.         if (!$this->supplierOrders->contains($supplierOrder)) {
  699.             $this->supplierOrders[] = $supplierOrder;
  700.             $supplierOrder->setOrderBy($this);
  701.         }
  703.         return $this;
  704.     }
  706.     public function removeSupplierOrder(SupplierOrders $supplierOrder): self
  707.     {
  708.         if ($this->supplierOrders->removeElement($supplierOrder)) {
  709.             // set the owning side to null (unless already changed)
  710.             if ($supplierOrder->getOrderBy() === $this) {
  711.                 $supplierOrder->setOrderBy(null);
  712.             }
  713.         }
  715.         return $this;
  716.     }
  718.     /**
  719.      * @return Collection<int, UserScopedItem>
  720.      */
  721.     public function getUserScopedItems(): Collection
  722.     {
  723.         return $this->user_scoped_items;
  724.     }
  726.     public function addUserScopedItems(UserScopedItem $userScopedItem): self
  727.     {
  728.         if (!$this->user_scoped_items->contains($userScopedItem)) {
  729.             $this->user_scoped_items[] = $userScopedItem;
  730.             $userScopedItem->setUser($this);
  731.         }
  733.         return $this;
  734.     }
  736.     public function removeUserScopedItems(UserScopedItem $userScopedItem): self
  737.     {
  738.         if ($this->user_scoped_items->removeElement($userScopedItem)) {
  739.             // set the owning side to null (unless already changed)
  740.             if ($userScopedItem->getUser() === $this) {
  741.                 $userScopedItem->setUser(null);
  742.             }
  743.         }
  745.         return $this;
  746.     }
  748.     public function getWorker(): ?Worker
  749.     {
  750.         return $this->worker;
  751.     }
  753.     public function setWorker(?Worker $worker): self
  754.     {
  755.         // unset the owning side of the relation if necessary
  756.         if ($worker === null && $this->worker !== null) {
  757.             $this->worker->setUser(null);
  758.         }
  760.         // set the owning side of the relation if necessary
  761.         if ($worker !== null && $worker->getUser() !== $this) {
  762.             $worker->setUser($this);
  763.         }
  765.         $this->worker = $worker;
  767.         return $this;
  768.     }
  770.     /**
  771.      * @return Collection<int, UserCalculationPermission>
  772.      */
  773.     public function getUserCalculationPermissions(): Collection
  774.     {
  775.         return $this->user_calculation_permissions;
  776.     }
  778.     public function addUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  779.     {
  780.         if (!$this->user_calculation_permissions->contains($userCalculationPermission)) {
  781.             $this->user_calculation_permissions[] = $userCalculationPermission;
  782.             $userCalculationPermission->setUser($this);
  783.         }
  785.         return $this;
  786.     }
  788.     public function removeUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  789.     {
  790.         if ($this->user_calculation_permissions->removeElement($userCalculationPermission)) {
  791.             // set the owning side to null (unless already changed)
  792.             if ($userCalculationPermission->getUser() === $this) {
  793.                 $userCalculationPermission->setUser(null);
  794.             }
  795.         }
  797.         return $this;
  798.     }
  800.     public function getIsPasswordUpdatedAt(): ?\DateTimeImmutable
  801.     {
  802.         return $this->is_password_updated_at;
  803.     }
  805.     public function setIsPasswordUpdatedAt(?\DateTimeImmutable $is_password_updated_at): self
  806.     {
  807.         $this->is_password_updated_at = $is_password_updated_at;
  809.         return $this;
  810.     }
  812.     public function getUserPosition(): ?UserPositions
  813.     {
  814.         return $this->user_position;
  815.     }
  817.     public function setUserPosition(?UserPositions $user_position): self
  818.     {
  819.         $this->user_position = $user_position;
  821.         return $this;
  822.     }
  824.     public function getIdleTimerTimeout(): ?int
  825.     {
  826.         return $this->idle_timer_timeout;
  827.     }
  829.     public function setIdleTimerTimeout(?int $idle_timer_timeout): self
  830.     {
  831.         $this->idle_timer_timeout = $idle_timer_timeout;
  833.         return $this;
  834.     }
  836.     /**
  837.      * @return Collection<int, WorkerActivities>
  838.      */
  839.     public function getWorkerActivities(): Collection
  840.     {
  841.         return $this->worker_activities;
  842.     }
  844.     public function addWorkerActivity(WorkerActivities $workerActivity): self
  845.     {
  846.         if (!$this->worker_activities->contains($workerActivity)) {
  847.             $this->worker_activities[] = $workerActivity;
  848.             $workerActivity->setUser($this);
  849.         }
  851.         return $this;
  852.     }
  854.     public function removeWorkerActivity(WorkerActivities $workerActivity): self
  855.     {
  856.         if ($this->worker_activities->removeElement($workerActivity)) {
  857.             // set the owning side to null (unless already changed)
  858.             if ($workerActivity->getUser() === $this) {
  859.                 $workerActivity->setUser(null);
  860.             }
  861.         }
  863.         return $this;
  864.     }
  866.     /**
  867.      * @return Collection<int, PurchaseRequest>
  868.      */
  869.     public function getPurchaseRequestsRequester(): Collection
  870.     {
  871.         return $this->purchase_requests_requester;
  872.     }
  874.     public function addPurchaseRequestForRequester(PurchaseRequest $purchaseRequest): self
  875.     {
  876.         if (!$this->purchase_requests_requester->contains($purchaseRequest)) {
  877.             $this->purchase_requests_requester[] = $purchaseRequest;
  878.             $purchaseRequest->setRequester($this);
  879.         }
  881.         return $this;
  882.     }
  884.     public function removePurchaseRequestFromRequester(PurchaseRequest $purchaseRequest): self
  885.     {
  886.         if ($this->purchase_requests_requester->removeElement($purchaseRequest)) {
  887.             // set the owning side to null (unless already changed)
  888.             if ($purchaseRequest->getRequester() === $this) {
  889.                 $purchaseRequest->setRequester(null);
  890.             }
  891.         }
  893.         return $this;
  894.     }
  896.     /**
  897.      * @return Collection<int, PurchaseRequest>
  898.      */
  899.     public function getPurchaseRequestsApprover(): Collection
  900.     {
  901.         return $this->purchase_requests_approver;
  902.     }
  904.     public function addPurchaseRequestForApprover(PurchaseRequest $purchaseRequest): self
  905.     {
  906.         if (!$this->purchase_requests_approver->contains($purchaseRequest)) {
  907.             $this->purchase_requests_approver[] = $purchaseRequest;
  908.             $purchaseRequest->setApprover($this);
  909.         }
  911.         return $this;
  912.     }
  914.     public function removePurchaseRequestFromApprover(PurchaseRequest $purchaseRequest): self
  915.     {
  916.         if ($this->purchase_requests_approver->removeElement($purchaseRequest)) {
  917.             // set the owning side to null (unless already changed)
  918.             if ($purchaseRequest->getApprover() === $this) {
  919.                 $purchaseRequest->setApprover(null);
  920.             }
  921.         }
  923.         return $this;
  924.     }
  926.     /**
  927.      * @return Collection<int, PurchaseRequestPositionHistoryRead>
  928.      */
  929.     public function getPositionPurchaseRequestPositionHistoryReads(): Collection
  930.     {
  931.         return $this->purchase_request_position_history_reads;
  932.     }
  934.     public function addPurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  935.     {
  936.         if (!$this->purchase_request_position_history_reads->contains($purchaseRequestPositionHistoryRead)) {
  937.             $this->purchase_request_position_history_reads[] = $purchaseRequestPositionHistoryRead;
  938.             $purchaseRequestPositionHistoryRead->setUser($this);
  939.         }
  941.         return $this;
  942.     }
  944.     public function removePurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  945.     {
  946.         if ($this->purchase_request_position_history_reads->removeElement($purchaseRequestPositionHistoryRead)) {
  947.             // set the owning side to null (unless already changed)
  948.             if ($purchaseRequestPositionHistoryRead->getUser() === $this) {
  949.                 $purchaseRequestPositionHistoryRead->setUser(null);
  950.             }
  951.         }
  953.         return $this;
  954.     }
  956.     /**
  957.      * @return Collection<int, PurchaseRequestHistoryRead>
  958.      */
  959.     public function getPurchaseRequestHistoryReads(): Collection
  960.     {
  961.         return $this->purchase_request_history_reads;
  962.     }
  964.     /**
  965.      * @return Collection<int, PurchaseRequestHistories>
  966.      */
  967.     public function getPurchaseRequestHistories(): Collection
  968.     {
  969.         return $this->purchaseRequestHistories;
  970.     }
  972.     public function addPurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  973.     {
  974.         if (!$this->purchaseRequestHistories->contains($purchaseRequestHistory)) {
  975.             $this->purchaseRequestHistories[] = $purchaseRequestHistory;
  976.             $purchaseRequestHistory->setOwner($this);
  977.         }
  979.         return $this;
  980.     }
  982.     public function removePurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  983.     {
  984.         if ($this->purchaseRequestHistories->removeElement($purchaseRequestHistory)) {
  985.             // set the owning side to null (unless already changed)
  986.             if ($purchaseRequestHistory->getOwner() === $this) {
  987.                 $purchaseRequestHistory->setOwner(null);
  988.             }
  989.         }
  991.         return $this;
  992.     }
  994.     /**
  995.      * @return Collection<int, PurchaseRequestUserFavorites>
  996.      */
  997.     public function getPurchaseRequestUserFavorites(): Collection
  998.     {
  999.         return $this->purchaseRequestUserFavorites;
  1000.     }
  1002.     public function addPurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1003.     {
  1004.         if (!$this->purchaseRequestUserFavorites->contains($purchaseRequestUserFavorite)) {
  1005.             $this->purchaseRequestUserFavorites[] = $purchaseRequestUserFavorite;
  1006.             $purchaseRequestUserFavorite->setUser($this);
  1007.         }
  1009.         return $this;
  1010.     }
  1012.     public function removePurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1013.     {
  1014.         if ($this->purchaseRequestUserFavorites->removeElement($purchaseRequestUserFavorite)) {
  1015.             // set the owning side to null (unless already changed)
  1016.             if ($purchaseRequestUserFavorite->getUser() === $this) {
  1017.                 $purchaseRequestUserFavorite->setUser(null);
  1018.             }
  1019.         }
  1021.         return $this;
  1022.     }
  1024.     /**
  1025.      * @return Collection<int, PurchaseRequestPositions>
  1026.      */
  1027.     public function getPurchaseRequestPositionsApprover(): Collection
  1028.     {
  1029.         return $this->purchase_request_positions_approver;
  1030.     }
  1032.     public function addPurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1033.     {
  1034.         if (!$this->purchase_request_positions_approver->contains($purchaseRequestPositionsApprover)) {
  1035.             $this->purchase_request_positions_approver[] = $purchaseRequestPositionsApprover;
  1036.             $purchaseRequestPositionsApprover->setApprover($this);
  1037.         }
  1039.         return $this;
  1040.     }
  1042.     public function removePurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1043.     {
  1044.         if ($this->purchase_request_positions_approver->removeElement($purchaseRequestPositionsApprover)) {
  1045.             // set the owning side to null (unless already changed)
  1046.             if ($purchaseRequestPositionsApprover->getApprover() === $this) {
  1047.                 $purchaseRequestPositionsApprover->setApprover(null);
  1048.             }
  1049.         }
  1051.         return $this;
  1052.     }
  1054.     /**
  1055.      * @return Collection<int, PurchaseRequestPositions>
  1056.      */
  1057.     public function getPurchaseRequestPositionsRejecter(): Collection
  1058.     {
  1059.         return $this->purchase_request_positions_rejecter;
  1060.     }
  1062.     public function addPurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1063.     {
  1064.         if (!$this->purchase_request_positions_rejecter->contains($purchaseRequestPositionsRejecter)) {
  1065.             $this->purchase_request_positions_rejecter[] = $purchaseRequestPositionsRejecter;
  1066.             $purchaseRequestPositionsRejecter->setRejecter($this);
  1067.         }
  1069.         return $this;
  1070.     }
  1072.     public function removePurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1073.     {
  1074.         if ($this->purchase_request_positions_rejecter->removeElement($purchaseRequestPositionsRejecter)) {
  1075.             // set the owning side to null (unless already changed)
  1076.             if ($purchaseRequestPositionsRejecter->getRejecter() === $this) {
  1077.                 $purchaseRequestPositionsRejecter->setRejecter(null);
  1078.             }
  1079.         }
  1081.         return $this;
  1082.     }
  1084.     /**
  1085.      * @return Collection<int, PurchaseRequest>
  1086.      */
  1087.     public function getPurchaseRequestRejecter(): Collection
  1088.     {
  1089.         return $this->purchase_request_rejecter;
  1090.     }
  1092.     public function addPurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1093.     {
  1094.         if (!$this->purchase_request_rejecter->contains($purchaseRequestRejecter)) {
  1095.             $this->purchase_request_rejecter[] = $purchaseRequestRejecter;
  1096.             $purchaseRequestRejecter->setRejecter($this);
  1097.         }
  1099.         return $this;
  1100.     }
  1102.     public function removePurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1103.     {
  1104.         if ($this->purchase_request_rejecter->removeElement($purchaseRequestRejecter)) {
  1105.             // set the owning side to null (unless already changed)
  1106.             if ($purchaseRequestRejecter->getRejecter() === $this) {
  1107.                 $purchaseRequestRejecter->setRejecter(null);
  1108.             }
  1109.         }
  1111.         return $this;
  1112.     }
  1114.     /**
  1115.      * @return Collection<int, Warehouses>
  1116.      */
  1117.     public function getWarehouses(): Collection
  1118.     {
  1119.         return $this->warehouses;
  1120.     }
  1122.     public function addWarehouse(Warehouses $warehouse): self
  1123.     {
  1124.         if (!$this->warehouses->contains($warehouse)) {
  1125.             $this->warehouses[] = $warehouse;
  1126.             $warehouse->setCreator($this);
  1127.         }
  1129.         return $this;
  1130.     }
  1132.     public function removeWarehouse(Warehouses $warehouse): self
  1133.     {
  1134.         if ($this->warehouses->removeElement($warehouse)) {
  1135.             // set the owning side to null (unless already changed)
  1136.             if ($warehouse->getCreator() === $this) {
  1137.                 $warehouse->setCreator(null);
  1138.             }
  1139.         }
  1141.         return $this;
  1142.     }
  1144.     /**
  1145.      * @return Collection<int, StockIssue>
  1146.      */
  1147.     public function getStockOutIssues(): Collection
  1148.     {
  1149.         return $this->stock_out_issues;
  1150.     }
  1152.     public function addStockOutIssue(StockIssue $stockOutIssue): self
  1153.     {
  1154.         if (!$this->stock_out_issues->contains($stockOutIssue)) {
  1155.             $this->stock_out_issues[] = $stockOutIssue;
  1156.             $stockOutIssue->setIssuedBy($this);
  1157.         }
  1159.         return $this;
  1160.     }
  1162.     public function removeStockOutIssue(StockIssue $stockOutIssue): self
  1163.     {
  1164.         if ($this->stock_out_issues->removeElement($stockOutIssue)) {
  1165.             // set the owning side to null (unless already changed)
  1166.             if ($stockOutIssue->getIssuedBy() === $this) {
  1167.                 $stockOutIssue->setIssuedBy(null);
  1168.             }
  1169.         }
  1171.         return $this;
  1172.     }
  1174.     /**
  1175.      * @return Collection<int, StockIssuePositions>
  1176.      */
  1177.     public function getDeliveredStockIssuePositions(): Collection
  1178.     {
  1179.         return $this->delivered_stock_issue_positions;
  1180.     }
  1182.     public function addDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1183.     {
  1184.         if (!$this->delivered_stock_issue_positions->contains($deliveredStockIssuePosition)) {
  1185.             $this->delivered_stock_issue_positions[] = $deliveredStockIssuePosition;
  1186.             $deliveredStockIssuePosition->setDeliverer($this);
  1187.         }
  1189.         return $this;
  1190.     }
  1192.     public function removeDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1193.     {
  1194.         if ($this->delivered_stock_issue_positions->removeElement($deliveredStockIssuePosition)) {
  1195.             // set the owning side to null (unless already changed)
  1196.             if ($deliveredStockIssuePosition->getDeliverer() === $this) {
  1197.                 $deliveredStockIssuePosition->setDeliverer(null);
  1198.             }
  1199.         }
  1201.         return $this;
  1202.     }
  1205. }