src/Entity/User.php line 23

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\Common\Collections\Selectable;
  10. use Doctrine\ORM\Mapping as ORM;
  11. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  12. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  13. use Symfony\Component\Security\Core\User\UserInterface;
  14. use Symfony\Component\Serializer\Annotation\Groups;
  16. /**
  17.  * @ORM\Entity(repositoryClass=UserRepository::class)
  18.  * @UniqueEntity(
  19.  *       fields={"email"},
  20.  *       message="User already registered|User with combination (%s) is already registered"
  21.  *  )
  22.  */
  23. class User implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     /**
  26.      * @ORM\Id
  27.      * @ORM\GeneratedValue
  28.      * @ORM\Column(type="integer")
  29.      * @Groups({
  30.      *     "user.core",
  31.      *     "user:core",
  32.      *     "user@base",
  33.      *     "user@core"
  34.      * })
  35.      */
  36.     private $id;
  38.     /**
  39.      * @ORM\Column(type="string", length=180, unique=true)
  40.      * @Groups({
  41.      *     "user.core",
  42.      *     "user:core",
  43.      *     "user@core",
  44.      *     "user@base",
  45.      *     "user@open_api"
  46.      *  })
  47.      */
  48.     private $email;
  50.     /**
  51.      * @ORM\Column(type="json")
  52.      * @Groups({
  53.      *     "user.core",
  54.      *     "user:core",
  55.      *     "user@core",
  56.      *     "user@roles"
  57.      *  })
  58.      */
  59.     private $roles = [];
  61.     /**
  62.      * @var string The hashed password
  63.      * @ORM\Column(type="string")
  64.      */
  65.     private $password;
  67.     /**
  68.      * @var string The hashed password
  69.      * @ORM\Column(type="string", length=64, nullable=true )
  70.      * Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
  71.      * @Groups({
  72.      *      "user.core",
  73.      *      "user:core",
  74.      *      "worker.manage.base.timesheet.payments",
  75.      *
  76.      *     "user@base",
  77.      *     "user@core",
  78.      *     "user@open_api"
  79.      *  })
  80.      */
  82.     private $name;
  84.     /**
  85.      * @var string The hashed password
  86.      * @ORM\Column(type="string", length=64, nullable=true )
  87.      * Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
  88.      * @Groups({
  89.      *     "user.core",
  90.      *     "user:core",
  91.      *     "worker.manage.base.timesheet.payments",
  92.      *
  93.      *     "user@base",
  94.      *     "user@core",
  95.      *     "user@open_api"
  96.      * })
  97.      */
  99.     private $surname;
  101.     /**
  102.      * Private Prop no column based
  103.      * @var string The hashed password
  104.      * @Groups({
  105.      *     "user.core",
  106.      *     "user:core",
  107.      *
  108.      *     "user@base",
  109.      *     "user@core",
  110.      *     "user@open_api"
  111.      * })
  112.      */
  114.     private $full_name;
  116.     public function getFullName(): string
  117.     {
  118.         return "{$this->getName()} {$this->getSurname()}";
  119.     }
  121.     /**
  122.      * @ORM\OneToMany(targetEntity=ProjectAddendumCosts::class, mappedBy="added_by")
  123.      */
  124.     private $projectAddendumCosts;
  125.     
  127.     /**
  128.      * TODO @deprecated
  129.      * @deprecated use user_rights
  130.      * @ORM\ManyToMany(targetEntity=AccessRoles::class, inversedBy="users")
  131.      * @Groups({
  132.      *     "user.manage",
  133.      *     "user.accessed.roles",
  134.      *
  135.      *     "user@acces_roles"
  136.      * })
  137.      */
  138.     private $user_accessed_roles;
  140.     /**
  141.      * @ORM\OneToMany(targetEntity=WorkerTimesheetPayments::class, mappedBy="payer")
  142.      */
  143.     private $workerTimesheetPayments;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity=ProjectOrderFeedback::class, mappedBy="user")
  147.      */
  148.     private $projectOrderFeedback;
  150.     /**
  151.      * @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="author")
  152.      */
  153.     private $projectOrders;
  155.     /**
  156.      * @ORM\Column(type="boolean", nullable=true)
  157.      * @Groups({
  158.      *     "user.core",
  159.      *     "user:core",
  160.      *     "user@core"
  161.      * })
  162.      */
  163.     private $login_refused;
  165.     /**
  166.      * @ORM\Column(type="string", length=255, nullable=true)
  167.      * @Groups({
  168.      *      "user.core",
  169.      *      "user:core",
  170.      *      "user@core"
  171.      *  })
  172.      */
  173.     private $login_refused_message;
  175.     /**
  176.      * @ORM\Column(type="datetime", nullable=true)
  177.      */
  178.     private $invisible_since;
  180.     /**
  181.      * @ORM\OneToMany(targetEntity=UserModulePermissions::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
  182.      * @Groups({
  183.      *     "user.rights",
  184.      *
  185.      *     "user@rights",
  186.      *
  187.      *
  188.      *     "user@permissions"
  189.      * })
  190.      */
  191.     private $user_module_permissions;
  193.     /**
  194.      * @ORM\OneToMany(targetEntity=Inventory::class, mappedBy="involved_by")
  195.      */
  196.     private $inventories;
  198.     /**
  199.      * @ORM\OneToMany(targetEntity=SupplierOrders::class, mappedBy="order_by")
  200.      */
  201.     private $supplierOrders;
  203.     /**
  204.      * TODO Replace prop with ownership
  205.      * @ORM\OneToMany(targetEntity=UserScopedItem::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
  206.      * @Groups({
  207.      *     "user.scoped.items",
  208.      *     "user@ownerships"
  209.      * })
  210.      */
  211.     private $user_scoped_items;
  213.     /**
  214.      * @deprecated use workerActivity instead
  215.      * @ORM\OneToOne(targetEntity=Worker::class, mappedBy="user", cascade={"persist", "remove"})
  216.      */
  217.     private $worker;
  219.     /**
  220.      * @ORM\OneToMany(targetEntity=UserCalculationPermission::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
  221.      * @Groups({"user.calculate.permissions"})
  222.      */
  223.     private $user_calculation_permissions;
  225.     /**
  226.      * @ORM\Column(type="datetime_immutable", nullable=true)
  227.      * @Groups({
  228.      *     "user.core",
  229.      *     "user:core",
  230.      *     "user@core"
  231.      * })
  232.      */
  233.     private $is_password_updated_at;
  235.     /**
  236.      * @ORM\ManyToOne(targetEntity=UserPositions::class, inversedBy="users")
  237.      * @Groups({
  238.      *     "user.position",
  239.      *
  240.      *     "user@position"
  241.      * })
  242.      */
  243.     private $user_position;
  245.     /**
  246.      * @ORM\Column(type="integer", nullable=true)
  247.      * @Groups({
  248.      *      "user.core",
  249.      *      "user:core",
  250.      *      "user@core"
  251.      *  })
  252.      */
  253.     private $idle_timer_timeout;
  255.     /**
  256.      * @ORM\Column(type="json", nullable=true)
  257.      * @Groups({
  258.      *      "user.core",
  259.      *      "user:core",
  260.      *      "user@core"
  261.      *  })
  262.      */
  263.     private $notification_preferences = [];
  265.     /**
  266.      * @ORM\Column(type="text", nullable=true)
  267.      * @Groups({
  268.      *      "user.core",
  269.      *      "user:core",
  270.      *      "user@core"
  271.      *  })
  272.      */
  273.     private $email_signature;
  275.     /**
  276.      * @ORM\OneToMany(targetEntity=WorkerActivities::class, mappedBy="user")
  277.      * @Groups({
  278.      *     "user.worker.activities",
  279.      *     "user@worker_activities"
  280.      * })
  281.      */
  282.     private $worker_activities;
  284.     /**
  285.      * NO COLUMN BASED
  286.      * @Groups({
  287.      *      "user.as.worker.latest.activity",
  288.      *      "user@latest_activity"
  289.      *  })
  290.      */
  291.     private $user_as_worker_latest_activity;
  293.     /**
  294.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="requester")
  295.      */
  296.     private $purchase_requests_requester;
  298.     /**
  299.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="approver")
  300.      */
  301.     private $purchase_requests_approver;
  303.     /**
  304.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositionHistoryRead::class, mappedBy="user")
  305.      */
  306.     private $purchase_request_position_history_reads;
  308.     /**
  309.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistoryRead::class, mappedBy="user")
  310.      */
  311.     private $purchase_request_history_reads;
  313.     /**
  314.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistories::class, mappedBy="owner")
  315.      */
  316.     private $purchaseRequestHistories;
  318.     /**
  319.      * @ORM\OneToMany(targetEntity=PurchaseRequestUserFavorites::class, mappedBy="user")
  320.      */
  321.     private $purchaseRequestUserFavorites;
  323.     /**
  324.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="approver")
  325.      */
  326.     private $purchase_request_positions_approver;
  328.     /**
  329.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="rejecter")
  330.      */
  331.     private $purchase_request_positions_rejecter;
  333.     /**
  334.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="rejecter")
  335.      */
  336.     private $purchase_request_rejecter;
  338.     /**
  339.      * @ORM\OneToMany(targetEntity=Warehouses::class, mappedBy="creator")
  340.      */
  341.     private $warehouses;
  343.     /**
  344.      * @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issued_by")
  345.      */
  346.     private $stock_out_issues;
  348.     /**
  349.      * @ORM\OneToMany(targetEntity=StockIssuePositions::class, mappedBy="deliverer")
  350.      */
  351.     private $delivered_stock_issue_positions;
  353.     /**
  354.      * @ORM\OneToMany(targetEntity=ProjectAIReports::class, mappedBy="analyse_by")
  355.      */
  356.     private $project_ai_reports;
  358.     /**
  359.      * @ORM\OneToMany(targetEntity=Invoices::class, mappedBy="adder")
  360.      */
  361.     private $invoices;
  363.     /**
  364.      * @ORM\OneToMany(targetEntity=ProjectOrderBillings::class, mappedBy="adder")
  365.      */
  366.     private $project_order_billings;
  369.     // Custom Virtual Column
  370.      private ?WorkerActivities $latest_activity = null;
  372.     /**
  373.      * @return mixed
  374.      */
  375.     public function getUserAsWorkerLatestActivity()
  376.     {
  378.         $criteria = Criteria::create();
  379.         // $criteria->where(Criteria::expr()->isNull('exit_at'));
  380.         $criteria->orderBy(['id' => Criteria::ASC]);// ->setMaxResults(1);
  382.         /**@var WorkerActivities $latestActivity*/
  383.         $latestActivity = $this->getWorkerActivities()->matching($criteria)->last();
  385.         return $this->latest_activity ?? $latestActivity;
  387.     }
  388.     public function setUserAsWorkerLatestActivity(WorkerActivities $workerActivity): void {
  389.         $this->latest_activity = $workerActivity;
  390.     }
  395.     public function __construct()
  396.     {
  397.         $this->projectAddendumCosts = new ArrayCollection();
  398.         $this->user_accessed_roles = new ArrayCollection();
  399.         $this->workerTimesheetPayments = new ArrayCollection();
  400.         $this->projectOrderFeedback = new ArrayCollection();
  401.         $this->projectOrders = new ArrayCollection();
  402.         $this->user_module_permissions = new ArrayCollection();
  403.         $this->inventories = new ArrayCollection();
  404.         $this->supplierOrders = new ArrayCollection();
  405.         $this->user_scoped_items = new ArrayCollection();
  406.         $this->user_calculation_permissions = new ArrayCollection();
  407.         $this->worker_activities = new ArrayCollection();
  408.         $this->purchase_requests_requester = new ArrayCollection();
  409.         $this->purchase_requests_approver = new ArrayCollection();
  410.         $this->purchase_request_position_history_reads = new ArrayCollection();
  411.         $this->purchase_request_history_reads = new ArrayCollection();
  412.         $this->purchaseRequestHistories = new ArrayCollection();
  413.         $this->purchaseRequestUserFavorites = new ArrayCollection();
  414.         $this->purchase_request_positions_approver = new ArrayCollection();
  415.         $this->purchase_request_positions_rejecter = new ArrayCollection();
  416.         $this->purchase_request_rejecter = new ArrayCollection();
  417.         $this->warehouses = new ArrayCollection();
  418.         $this->stock_out_issues = new ArrayCollection();
  419.         $this->delivered_stock_issue_positions = new ArrayCollection();
  420.         $this->project_ai_reports = new ArrayCollection();
  421.         $this->invoices = new ArrayCollection();
  422.         $this->project_order_billings = new ArrayCollection();
  423.     }
  425.     public function getId(): ?int
  426.     {
  427.         return $this->id;
  428.     }
  430.     public function getEmail(): ?string
  431.     {
  432.         return $this->email;
  433.     }
  435.     public function setEmail(string $email): self
  436.     {
  437.         $this->email = $email;
  439.         return $this;
  440.     }
  442.     /**
  443.      * A visual identifier that represents this user.
  444.      *
  445.      * @see UserInterface
  446.      */
  447.     public function getUserIdentifier(): string
  448.     {
  449.         return (string) $this->email;
  450.     }
  452.     /**
  453.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  454.      */
  455.     public function getUsername(): string
  456.     {
  457.         return (string) $this->email;
  458.     }
  460.     /**
  461.      * @see UserInterface
  462.      */
  463.     public function getRoles(): array
  464.     {
  465.         $roles = $this->roles;
  466.         // guarantee every user at least has ROLE_USER
  467.         $roles[] = 'ROLE_USER';
  469.         return array_unique($roles);
  470.     }
  472.     public function setRoles(array $roles): self
  473.     {
  474.         $this->roles = $roles;
  476.         return $this;
  477.     }
  479.     /**
  480.      * @see PasswordAuthenticatedUserInterface
  481.      */
  482.     public function getPassword(): string
  483.     {
  484.         return $this->password;
  485.     }
  487.     public function setPassword(string $password): self
  488.     {
  489.         $this->password = $password;
  491.         return $this;
  492.     }
  494.     public function getName(): ?string
  495.     {
  496.         return $this->name;
  497.     }
  499.     public function setName( ?string $name): self
  500.     {
  501.         $this->name = $name;
  503.         return $this;
  504.     }
  506.     public function getSurname(): ?string
  507.     {
  508.         return $this->surname;
  509.     }
  511.     public function setSurname(?string $surname): self
  512.     {
  513.         $this->surname = $surname;
  515.         return $this;
  516.     }
  518.     /**
  519.      * Returning a salt is only needed, if you are not using a modern
  520.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  521.      *
  522.      * @see UserInterface
  523.      */
  524.     public function getSalt(): ?string
  525.     {
  526.         return null;
  527.     }
  529.     /**
  530.      * @see UserInterface
  531.      */
  532.     public function eraseCredentials()
  533.     {
  534.         // If you store any temporary, sensitive data on the user, clear it here
  535.         // $this->plainPassword = null;
  536.     }
  538.     /**
  539.      * @return Collection<int, ProjectAddendumCosts>
  540.      */
  541.     public function getProjectAddendumCosts(): Collection
  542.     {
  543.         return $this->projectAddendumCosts;
  544.     }
  546.     public function addProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  547.     {
  548.         if (!$this->projectAddendumCosts->contains($projectAddendumCost)) {
  549.             $this->projectAddendumCosts[] = $projectAddendumCost;
  550.             $projectAddendumCost->setAddedBy($this);
  551.         }
  553.         return $this;
  554.     }
  556.     public function removeProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  557.     {
  558.         if ($this->projectAddendumCosts->removeElement($projectAddendumCost)) {
  559.             // set the owning side to null (unless already changed)
  560.             if ($projectAddendumCost->getAddedBy() === $this) {
  561.                 $projectAddendumCost->setAddedBy(null);
  562.             }
  563.         }
  565.         return $this;
  566.     }
  568.     /**
  569.      * TODO Check this absolutely
  570.      * @return Collection<int, AccessRoles>
  571.      *     @deprecated use user_rights
  572.      */
  573.     public function getUserAccessedRoles(): Collection
  574.     {
  575.         return $this->user_accessed_roles;
  576.     }
  578.     /**
  579.      * @deprecated use user_rights
  580.     */
  581.     public function addUserAccessedRole(AccessRoles $userAccessedRole): self
  582.     {
  583.         if (!$this->user_accessed_roles->contains($userAccessedRole)) {
  584.             $this->user_accessed_roles[] = $userAccessedRole;
  585.         }
  587.         return $this;
  588.     }
  590.     /**
  591.      * @deprecated use user_rights
  592.     */
  593.     public function removeUserAccessedRole(AccessRoles $userAccessedRole): self
  594.     {
  595.         $this->user_accessed_roles->removeElement($userAccessedRole);
  597.         return $this;
  598.     }
  600.     /**
  601.      * @return Collection<int, WorkerTimesheetPayments>
  602.      */
  603.     public function getWorkerTimesheetPayments(): Collection
  604.     {
  605.         return $this->workerTimesheetPayments;
  606.     }
  608.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  609.     {
  610.         if (!$this->workerTimesheetPayments->contains($workerTimesheetPayment)) {
  611.             $this->workerTimesheetPayments[] = $workerTimesheetPayment;
  612.             $workerTimesheetPayment->setPayer($this);
  613.         }
  615.         return $this;
  616.     }
  618.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  619.     {
  620.         if ($this->workerTimesheetPayments->removeElement($workerTimesheetPayment)) {
  621.             // set the owning side to null (unless already changed)
  622.             if ($workerTimesheetPayment->getPayer() === $this) {
  623.                 $workerTimesheetPayment->setPayer(null);
  624.             }
  625.         }
  627.         return $this;
  628.     }
  630.     /**
  631.      * @return Collection<int, ProjectOrderFeedback>
  632.      */
  633.     public function getProjectOrderFeedback(): Collection
  634.     {
  635.         return $this->projectOrderFeedback;
  636.     }
  638.     public function addProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  639.     {
  640.         if (!$this->projectOrderFeedback->contains($projectOrderFeedback)) {
  641.             $this->projectOrderFeedback[] = $projectOrderFeedback;
  642.             $projectOrderFeedback->setUser($this);
  643.         }
  645.         return $this;
  646.     }
  648.     public function removeProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  649.     {
  650.         if ($this->projectOrderFeedback->removeElement($projectOrderFeedback)) {
  651.             // set the owning side to null (unless already changed)
  652.             if ($projectOrderFeedback->getUser() === $this) {
  653.                 $projectOrderFeedback->setUser(null);
  654.             }
  655.         }
  657.         return $this;
  658.     }
  660.     /**
  661.      * @return Collection<int, ProjectOrders>
  662.      */
  663.     public function getProjectOrders(): Collection
  664.     {
  665.         return $this->projectOrders;
  666.     }
  668.     public function addProjectOrder(ProjectOrders $projectOrder): self
  669.     {
  670.         if (!$this->projectOrders->contains($projectOrder)) {
  671.             $this->projectOrders[] = $projectOrder;
  672.             $projectOrder->setAuthor($this);
  673.         }
  675.         return $this;
  676.     }
  678.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  679.     {
  680.         if ($this->projectOrders->removeElement($projectOrder)) {
  681.             // set the owning side to null (unless already changed)
  682.             if ($projectOrder->getAuthor() === $this) {
  683.                 $projectOrder->setAuthor(null);
  684.             }
  685.         }
  687.         return $this;
  688.     }
  690.     public function isLoginRefused(): ?bool
  691.     {
  692.         return $this->login_refused;
  693.     }
  695.     public function setLoginRefused(?bool $login_refused): self
  696.     {
  697.         $this->login_refused = $login_refused;
  699.         return $this;
  700.     }
  702.     public function getLoginRefusedMessage(): ?string
  703.     {
  704.         return $this->login_refused_message;
  705.     }
  707.     public function setLoginRefusedMessage(?string $login_refused_message): self
  708.     {
  709.         $this->login_refused_message = $login_refused_message;
  711.         return $this;
  712.     }
  714.     public function getInvisibleSince(): ?\DateTimeInterface
  715.     {
  716.         return $this->invisible_since;
  717.     }
  719.     public function setInvisibleSince(?\DateTimeInterface $invisible_since): self
  720.     {
  721.         $this->invisible_since = $invisible_since;
  723.         return $this;
  724.     }
  726.     /**
  727.      * @return Collection<int, UserModulePermissions>&Selectable
  728.      */
  729.     public function getUserModulePermissions(): Collection
  730.     {
  731.         return $this->user_module_permissions;
  732.     }
  734.     public function addUserModulePermission(UserModulePermissions $userModulePermission): self
  735.     {
  736.         if (!$this->user_module_permissions->contains($userModulePermission)) {
  737.             $this->user_module_permissions[] = $userModulePermission;
  738.             $userModulePermission->setUser($this);
  739.         }
  741.         return $this;
  742.     }
  744.     public function removeUserModulePermission(UserModulePermissions $userModulePermission): self
  745.     {
  746.         if ($this->user_module_permissions->removeElement($userModulePermission)) {
  747.             // set the owning side to null (unless already changed)
  748.             if ($userModulePermission->getUser() === $this) {
  749.                 $userModulePermission->setUser(null);
  750.             }
  751.         }
  753.         return $this;
  754.     }
  756.     /**
  757.      * @return Collection<int, Inventory>
  758.      */
  759.     public function getInventories(): Collection
  760.     {
  761.         return $this->inventories;
  762.     }
  764.     public function addInventory(Inventory $inventory): self
  765.     {
  766.         if (!$this->inventories->contains($inventory)) {
  767.             $this->inventories[] = $inventory;
  768.             $inventory->setInvolvedBy($this);
  769.         }
  771.         return $this;
  772.     }
  774.     public function removeInventory(Inventory $inventory): self
  775.     {
  776.         if ($this->inventories->removeElement($inventory)) {
  777.             // set the owning side to null (unless already changed)
  778.             if ($inventory->getInvolvedBy() === $this) {
  779.                 $inventory->setInvolvedBy(null);
  780.             }
  781.         }
  783.         return $this;
  784.     }
  786.     /**
  787.      * @return Collection<int, SupplierOrders>
  788.      */
  789.     public function getSupplierOrders(): Collection
  790.     {
  791.         return $this->supplierOrders;
  792.     }
  794.     public function addSupplierOrder(SupplierOrders $supplierOrder): self
  795.     {
  796.         if (!$this->supplierOrders->contains($supplierOrder)) {
  797.             $this->supplierOrders[] = $supplierOrder;
  798.             $supplierOrder->setOrderBy($this);
  799.         }
  801.         return $this;
  802.     }
  804.     public function removeSupplierOrder(SupplierOrders $supplierOrder): self
  805.     {
  806.         if ($this->supplierOrders->removeElement($supplierOrder)) {
  807.             // set the owning side to null (unless already changed)
  808.             if ($supplierOrder->getOrderBy() === $this) {
  809.                 $supplierOrder->setOrderBy(null);
  810.             }
  811.         }
  813.         return $this;
  814.     }
  816.     /**
  817.      * @return Collection<int, UserScopedItem>
  818.      */
  819.     public function getUserScopedItems(): Collection
  820.     {
  821.         return $this->user_scoped_items;
  822.     }
  824.     public function addUserScopedItems(UserScopedItem $userScopedItem): self
  825.     {
  826.         if (!$this->user_scoped_items->contains($userScopedItem)) {
  827.             $this->user_scoped_items[] = $userScopedItem;
  828.             $userScopedItem->setUser($this);
  829.         }
  831.         return $this;
  832.     }
  834.     public function removeUserScopedItems(UserScopedItem $userScopedItem): self
  835.     {
  836.         if ($this->user_scoped_items->removeElement($userScopedItem)) {
  837.             // set the owning side to null (unless already changed)
  838.             if ($userScopedItem->getUser() === $this) {
  839.                 $userScopedItem->setUser(null);
  840.             }
  841.         }
  843.         return $this;
  844.     }
  846.     public function getWorker(): ?Worker
  847.     {
  848.         return $this->worker;
  849.     }
  851.     public function setWorker(?Worker $worker): self
  852.     {
  853.         // unset the owning side of the relation if necessary
  854.         if ($worker === null && $this->worker !== null) {
  855.             $this->worker->setUser(null);
  856.         }
  858.         // set the owning side of the relation if necessary
  859.         if ($worker !== null && $worker->getUser() !== $this) {
  860.             $worker->setUser($this);
  861.         }
  863.         $this->worker = $worker;
  865.         return $this;
  866.     }
  868.     /**
  869.      * @return Collection<int, UserCalculationPermission>
  870.      */
  871.     public function getUserCalculationPermissions(): Collection
  872.     {
  873.         return $this->user_calculation_permissions;
  874.     }
  876.     public function addUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  877.     {
  878.         if (!$this->user_calculation_permissions->contains($userCalculationPermission)) {
  879.             $this->user_calculation_permissions[] = $userCalculationPermission;
  880.             $userCalculationPermission->setUser($this);
  881.         }
  883.         return $this;
  884.     }
  886.     public function removeUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  887.     {
  888.         if ($this->user_calculation_permissions->removeElement($userCalculationPermission)) {
  889.             // set the owning side to null (unless already changed)
  890.             if ($userCalculationPermission->getUser() === $this) {
  891.                 $userCalculationPermission->setUser(null);
  892.             }
  893.         }
  895.         return $this;
  896.     }
  898.     public function getIsPasswordUpdatedAt(): ?\DateTimeImmutable
  899.     {
  900.         return $this->is_password_updated_at;
  901.     }
  903.     public function setIsPasswordUpdatedAt(?\DateTimeImmutable $is_password_updated_at): self
  904.     {
  905.         $this->is_password_updated_at = $is_password_updated_at;
  907.         return $this;
  908.     }
  910.     public function getUserPosition(): ?UserPositions
  911.     {
  912.         return $this->user_position;
  913.     }
  915.     public function setUserPosition(?UserPositions $user_position): self
  916.     {
  917.         $this->user_position = $user_position;
  919.         return $this;
  920.     }
  922.     public function getIdleTimerTimeout(): ?int
  923.     {
  924.         return $this->idle_timer_timeout;
  925.     }
  927.     public function setIdleTimerTimeout(?int $idle_timer_timeout): self
  928.     {
  929.         $this->idle_timer_timeout = $idle_timer_timeout;
  931.         return $this;
  932.     }
  934.     public function getNotificationPreferences(): ?array
  935.     {
  936.         return $this->notification_preferences;
  937.     }
  939.     public function setNotificationPreferences(?array $notification_preferences): self
  940.     {
  941.         $this->notification_preferences = $notification_preferences;
  943.         return $this;
  944.     }
  946.     public function getEmailSignature(): ?string
  947.     {
  948.         return $this->email_signature;
  949.     }
  951.     public function setEmailSignature(?string $email_signature): self
  952.     {
  953.         $this->email_signature = $email_signature;
  955.         return $this;
  956.     }
  958.     /**
  959.      * @return Collection<int, WorkerActivities>
  960.      */
  961.     public function getWorkerActivities(): Collection
  962.     {
  963.         return $this->worker_activities;
  964.     }
  966.     public function addWorkerActivity(WorkerActivities $workerActivity): self
  967.     {
  968.         if (!$this->worker_activities->contains($workerActivity)) {
  969.             $this->worker_activities[] = $workerActivity;
  970.             $workerActivity->setUser($this);
  971.         }
  973.         return $this;
  974.     }
  976.     public function removeWorkerActivity(WorkerActivities $workerActivity): self
  977.     {
  978.         if ($this->worker_activities->removeElement($workerActivity)) {
  979.             // set the owning side to null (unless already changed)
  980.             if ($workerActivity->getUser() === $this) {
  981.                 $workerActivity->setUser(null);
  982.             }
  983.         }
  985.         return $this;
  986.     }
  988.     /**
  989.      * @return Collection<int, PurchaseRequest>
  990.      */
  991.     public function getPurchaseRequestsRequester(): Collection
  992.     {
  993.         return $this->purchase_requests_requester;
  994.     }
  996.     public function addPurchaseRequestForRequester(PurchaseRequest $purchaseRequest): self
  997.     {
  998.         if (!$this->purchase_requests_requester->contains($purchaseRequest)) {
  999.             $this->purchase_requests_requester[] = $purchaseRequest;
  1000.             $purchaseRequest->setRequester($this);
  1001.         }
  1003.         return $this;
  1004.     }
  1006.     public function removePurchaseRequestFromRequester(PurchaseRequest $purchaseRequest): self
  1007.     {
  1008.         if ($this->purchase_requests_requester->removeElement($purchaseRequest)) {
  1009.             // set the owning side to null (unless already changed)
  1010.             if ($purchaseRequest->getRequester() === $this) {
  1011.                 $purchaseRequest->setRequester(null);
  1012.             }
  1013.         }
  1015.         return $this;
  1016.     }
  1018.     /**
  1019.      * @return Collection<int, PurchaseRequest>
  1020.      */
  1021.     public function getPurchaseRequestsApprover(): Collection
  1022.     {
  1023.         return $this->purchase_requests_approver;
  1024.     }
  1026.     public function addPurchaseRequestForApprover(PurchaseRequest $purchaseRequest): self
  1027.     {
  1028.         if (!$this->purchase_requests_approver->contains($purchaseRequest)) {
  1029.             $this->purchase_requests_approver[] = $purchaseRequest;
  1030.             $purchaseRequest->setApprover($this);
  1031.         }
  1033.         return $this;
  1034.     }
  1036.     public function removePurchaseRequestFromApprover(PurchaseRequest $purchaseRequest): self
  1037.     {
  1038.         if ($this->purchase_requests_approver->removeElement($purchaseRequest)) {
  1039.             // set the owning side to null (unless already changed)
  1040.             if ($purchaseRequest->getApprover() === $this) {
  1041.                 $purchaseRequest->setApprover(null);
  1042.             }
  1043.         }
  1045.         return $this;
  1046.     }
  1048.     /**
  1049.      * @return Collection<int, PurchaseRequestPositionHistoryRead>
  1050.      */
  1051.     public function getPositionPurchaseRequestPositionHistoryReads(): Collection
  1052.     {
  1053.         return $this->purchase_request_position_history_reads;
  1054.     }
  1056.     public function addPurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  1057.     {
  1058.         if (!$this->purchase_request_position_history_reads->contains($purchaseRequestPositionHistoryRead)) {
  1059.             $this->purchase_request_position_history_reads[] = $purchaseRequestPositionHistoryRead;
  1060.             $purchaseRequestPositionHistoryRead->setUser($this);
  1061.         }
  1063.         return $this;
  1064.     }
  1066.     public function removePurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  1067.     {
  1068.         if ($this->purchase_request_position_history_reads->removeElement($purchaseRequestPositionHistoryRead)) {
  1069.             // set the owning side to null (unless already changed)
  1070.             if ($purchaseRequestPositionHistoryRead->getUser() === $this) {
  1071.                 $purchaseRequestPositionHistoryRead->setUser(null);
  1072.             }
  1073.         }
  1075.         return $this;
  1076.     }
  1078.     /**
  1079.      * @return Collection<int, PurchaseRequestHistoryRead>
  1080.      */
  1081.     public function getPurchaseRequestHistoryReads(): Collection
  1082.     {
  1083.         return $this->purchase_request_history_reads;
  1084.     }
  1086.     /**
  1087.      * @return Collection<int, PurchaseRequestHistories>
  1088.      */
  1089.     public function getPurchaseRequestHistories(): Collection
  1090.     {
  1091.         return $this->purchaseRequestHistories;
  1092.     }
  1094.     public function addPurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  1095.     {
  1096.         if (!$this->purchaseRequestHistories->contains($purchaseRequestHistory)) {
  1097.             $this->purchaseRequestHistories[] = $purchaseRequestHistory;
  1098.             $purchaseRequestHistory->setOwner($this);
  1099.         }
  1101.         return $this;
  1102.     }
  1104.     public function removePurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  1105.     {
  1106.         if ($this->purchaseRequestHistories->removeElement($purchaseRequestHistory)) {
  1107.             // set the owning side to null (unless already changed)
  1108.             if ($purchaseRequestHistory->getOwner() === $this) {
  1109.                 $purchaseRequestHistory->setOwner(null);
  1110.             }
  1111.         }
  1113.         return $this;
  1114.     }
  1116.     /**
  1117.      * @return Collection<int, PurchaseRequestUserFavorites>
  1118.      */
  1119.     public function getPurchaseRequestUserFavorites(): Collection
  1120.     {
  1121.         return $this->purchaseRequestUserFavorites;
  1122.     }
  1124.     public function addPurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1125.     {
  1126.         if (!$this->purchaseRequestUserFavorites->contains($purchaseRequestUserFavorite)) {
  1127.             $this->purchaseRequestUserFavorites[] = $purchaseRequestUserFavorite;
  1128.             $purchaseRequestUserFavorite->setUser($this);
  1129.         }
  1131.         return $this;
  1132.     }
  1134.     public function removePurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1135.     {
  1136.         if ($this->purchaseRequestUserFavorites->removeElement($purchaseRequestUserFavorite)) {
  1137.             // set the owning side to null (unless already changed)
  1138.             if ($purchaseRequestUserFavorite->getUser() === $this) {
  1139.                 $purchaseRequestUserFavorite->setUser(null);
  1140.             }
  1141.         }
  1143.         return $this;
  1144.     }
  1146.     /**
  1147.      * @return Collection<int, PurchaseRequestPositions>
  1148.      */
  1149.     public function getPurchaseRequestPositionsApprover(): Collection
  1150.     {
  1151.         return $this->purchase_request_positions_approver;
  1152.     }
  1154.     public function addPurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1155.     {
  1156.         if (!$this->purchase_request_positions_approver->contains($purchaseRequestPositionsApprover)) {
  1157.             $this->purchase_request_positions_approver[] = $purchaseRequestPositionsApprover;
  1158.             $purchaseRequestPositionsApprover->setApprover($this);
  1159.         }
  1161.         return $this;
  1162.     }
  1164.     public function removePurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1165.     {
  1166.         if ($this->purchase_request_positions_approver->removeElement($purchaseRequestPositionsApprover)) {
  1167.             // set the owning side to null (unless already changed)
  1168.             if ($purchaseRequestPositionsApprover->getApprover() === $this) {
  1169.                 $purchaseRequestPositionsApprover->setApprover(null);
  1170.             }
  1171.         }
  1173.         return $this;
  1174.     }
  1176.     /**
  1177.      * @return Collection<int, PurchaseRequestPositions>
  1178.      */
  1179.     public function getPurchaseRequestPositionsRejecter(): Collection
  1180.     {
  1181.         return $this->purchase_request_positions_rejecter;
  1182.     }
  1184.     public function addPurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1185.     {
  1186.         if (!$this->purchase_request_positions_rejecter->contains($purchaseRequestPositionsRejecter)) {
  1187.             $this->purchase_request_positions_rejecter[] = $purchaseRequestPositionsRejecter;
  1188.             $purchaseRequestPositionsRejecter->setRejecter($this);
  1189.         }
  1191.         return $this;
  1192.     }
  1194.     public function removePurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1195.     {
  1196.         if ($this->purchase_request_positions_rejecter->removeElement($purchaseRequestPositionsRejecter)) {
  1197.             // set the owning side to null (unless already changed)
  1198.             if ($purchaseRequestPositionsRejecter->getRejecter() === $this) {
  1199.                 $purchaseRequestPositionsRejecter->setRejecter(null);
  1200.             }
  1201.         }
  1203.         return $this;
  1204.     }
  1206.     /**
  1207.      * @return Collection<int, PurchaseRequest>
  1208.      */
  1209.     public function getPurchaseRequestRejecter(): Collection
  1210.     {
  1211.         return $this->purchase_request_rejecter;
  1212.     }
  1214.     public function addPurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1215.     {
  1216.         if (!$this->purchase_request_rejecter->contains($purchaseRequestRejecter)) {
  1217.             $this->purchase_request_rejecter[] = $purchaseRequestRejecter;
  1218.             $purchaseRequestRejecter->setRejecter($this);
  1219.         }
  1221.         return $this;
  1222.     }
  1224.     public function removePurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1225.     {
  1226.         if ($this->purchase_request_rejecter->removeElement($purchaseRequestRejecter)) {
  1227.             // set the owning side to null (unless already changed)
  1228.             if ($purchaseRequestRejecter->getRejecter() === $this) {
  1229.                 $purchaseRequestRejecter->setRejecter(null);
  1230.             }
  1231.         }
  1233.         return $this;
  1234.     }
  1236.     /**
  1237.      * @return Collection<int, Warehouses>
  1238.      */
  1239.     public function getWarehouses(): Collection
  1240.     {
  1241.         return $this->warehouses;
  1242.     }
  1244.     public function addWarehouse(Warehouses $warehouse): self
  1245.     {
  1246.         if (!$this->warehouses->contains($warehouse)) {
  1247.             $this->warehouses[] = $warehouse;
  1248.             $warehouse->setCreator($this);
  1249.         }
  1251.         return $this;
  1252.     }
  1254.     public function removeWarehouse(Warehouses $warehouse): self
  1255.     {
  1256.         if ($this->warehouses->removeElement($warehouse)) {
  1257.             // set the owning side to null (unless already changed)
  1258.             if ($warehouse->getCreator() === $this) {
  1259.                 $warehouse->setCreator(null);
  1260.             }
  1261.         }
  1263.         return $this;
  1264.     }
  1266.     /**
  1267.      * @return Collection<int, StockIssue>
  1268.      */
  1269.     public function getStockOutIssues(): Collection
  1270.     {
  1271.         return $this->stock_out_issues;
  1272.     }
  1274.     public function addStockOutIssue(StockIssue $stockOutIssue): self
  1275.     {
  1276.         if (!$this->stock_out_issues->contains($stockOutIssue)) {
  1277.             $this->stock_out_issues[] = $stockOutIssue;
  1278.             $stockOutIssue->setIssuedBy($this);
  1279.         }
  1281.         return $this;
  1282.     }
  1284.     public function removeStockOutIssue(StockIssue $stockOutIssue): self
  1285.     {
  1286.         if ($this->stock_out_issues->removeElement($stockOutIssue)) {
  1287.             // set the owning side to null (unless already changed)
  1288.             if ($stockOutIssue->getIssuedBy() === $this) {
  1289.                 $stockOutIssue->setIssuedBy(null);
  1290.             }
  1291.         }
  1293.         return $this;
  1294.     }
  1296.     /**
  1297.      * @return Collection<int, StockIssuePositions>
  1298.      */
  1299.     public function getDeliveredStockIssuePositions(): Collection
  1300.     {
  1301.         return $this->delivered_stock_issue_positions;
  1302.     }
  1304.     public function addDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1305.     {
  1306.         if (!$this->delivered_stock_issue_positions->contains($deliveredStockIssuePosition)) {
  1307.             $this->delivered_stock_issue_positions[] = $deliveredStockIssuePosition;
  1308.             $deliveredStockIssuePosition->setDeliverer($this);
  1309.         }
  1311.         return $this;
  1312.     }
  1314.     public function removeDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1315.     {
  1316.         if ($this->delivered_stock_issue_positions->removeElement($deliveredStockIssuePosition)) {
  1317.             // set the owning side to null (unless already changed)
  1318.             if ($deliveredStockIssuePosition->getDeliverer() === $this) {
  1319.                 $deliveredStockIssuePosition->setDeliverer(null);
  1320.             }
  1321.         }
  1323.         return $this;
  1324.     }
  1326.     /**
  1327.      * @return Collection<int, ProjectAIReports>
  1328.      */
  1329.     public function getProjectAiReports(): Collection
  1330.     {
  1331.         return $this->project_ai_reports;
  1332.     }
  1334.     public function addProjectAiReport(ProjectAIReports $projectAiReport): self
  1335.     {
  1336.         if (!$this->project_ai_reports->contains($projectAiReport)) {
  1337.             $this->project_ai_reports[] = $projectAiReport;
  1338.             $projectAiReport->setAnalyseBy($this);
  1339.         }
  1341.         return $this;
  1342.     }
  1344.     public function removeProjectAiReport(ProjectAIReports $projectAiReport): self
  1345.     {
  1346.         if ($this->project_ai_reports->removeElement($projectAiReport)) {
  1347.             // set the owning side to null (unless already changed)
  1348.             if ($projectAiReport->getAnalyseBy() === $this) {
  1349.                 $projectAiReport->setAnalyseBy(null);
  1350.             }
  1351.         }
  1353.         return $this;
  1354.     }
  1356.     /**
  1357.      * @return Collection<int, Invoices>
  1358.      */
  1359.     public function getInvoices(): Collection
  1360.     {
  1361.         return $this->invoices;
  1362.     }
  1364.     public function addInvoice(Invoices $invoice): self
  1365.     {
  1366.         if (!$this->invoices->contains($invoice)) {
  1367.             $this->invoices[] = $invoice;
  1368.             $invoice->setAdder($this);
  1369.         }
  1371.         return $this;
  1372.     }
  1374.     public function removeInvoice(Invoices $invoice): self
  1375.     {
  1376.         if ($this->invoices->removeElement($invoice)) {
  1377.             // set the owning side to null (unless already changed)
  1378.             if ($invoice->getAdder() === $this) {
  1379.                 $invoice->setAdder(null);
  1380.             }
  1381.         }
  1383.         return $this;
  1384.     }
  1386.     /**
  1387.      * @return Collection<int, ProjectOrderBillings>
  1388.      */
  1389.     public function getProjectOrderBillings(): Collection
  1390.     {
  1391.         return $this->project_order_billings;
  1392.     }
  1394.     public function addProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
  1395.     {
  1396.         if (!$this->project_order_billings->contains($projectOrderBilling)) {
  1397.             $this->project_order_billings[] = $projectOrderBilling;
  1398.             $projectOrderBilling->setAdder($this);
  1399.         }
  1401.         return $this;
  1402.     }
  1404.     public function removeProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
  1405.     {
  1406.         if ($this->project_order_billings->removeElement($projectOrderBilling)) {
  1407.             // set the owning side to null (unless already changed)
  1408.             if ($projectOrderBilling->getAdder() === $this) {
  1409.                 $projectOrderBilling->setAdder(null);
  1410.             }
  1411.         }
  1413.         return $this;
  1414.     }
  1417. }