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.      * En son "What's New" (News) bildirimini gordugu an. FE bunu okuyup daha yeni
  237.      * News item'lari icin badge/NEW rozeti gosterir; drawer acilinca now() ile guncellenir.
  238.      * @ORM\Column(type="datetime_immutable", nullable=true)
  239.      * @Groups({
  240.      *     "user.core",
  241.      *     "user:core",
  242.      *     "user@core"
  243.      * })
  244.      */
  245.     private $news_last_seen_at;
  247.     /**
  248.      * @ORM\ManyToOne(targetEntity=UserPositions::class, inversedBy="users")
  249.      * @Groups({
  250.      *     "user.position",
  251.      *
  252.      *     "user@position"
  253.      * })
  254.      */
  255.     private $user_position;
  257.     /**
  258.      * @ORM\Column(type="integer", nullable=true)
  259.      * @Groups({
  260.      *      "user.core",
  261.      *      "user:core",
  262.      *      "user@core"
  263.      *  })
  264.      */
  265.     private $idle_timer_timeout;
  267.     /**
  268.      * @ORM\Column(type="json", nullable=true)
  269.      * @Groups({
  270.      *      "user.core",
  271.      *      "user:core",
  272.      *      "user@core"
  273.      *  })
  274.      */
  275.     private $notification_preferences = [];
  277.     /**
  278.      * @ORM\Column(type="text", nullable=true)
  279.      * @Groups({
  280.      *      "user.core",
  281.      *      "user:core",
  282.      *      "user@core"
  283.      *  })
  284.      */
  285.     private $email_signature;
  287.     /**
  288.      * @ORM\OneToMany(targetEntity=WorkerActivities::class, mappedBy="user")
  289.      * @Groups({
  290.      *     "user.worker.activities",
  291.      *     "user@worker_activities"
  292.      * })
  293.      */
  294.     private $worker_activities;
  296.     /**
  297.      * NO COLUMN BASED
  298.      * @Groups({
  299.      *      "user.as.worker.latest.activity",
  300.      *      "user@latest_activity"
  301.      *  })
  302.      */
  303.     private $user_as_worker_latest_activity;
  305.     /**
  306.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="requester")
  307.      */
  308.     private $purchase_requests_requester;
  310.     /**
  311.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="approver")
  312.      */
  313.     private $purchase_requests_approver;
  315.     /**
  316.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositionHistoryRead::class, mappedBy="user")
  317.      */
  318.     private $purchase_request_position_history_reads;
  320.     /**
  321.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistoryRead::class, mappedBy="user")
  322.      */
  323.     private $purchase_request_history_reads;
  325.     /**
  326.      * @ORM\OneToMany(targetEntity=PurchaseRequestHistories::class, mappedBy="owner")
  327.      */
  328.     private $purchaseRequestHistories;
  330.     /**
  331.      * @ORM\OneToMany(targetEntity=PurchaseRequestUserFavorites::class, mappedBy="user")
  332.      */
  333.     private $purchaseRequestUserFavorites;
  335.     /**
  336.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="approver")
  337.      */
  338.     private $purchase_request_positions_approver;
  340.     /**
  341.      * @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="rejecter")
  342.      */
  343.     private $purchase_request_positions_rejecter;
  345.     /**
  346.      * @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="rejecter")
  347.      */
  348.     private $purchase_request_rejecter;
  350.     /**
  351.      * @ORM\OneToMany(targetEntity=Warehouses::class, mappedBy="creator")
  352.      */
  353.     private $warehouses;
  355.     /**
  356.      * @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issued_by")
  357.      */
  358.     private $stock_out_issues;
  360.     /**
  361.      * @ORM\OneToMany(targetEntity=StockIssuePositions::class, mappedBy="deliverer")
  362.      */
  363.     private $delivered_stock_issue_positions;
  365.     /**
  366.      * @ORM\OneToMany(targetEntity=ProjectAIReports::class, mappedBy="analyse_by")
  367.      */
  368.     private $project_ai_reports;
  370.     /**
  371.      * @ORM\OneToMany(targetEntity=Invoices::class, mappedBy="adder")
  372.      */
  373.     private $invoices;
  375.     /**
  376.      * @ORM\OneToMany(targetEntity=ProjectOrderBillings::class, mappedBy="adder")
  377.      */
  378.     private $project_order_billings;
  381.     // Custom Virtual Column
  382.      private ?WorkerActivities $latest_activity = null;
  384.     /**
  385.      * @return mixed
  386.      */
  387.     public function getUserAsWorkerLatestActivity()
  388.     {
  390.         $criteria = Criteria::create();
  391.         // $criteria->where(Criteria::expr()->isNull('exit_at'));
  392.         $criteria->orderBy(['id' => Criteria::ASC]);// ->setMaxResults(1);
  394.         /**@var WorkerActivities $latestActivity*/
  395.         $latestActivity = $this->getWorkerActivities()->matching($criteria)->last();
  397.         return $this->latest_activity ?? $latestActivity;
  399.     }
  400.     public function setUserAsWorkerLatestActivity(WorkerActivities $workerActivity): void {
  401.         $this->latest_activity = $workerActivity;
  402.     }
  407.     public function __construct()
  408.     {
  409.         $this->projectAddendumCosts = new ArrayCollection();
  410.         $this->user_accessed_roles = new ArrayCollection();
  411.         $this->workerTimesheetPayments = new ArrayCollection();
  412.         $this->projectOrderFeedback = new ArrayCollection();
  413.         $this->projectOrders = new ArrayCollection();
  414.         $this->user_module_permissions = new ArrayCollection();
  415.         $this->inventories = new ArrayCollection();
  416.         $this->supplierOrders = new ArrayCollection();
  417.         $this->user_scoped_items = new ArrayCollection();
  418.         $this->user_calculation_permissions = new ArrayCollection();
  419.         $this->worker_activities = new ArrayCollection();
  420.         $this->purchase_requests_requester = new ArrayCollection();
  421.         $this->purchase_requests_approver = new ArrayCollection();
  422.         $this->purchase_request_position_history_reads = new ArrayCollection();
  423.         $this->purchase_request_history_reads = new ArrayCollection();
  424.         $this->purchaseRequestHistories = new ArrayCollection();
  425.         $this->purchaseRequestUserFavorites = new ArrayCollection();
  426.         $this->purchase_request_positions_approver = new ArrayCollection();
  427.         $this->purchase_request_positions_rejecter = new ArrayCollection();
  428.         $this->purchase_request_rejecter = new ArrayCollection();
  429.         $this->warehouses = new ArrayCollection();
  430.         $this->stock_out_issues = new ArrayCollection();
  431.         $this->delivered_stock_issue_positions = new ArrayCollection();
  432.         $this->project_ai_reports = new ArrayCollection();
  433.         $this->invoices = new ArrayCollection();
  434.         $this->project_order_billings = new ArrayCollection();
  435.     }
  437.     public function getId(): ?int
  438.     {
  439.         return $this->id;
  440.     }
  442.     public function getEmail(): ?string
  443.     {
  444.         return $this->email;
  445.     }
  447.     public function setEmail(string $email): self
  448.     {
  449.         $this->email = $email;
  451.         return $this;
  452.     }
  454.     /**
  455.      * A visual identifier that represents this user.
  456.      *
  457.      * @see UserInterface
  458.      */
  459.     public function getUserIdentifier(): string
  460.     {
  461.         return (string) $this->email;
  462.     }
  464.     /**
  465.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  466.      */
  467.     public function getUsername(): string
  468.     {
  469.         return (string) $this->email;
  470.     }
  472.     /**
  473.      * @see UserInterface
  474.      */
  475.     public function getRoles(): array
  476.     {
  477.         $roles = $this->roles;
  478.         // guarantee every user at least has ROLE_USER
  479.         $roles[] = 'ROLE_USER';
  481.         return array_unique($roles);
  482.     }
  484.     public function setRoles(array $roles): self
  485.     {
  486.         $this->roles = $roles;
  488.         return $this;
  489.     }
  491.     /**
  492.      * @see PasswordAuthenticatedUserInterface
  493.      */
  494.     public function getPassword(): string
  495.     {
  496.         return $this->password;
  497.     }
  499.     public function setPassword(string $password): self
  500.     {
  501.         $this->password = $password;
  503.         return $this;
  504.     }
  506.     public function getName(): ?string
  507.     {
  508.         return $this->name;
  509.     }
  511.     public function setName( ?string $name): self
  512.     {
  513.         $this->name = $name;
  515.         return $this;
  516.     }
  518.     public function getSurname(): ?string
  519.     {
  520.         return $this->surname;
  521.     }
  523.     public function setSurname(?string $surname): self
  524.     {
  525.         $this->surname = $surname;
  527.         return $this;
  528.     }
  530.     /**
  531.      * Returning a salt is only needed, if you are not using a modern
  532.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  533.      *
  534.      * @see UserInterface
  535.      */
  536.     public function getSalt(): ?string
  537.     {
  538.         return null;
  539.     }
  541.     /**
  542.      * @see UserInterface
  543.      */
  544.     public function eraseCredentials()
  545.     {
  546.         // If you store any temporary, sensitive data on the user, clear it here
  547.         // $this->plainPassword = null;
  548.     }
  550.     /**
  551.      * @return Collection<int, ProjectAddendumCosts>
  552.      */
  553.     public function getProjectAddendumCosts(): Collection
  554.     {
  555.         return $this->projectAddendumCosts;
  556.     }
  558.     public function addProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  559.     {
  560.         if (!$this->projectAddendumCosts->contains($projectAddendumCost)) {
  561.             $this->projectAddendumCosts[] = $projectAddendumCost;
  562.             $projectAddendumCost->setAddedBy($this);
  563.         }
  565.         return $this;
  566.     }
  568.     public function removeProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
  569.     {
  570.         if ($this->projectAddendumCosts->removeElement($projectAddendumCost)) {
  571.             // set the owning side to null (unless already changed)
  572.             if ($projectAddendumCost->getAddedBy() === $this) {
  573.                 $projectAddendumCost->setAddedBy(null);
  574.             }
  575.         }
  577.         return $this;
  578.     }
  580.     /**
  581.      * TODO Check this absolutely
  582.      * @return Collection<int, AccessRoles>
  583.      *     @deprecated use user_rights
  584.      */
  585.     public function getUserAccessedRoles(): Collection
  586.     {
  587.         return $this->user_accessed_roles;
  588.     }
  590.     /**
  591.      * @deprecated use user_rights
  592.     */
  593.     public function addUserAccessedRole(AccessRoles $userAccessedRole): self
  594.     {
  595.         if (!$this->user_accessed_roles->contains($userAccessedRole)) {
  596.             $this->user_accessed_roles[] = $userAccessedRole;
  597.         }
  599.         return $this;
  600.     }
  602.     /**
  603.      * @deprecated use user_rights
  604.     */
  605.     public function removeUserAccessedRole(AccessRoles $userAccessedRole): self
  606.     {
  607.         $this->user_accessed_roles->removeElement($userAccessedRole);
  609.         return $this;
  610.     }
  612.     /**
  613.      * @return Collection<int, WorkerTimesheetPayments>
  614.      */
  615.     public function getWorkerTimesheetPayments(): Collection
  616.     {
  617.         return $this->workerTimesheetPayments;
  618.     }
  620.     public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  621.     {
  622.         if (!$this->workerTimesheetPayments->contains($workerTimesheetPayment)) {
  623.             $this->workerTimesheetPayments[] = $workerTimesheetPayment;
  624.             $workerTimesheetPayment->setPayer($this);
  625.         }
  627.         return $this;
  628.     }
  630.     public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
  631.     {
  632.         if ($this->workerTimesheetPayments->removeElement($workerTimesheetPayment)) {
  633.             // set the owning side to null (unless already changed)
  634.             if ($workerTimesheetPayment->getPayer() === $this) {
  635.                 $workerTimesheetPayment->setPayer(null);
  636.             }
  637.         }
  639.         return $this;
  640.     }
  642.     /**
  643.      * @return Collection<int, ProjectOrderFeedback>
  644.      */
  645.     public function getProjectOrderFeedback(): Collection
  646.     {
  647.         return $this->projectOrderFeedback;
  648.     }
  650.     public function addProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  651.     {
  652.         if (!$this->projectOrderFeedback->contains($projectOrderFeedback)) {
  653.             $this->projectOrderFeedback[] = $projectOrderFeedback;
  654.             $projectOrderFeedback->setUser($this);
  655.         }
  657.         return $this;
  658.     }
  660.     public function removeProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
  661.     {
  662.         if ($this->projectOrderFeedback->removeElement($projectOrderFeedback)) {
  663.             // set the owning side to null (unless already changed)
  664.             if ($projectOrderFeedback->getUser() === $this) {
  665.                 $projectOrderFeedback->setUser(null);
  666.             }
  667.         }
  669.         return $this;
  670.     }
  672.     /**
  673.      * @return Collection<int, ProjectOrders>
  674.      */
  675.     public function getProjectOrders(): Collection
  676.     {
  677.         return $this->projectOrders;
  678.     }
  680.     public function addProjectOrder(ProjectOrders $projectOrder): self
  681.     {
  682.         if (!$this->projectOrders->contains($projectOrder)) {
  683.             $this->projectOrders[] = $projectOrder;
  684.             $projectOrder->setAuthor($this);
  685.         }
  687.         return $this;
  688.     }
  690.     public function removeProjectOrder(ProjectOrders $projectOrder): self
  691.     {
  692.         if ($this->projectOrders->removeElement($projectOrder)) {
  693.             // set the owning side to null (unless already changed)
  694.             if ($projectOrder->getAuthor() === $this) {
  695.                 $projectOrder->setAuthor(null);
  696.             }
  697.         }
  699.         return $this;
  700.     }
  702.     public function isLoginRefused(): ?bool
  703.     {
  704.         return $this->login_refused;
  705.     }
  707.     public function setLoginRefused(?bool $login_refused): self
  708.     {
  709.         $this->login_refused = $login_refused;
  711.         return $this;
  712.     }
  714.     public function getLoginRefusedMessage(): ?string
  715.     {
  716.         return $this->login_refused_message;
  717.     }
  719.     public function setLoginRefusedMessage(?string $login_refused_message): self
  720.     {
  721.         $this->login_refused_message = $login_refused_message;
  723.         return $this;
  724.     }
  726.     public function getInvisibleSince(): ?\DateTimeInterface
  727.     {
  728.         return $this->invisible_since;
  729.     }
  731.     public function setInvisibleSince(?\DateTimeInterface $invisible_since): self
  732.     {
  733.         $this->invisible_since = $invisible_since;
  735.         return $this;
  736.     }
  738.     /**
  739.      * @return Collection<int, UserModulePermissions>&Selectable
  740.      */
  741.     public function getUserModulePermissions(): Collection
  742.     {
  743.         return $this->user_module_permissions;
  744.     }
  746.     public function addUserModulePermission(UserModulePermissions $userModulePermission): self
  747.     {
  748.         if (!$this->user_module_permissions->contains($userModulePermission)) {
  749.             $this->user_module_permissions[] = $userModulePermission;
  750.             $userModulePermission->setUser($this);
  751.         }
  753.         return $this;
  754.     }
  756.     public function removeUserModulePermission(UserModulePermissions $userModulePermission): self
  757.     {
  758.         if ($this->user_module_permissions->removeElement($userModulePermission)) {
  759.             // set the owning side to null (unless already changed)
  760.             if ($userModulePermission->getUser() === $this) {
  761.                 $userModulePermission->setUser(null);
  762.             }
  763.         }
  765.         return $this;
  766.     }
  768.     /**
  769.      * @return Collection<int, Inventory>
  770.      */
  771.     public function getInventories(): Collection
  772.     {
  773.         return $this->inventories;
  774.     }
  776.     public function addInventory(Inventory $inventory): self
  777.     {
  778.         if (!$this->inventories->contains($inventory)) {
  779.             $this->inventories[] = $inventory;
  780.             $inventory->setInvolvedBy($this);
  781.         }
  783.         return $this;
  784.     }
  786.     public function removeInventory(Inventory $inventory): self
  787.     {
  788.         if ($this->inventories->removeElement($inventory)) {
  789.             // set the owning side to null (unless already changed)
  790.             if ($inventory->getInvolvedBy() === $this) {
  791.                 $inventory->setInvolvedBy(null);
  792.             }
  793.         }
  795.         return $this;
  796.     }
  798.     /**
  799.      * @return Collection<int, SupplierOrders>
  800.      */
  801.     public function getSupplierOrders(): Collection
  802.     {
  803.         return $this->supplierOrders;
  804.     }
  806.     public function addSupplierOrder(SupplierOrders $supplierOrder): self
  807.     {
  808.         if (!$this->supplierOrders->contains($supplierOrder)) {
  809.             $this->supplierOrders[] = $supplierOrder;
  810.             $supplierOrder->setOrderBy($this);
  811.         }
  813.         return $this;
  814.     }
  816.     public function removeSupplierOrder(SupplierOrders $supplierOrder): self
  817.     {
  818.         if ($this->supplierOrders->removeElement($supplierOrder)) {
  819.             // set the owning side to null (unless already changed)
  820.             if ($supplierOrder->getOrderBy() === $this) {
  821.                 $supplierOrder->setOrderBy(null);
  822.             }
  823.         }
  825.         return $this;
  826.     }
  828.     /**
  829.      * @return Collection<int, UserScopedItem>
  830.      */
  831.     public function getUserScopedItems(): Collection
  832.     {
  833.         return $this->user_scoped_items;
  834.     }
  836.     public function addUserScopedItems(UserScopedItem $userScopedItem): self
  837.     {
  838.         if (!$this->user_scoped_items->contains($userScopedItem)) {
  839.             $this->user_scoped_items[] = $userScopedItem;
  840.             $userScopedItem->setUser($this);
  841.         }
  843.         return $this;
  844.     }
  846.     public function removeUserScopedItems(UserScopedItem $userScopedItem): self
  847.     {
  848.         if ($this->user_scoped_items->removeElement($userScopedItem)) {
  849.             // set the owning side to null (unless already changed)
  850.             if ($userScopedItem->getUser() === $this) {
  851.                 $userScopedItem->setUser(null);
  852.             }
  853.         }
  855.         return $this;
  856.     }
  858.     public function getWorker(): ?Worker
  859.     {
  860.         return $this->worker;
  861.     }
  863.     public function setWorker(?Worker $worker): self
  864.     {
  865.         // unset the owning side of the relation if necessary
  866.         if ($worker === null && $this->worker !== null) {
  867.             $this->worker->setUser(null);
  868.         }
  870.         // set the owning side of the relation if necessary
  871.         if ($worker !== null && $worker->getUser() !== $this) {
  872.             $worker->setUser($this);
  873.         }
  875.         $this->worker = $worker;
  877.         return $this;
  878.     }
  880.     /**
  881.      * @return Collection<int, UserCalculationPermission>
  882.      */
  883.     public function getUserCalculationPermissions(): Collection
  884.     {
  885.         return $this->user_calculation_permissions;
  886.     }
  888.     public function addUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  889.     {
  890.         if (!$this->user_calculation_permissions->contains($userCalculationPermission)) {
  891.             $this->user_calculation_permissions[] = $userCalculationPermission;
  892.             $userCalculationPermission->setUser($this);
  893.         }
  895.         return $this;
  896.     }
  898.     public function removeUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
  899.     {
  900.         if ($this->user_calculation_permissions->removeElement($userCalculationPermission)) {
  901.             // set the owning side to null (unless already changed)
  902.             if ($userCalculationPermission->getUser() === $this) {
  903.                 $userCalculationPermission->setUser(null);
  904.             }
  905.         }
  907.         return $this;
  908.     }
  910.     public function getIsPasswordUpdatedAt(): ?\DateTimeImmutable
  911.     {
  912.         return $this->is_password_updated_at;
  913.     }
  915.     public function setIsPasswordUpdatedAt(?\DateTimeImmutable $is_password_updated_at): self
  916.     {
  917.         $this->is_password_updated_at = $is_password_updated_at;
  919.         return $this;
  920.     }
  922.     public function getNewsLastSeenAt(): ?\DateTimeImmutable
  923.     {
  924.         return $this->news_last_seen_at;
  925.     }
  927.     public function setNewsLastSeenAt(?\DateTimeImmutable $news_last_seen_at): self
  928.     {
  929.         $this->news_last_seen_at = $news_last_seen_at;
  931.         return $this;
  932.     }
  934.     public function getUserPosition(): ?UserPositions
  935.     {
  936.         return $this->user_position;
  937.     }
  939.     public function setUserPosition(?UserPositions $user_position): self
  940.     {
  941.         $this->user_position = $user_position;
  943.         return $this;
  944.     }
  946.     public function getIdleTimerTimeout(): ?int
  947.     {
  948.         return $this->idle_timer_timeout;
  949.     }
  951.     public function setIdleTimerTimeout(?int $idle_timer_timeout): self
  952.     {
  953.         $this->idle_timer_timeout = $idle_timer_timeout;
  955.         return $this;
  956.     }
  958.     public function getNotificationPreferences(): ?array
  959.     {
  960.         return $this->notification_preferences;
  961.     }
  963.     public function setNotificationPreferences(?array $notification_preferences): self
  964.     {
  965.         $this->notification_preferences = $notification_preferences;
  967.         return $this;
  968.     }
  970.     public function getEmailSignature(): ?string
  971.     {
  972.         return $this->email_signature;
  973.     }
  975.     public function setEmailSignature(?string $email_signature): self
  976.     {
  977.         $this->email_signature = $email_signature;
  979.         return $this;
  980.     }
  982.     /**
  983.      * @return Collection<int, WorkerActivities>
  984.      */
  985.     public function getWorkerActivities(): Collection
  986.     {
  987.         return $this->worker_activities;
  988.     }
  990.     public function addWorkerActivity(WorkerActivities $workerActivity): self
  991.     {
  992.         if (!$this->worker_activities->contains($workerActivity)) {
  993.             $this->worker_activities[] = $workerActivity;
  994.             $workerActivity->setUser($this);
  995.         }
  997.         return $this;
  998.     }
  1000.     public function removeWorkerActivity(WorkerActivities $workerActivity): self
  1001.     {
  1002.         if ($this->worker_activities->removeElement($workerActivity)) {
  1003.             // set the owning side to null (unless already changed)
  1004.             if ($workerActivity->getUser() === $this) {
  1005.                 $workerActivity->setUser(null);
  1006.             }
  1007.         }
  1009.         return $this;
  1010.     }
  1012.     /**
  1013.      * @return Collection<int, PurchaseRequest>
  1014.      */
  1015.     public function getPurchaseRequestsRequester(): Collection
  1016.     {
  1017.         return $this->purchase_requests_requester;
  1018.     }
  1020.     public function addPurchaseRequestForRequester(PurchaseRequest $purchaseRequest): self
  1021.     {
  1022.         if (!$this->purchase_requests_requester->contains($purchaseRequest)) {
  1023.             $this->purchase_requests_requester[] = $purchaseRequest;
  1024.             $purchaseRequest->setRequester($this);
  1025.         }
  1027.         return $this;
  1028.     }
  1030.     public function removePurchaseRequestFromRequester(PurchaseRequest $purchaseRequest): self
  1031.     {
  1032.         if ($this->purchase_requests_requester->removeElement($purchaseRequest)) {
  1033.             // set the owning side to null (unless already changed)
  1034.             if ($purchaseRequest->getRequester() === $this) {
  1035.                 $purchaseRequest->setRequester(null);
  1036.             }
  1037.         }
  1039.         return $this;
  1040.     }
  1042.     /**
  1043.      * @return Collection<int, PurchaseRequest>
  1044.      */
  1045.     public function getPurchaseRequestsApprover(): Collection
  1046.     {
  1047.         return $this->purchase_requests_approver;
  1048.     }
  1050.     public function addPurchaseRequestForApprover(PurchaseRequest $purchaseRequest): self
  1051.     {
  1052.         if (!$this->purchase_requests_approver->contains($purchaseRequest)) {
  1053.             $this->purchase_requests_approver[] = $purchaseRequest;
  1054.             $purchaseRequest->setApprover($this);
  1055.         }
  1057.         return $this;
  1058.     }
  1060.     public function removePurchaseRequestFromApprover(PurchaseRequest $purchaseRequest): self
  1061.     {
  1062.         if ($this->purchase_requests_approver->removeElement($purchaseRequest)) {
  1063.             // set the owning side to null (unless already changed)
  1064.             if ($purchaseRequest->getApprover() === $this) {
  1065.                 $purchaseRequest->setApprover(null);
  1066.             }
  1067.         }
  1069.         return $this;
  1070.     }
  1072.     /**
  1073.      * @return Collection<int, PurchaseRequestPositionHistoryRead>
  1074.      */
  1075.     public function getPositionPurchaseRequestPositionHistoryReads(): Collection
  1076.     {
  1077.         return $this->purchase_request_position_history_reads;
  1078.     }
  1080.     public function addPurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  1081.     {
  1082.         if (!$this->purchase_request_position_history_reads->contains($purchaseRequestPositionHistoryRead)) {
  1083.             $this->purchase_request_position_history_reads[] = $purchaseRequestPositionHistoryRead;
  1084.             $purchaseRequestPositionHistoryRead->setUser($this);
  1085.         }
  1087.         return $this;
  1088.     }
  1090.     public function removePurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
  1091.     {
  1092.         if ($this->purchase_request_position_history_reads->removeElement($purchaseRequestPositionHistoryRead)) {
  1093.             // set the owning side to null (unless already changed)
  1094.             if ($purchaseRequestPositionHistoryRead->getUser() === $this) {
  1095.                 $purchaseRequestPositionHistoryRead->setUser(null);
  1096.             }
  1097.         }
  1099.         return $this;
  1100.     }
  1102.     /**
  1103.      * @return Collection<int, PurchaseRequestHistoryRead>
  1104.      */
  1105.     public function getPurchaseRequestHistoryReads(): Collection
  1106.     {
  1107.         return $this->purchase_request_history_reads;
  1108.     }
  1110.     /**
  1111.      * @return Collection<int, PurchaseRequestHistories>
  1112.      */
  1113.     public function getPurchaseRequestHistories(): Collection
  1114.     {
  1115.         return $this->purchaseRequestHistories;
  1116.     }
  1118.     public function addPurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  1119.     {
  1120.         if (!$this->purchaseRequestHistories->contains($purchaseRequestHistory)) {
  1121.             $this->purchaseRequestHistories[] = $purchaseRequestHistory;
  1122.             $purchaseRequestHistory->setOwner($this);
  1123.         }
  1125.         return $this;
  1126.     }
  1128.     public function removePurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
  1129.     {
  1130.         if ($this->purchaseRequestHistories->removeElement($purchaseRequestHistory)) {
  1131.             // set the owning side to null (unless already changed)
  1132.             if ($purchaseRequestHistory->getOwner() === $this) {
  1133.                 $purchaseRequestHistory->setOwner(null);
  1134.             }
  1135.         }
  1137.         return $this;
  1138.     }
  1140.     /**
  1141.      * @return Collection<int, PurchaseRequestUserFavorites>
  1142.      */
  1143.     public function getPurchaseRequestUserFavorites(): Collection
  1144.     {
  1145.         return $this->purchaseRequestUserFavorites;
  1146.     }
  1148.     public function addPurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1149.     {
  1150.         if (!$this->purchaseRequestUserFavorites->contains($purchaseRequestUserFavorite)) {
  1151.             $this->purchaseRequestUserFavorites[] = $purchaseRequestUserFavorite;
  1152.             $purchaseRequestUserFavorite->setUser($this);
  1153.         }
  1155.         return $this;
  1156.     }
  1158.     public function removePurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
  1159.     {
  1160.         if ($this->purchaseRequestUserFavorites->removeElement($purchaseRequestUserFavorite)) {
  1161.             // set the owning side to null (unless already changed)
  1162.             if ($purchaseRequestUserFavorite->getUser() === $this) {
  1163.                 $purchaseRequestUserFavorite->setUser(null);
  1164.             }
  1165.         }
  1167.         return $this;
  1168.     }
  1170.     /**
  1171.      * @return Collection<int, PurchaseRequestPositions>
  1172.      */
  1173.     public function getPurchaseRequestPositionsApprover(): Collection
  1174.     {
  1175.         return $this->purchase_request_positions_approver;
  1176.     }
  1178.     public function addPurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1179.     {
  1180.         if (!$this->purchase_request_positions_approver->contains($purchaseRequestPositionsApprover)) {
  1181.             $this->purchase_request_positions_approver[] = $purchaseRequestPositionsApprover;
  1182.             $purchaseRequestPositionsApprover->setApprover($this);
  1183.         }
  1185.         return $this;
  1186.     }
  1188.     public function removePurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
  1189.     {
  1190.         if ($this->purchase_request_positions_approver->removeElement($purchaseRequestPositionsApprover)) {
  1191.             // set the owning side to null (unless already changed)
  1192.             if ($purchaseRequestPositionsApprover->getApprover() === $this) {
  1193.                 $purchaseRequestPositionsApprover->setApprover(null);
  1194.             }
  1195.         }
  1197.         return $this;
  1198.     }
  1200.     /**
  1201.      * @return Collection<int, PurchaseRequestPositions>
  1202.      */
  1203.     public function getPurchaseRequestPositionsRejecter(): Collection
  1204.     {
  1205.         return $this->purchase_request_positions_rejecter;
  1206.     }
  1208.     public function addPurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1209.     {
  1210.         if (!$this->purchase_request_positions_rejecter->contains($purchaseRequestPositionsRejecter)) {
  1211.             $this->purchase_request_positions_rejecter[] = $purchaseRequestPositionsRejecter;
  1212.             $purchaseRequestPositionsRejecter->setRejecter($this);
  1213.         }
  1215.         return $this;
  1216.     }
  1218.     public function removePurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
  1219.     {
  1220.         if ($this->purchase_request_positions_rejecter->removeElement($purchaseRequestPositionsRejecter)) {
  1221.             // set the owning side to null (unless already changed)
  1222.             if ($purchaseRequestPositionsRejecter->getRejecter() === $this) {
  1223.                 $purchaseRequestPositionsRejecter->setRejecter(null);
  1224.             }
  1225.         }
  1227.         return $this;
  1228.     }
  1230.     /**
  1231.      * @return Collection<int, PurchaseRequest>
  1232.      */
  1233.     public function getPurchaseRequestRejecter(): Collection
  1234.     {
  1235.         return $this->purchase_request_rejecter;
  1236.     }
  1238.     public function addPurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1239.     {
  1240.         if (!$this->purchase_request_rejecter->contains($purchaseRequestRejecter)) {
  1241.             $this->purchase_request_rejecter[] = $purchaseRequestRejecter;
  1242.             $purchaseRequestRejecter->setRejecter($this);
  1243.         }
  1245.         return $this;
  1246.     }
  1248.     public function removePurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
  1249.     {
  1250.         if ($this->purchase_request_rejecter->removeElement($purchaseRequestRejecter)) {
  1251.             // set the owning side to null (unless already changed)
  1252.             if ($purchaseRequestRejecter->getRejecter() === $this) {
  1253.                 $purchaseRequestRejecter->setRejecter(null);
  1254.             }
  1255.         }
  1257.         return $this;
  1258.     }
  1260.     /**
  1261.      * @return Collection<int, Warehouses>
  1262.      */
  1263.     public function getWarehouses(): Collection
  1264.     {
  1265.         return $this->warehouses;
  1266.     }
  1268.     public function addWarehouse(Warehouses $warehouse): self
  1269.     {
  1270.         if (!$this->warehouses->contains($warehouse)) {
  1271.             $this->warehouses[] = $warehouse;
  1272.             $warehouse->setCreator($this);
  1273.         }
  1275.         return $this;
  1276.     }
  1278.     public function removeWarehouse(Warehouses $warehouse): self
  1279.     {
  1280.         if ($this->warehouses->removeElement($warehouse)) {
  1281.             // set the owning side to null (unless already changed)
  1282.             if ($warehouse->getCreator() === $this) {
  1283.                 $warehouse->setCreator(null);
  1284.             }
  1285.         }
  1287.         return $this;
  1288.     }
  1290.     /**
  1291.      * @return Collection<int, StockIssue>
  1292.      */
  1293.     public function getStockOutIssues(): Collection
  1294.     {
  1295.         return $this->stock_out_issues;
  1296.     }
  1298.     public function addStockOutIssue(StockIssue $stockOutIssue): self
  1299.     {
  1300.         if (!$this->stock_out_issues->contains($stockOutIssue)) {
  1301.             $this->stock_out_issues[] = $stockOutIssue;
  1302.             $stockOutIssue->setIssuedBy($this);
  1303.         }
  1305.         return $this;
  1306.     }
  1308.     public function removeStockOutIssue(StockIssue $stockOutIssue): self
  1309.     {
  1310.         if ($this->stock_out_issues->removeElement($stockOutIssue)) {
  1311.             // set the owning side to null (unless already changed)
  1312.             if ($stockOutIssue->getIssuedBy() === $this) {
  1313.                 $stockOutIssue->setIssuedBy(null);
  1314.             }
  1315.         }
  1317.         return $this;
  1318.     }
  1320.     /**
  1321.      * @return Collection<int, StockIssuePositions>
  1322.      */
  1323.     public function getDeliveredStockIssuePositions(): Collection
  1324.     {
  1325.         return $this->delivered_stock_issue_positions;
  1326.     }
  1328.     public function addDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1329.     {
  1330.         if (!$this->delivered_stock_issue_positions->contains($deliveredStockIssuePosition)) {
  1331.             $this->delivered_stock_issue_positions[] = $deliveredStockIssuePosition;
  1332.             $deliveredStockIssuePosition->setDeliverer($this);
  1333.         }
  1335.         return $this;
  1336.     }
  1338.     public function removeDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
  1339.     {
  1340.         if ($this->delivered_stock_issue_positions->removeElement($deliveredStockIssuePosition)) {
  1341.             // set the owning side to null (unless already changed)
  1342.             if ($deliveredStockIssuePosition->getDeliverer() === $this) {
  1343.                 $deliveredStockIssuePosition->setDeliverer(null);
  1344.             }
  1345.         }
  1347.         return $this;
  1348.     }
  1350.     /**
  1351.      * @return Collection<int, ProjectAIReports>
  1352.      */
  1353.     public function getProjectAiReports(): Collection
  1354.     {
  1355.         return $this->project_ai_reports;
  1356.     }
  1358.     public function addProjectAiReport(ProjectAIReports $projectAiReport): self
  1359.     {
  1360.         if (!$this->project_ai_reports->contains($projectAiReport)) {
  1361.             $this->project_ai_reports[] = $projectAiReport;
  1362.             $projectAiReport->setAnalyseBy($this);
  1363.         }
  1365.         return $this;
  1366.     }
  1368.     public function removeProjectAiReport(ProjectAIReports $projectAiReport): self
  1369.     {
  1370.         if ($this->project_ai_reports->removeElement($projectAiReport)) {
  1371.             // set the owning side to null (unless already changed)
  1372.             if ($projectAiReport->getAnalyseBy() === $this) {
  1373.                 $projectAiReport->setAnalyseBy(null);
  1374.             }
  1375.         }
  1377.         return $this;
  1378.     }
  1380.     /**
  1381.      * @return Collection<int, Invoices>
  1382.      */
  1383.     public function getInvoices(): Collection
  1384.     {
  1385.         return $this->invoices;
  1386.     }
  1388.     public function addInvoice(Invoices $invoice): self
  1389.     {
  1390.         if (!$this->invoices->contains($invoice)) {
  1391.             $this->invoices[] = $invoice;
  1392.             $invoice->setAdder($this);
  1393.         }
  1395.         return $this;
  1396.     }
  1398.     public function removeInvoice(Invoices $invoice): self
  1399.     {
  1400.         if ($this->invoices->removeElement($invoice)) {
  1401.             // set the owning side to null (unless already changed)
  1402.             if ($invoice->getAdder() === $this) {
  1403.                 $invoice->setAdder(null);
  1404.             }
  1405.         }
  1407.         return $this;
  1408.     }
  1410.     /**
  1411.      * @return Collection<int, ProjectOrderBillings>
  1412.      */
  1413.     public function getProjectOrderBillings(): Collection
  1414.     {
  1415.         return $this->project_order_billings;
  1416.     }
  1418.     public function addProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
  1419.     {
  1420.         if (!$this->project_order_billings->contains($projectOrderBilling)) {
  1421.             $this->project_order_billings[] = $projectOrderBilling;
  1422.             $projectOrderBilling->setAdder($this);
  1423.         }
  1425.         return $this;
  1426.     }
  1428.     public function removeProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
  1429.     {
  1430.         if ($this->project_order_billings->removeElement($projectOrderBilling)) {
  1431.             // set the owning side to null (unless already changed)
  1432.             if ($projectOrderBilling->getAdder() === $this) {
  1433.                 $projectOrderBilling->setAdder(null);
  1434.             }
  1435.         }
  1437.         return $this;
  1438.     }
  1441. }