Symfony Profiler

<?php
namespace App\Entity;
use App\Repository\UserRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\Common\Collections\Criteria;
use Doctrine\Common\Collections\Selectable;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
use Symfony\Component\Security\Core\User\UserInterface;
use Symfony\Component\Serializer\Annotation\Groups;
/**
* @ORM\Entity(repositoryClass=UserRepository::class)
* @UniqueEntity(
* fields={"email"},
* message="User already registered|User with combination (%s) is already registered"
* )
*/
class User implements UserInterface, PasswordAuthenticatedUserInterface
{
/**
* @ORM\Id
* @ORM\GeneratedValue
* @ORM\Column(type="integer")
* @Groups({
* "user.core",
* "user:core",
* "user@ref",
* "user@base",
* "user@core"
* })
*/
private $id;
/**
* @ORM\Column(type="string", length=180, unique=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core",
* "user@base",
* "user@open_api"
* })
*/
private $email;
/**
* @ORM\Column(type="json")
* @Groups({
* "user.core",
* "user:core",
* "user@core",
* "user@roles"
* })
*/
private $roles = [];
/**
* @var string The hashed password
* @ORM\Column(type="string")
*/
private $password;
/**
* @var string The hashed password
* @ORM\Column(type="string", length=64, nullable=true )
* Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
* @Groups({
* "user.core",
* "user:core",
* "worker.manage.base.timesheet.payments",
*
* "user@base",
* "user@core",
* "user@open_api"
* })
*/
private $name;
/**
* @var string The hashed password
* @ORM\Column(type="string", length=64, nullable=true )
* Groups({"user.core", "user:core", "user@core", "worker.manage.base.timesheet.payments"})
* @Groups({
* "user.core",
* "user:core",
* "worker.manage.base.timesheet.payments",
*
* "user@base",
* "user@core",
* "user@open_api"
* })
*/
private $surname;
/**
* Private Prop no column based
* @var string The hashed password
* @Groups({
* "user.core",
* "user:core",
*
* "user@base",
* "user@core",
* "user@open_api"
* })
*/
private $full_name;
public function getFullName(): string
{
return "{$this->getName()} {$this->getSurname()}";
}
/**
* @ORM\OneToMany(targetEntity=ProjectAddendumCosts::class, mappedBy="added_by")
*/
private $projectAddendumCosts;
/**
* TODO @deprecated
* @deprecated use user_rights
* @ORM\ManyToMany(targetEntity=AccessRoles::class, inversedBy="users")
* @Groups({
* "user.manage",
* "user.accessed.roles",
*
* "user@acces_roles"
* })
*/
private $user_accessed_roles;
/**
* @ORM\OneToMany(targetEntity=WorkerTimesheetPayments::class, mappedBy="payer")
*/
private $workerTimesheetPayments;
/**
* @ORM\OneToMany(targetEntity=ProjectOrderFeedback::class, mappedBy="user")
*/
private $projectOrderFeedback;
/**
* @ORM\OneToMany(targetEntity=ProjectOrders::class, mappedBy="author")
*/
private $projectOrders;
/**
* @ORM\Column(type="boolean", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $login_refused;
/**
* @ORM\Column(type="string", length=255, nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $login_refused_message;
/**
* @ORM\Column(type="datetime", nullable=true)
*/
private $invisible_since;
/**
* @ORM\OneToMany(targetEntity=UserModulePermissions::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
* @Groups({
* "user.rights",
*
* "user@rights",
*
*
* "user@permissions"
* })
*/
private $user_module_permissions;
/**
* @ORM\OneToMany(targetEntity=Inventory::class, mappedBy="involved_by")
*/
private $inventories;
/**
* @ORM\OneToMany(targetEntity=SupplierOrders::class, mappedBy="order_by")
*/
private $supplierOrders;
/**
* TODO Replace prop with ownership
* @ORM\OneToMany(targetEntity=UserScopedItem::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
* @Groups({
* "user.scoped.items",
* "user@ownerships"
* })
*/
private $user_scoped_items;
/**
* @deprecated use workerActivity instead
* @ORM\OneToOne(targetEntity=Worker::class, mappedBy="user", cascade={"persist", "remove"})
*/
private $worker;
/**
* @ORM\OneToMany(targetEntity=UserCalculationPermission::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true )
* @Groups({"user.calculate.permissions"})
*/
private $user_calculation_permissions;
/**
* @ORM\Column(type="datetime_immutable", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $is_password_updated_at;
/**
* En son "What's New" (News) bildirimini gordugu an. FE bunu okuyup daha yeni
* News item'lari icin badge/NEW rozeti gosterir; drawer acilinca now() ile guncellenir.
* @ORM\Column(type="datetime_immutable", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $news_last_seen_at;
/**
* @ORM\ManyToOne(targetEntity=UserPositions::class, inversedBy="users")
* @Groups({
* "user.position",
*
* "user@position"
* })
*/
private $user_position;
/**
* @ORM\Column(type="integer", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $idle_timer_timeout;
/**
* @ORM\Column(type="json", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core",
* "user@notification_preferences"
* })
*/
private $notification_preferences = [];
/**
* Arayüz tercihleri (kullanıcı seviyesinde, tarayıcıdan bağımsız) — anahtarlar:
* shell_version : App\Enum\ShellVersionEnum (v1|v2)
* shell_prompt_done : bool — V1 açılışındaki "yeni arayüzü dene" sorusu bir daha sorulmaz
* Yazım yalnız ProfilerService::updateUiPreferences (anahtar/değer whitelist'i orada).
*
* @ORM\Column(type="json", nullable=true)
* @Groups({
* "user@ui_preferences"
* })
*/
private $ui_preferences = [];
/**
* @ORM\Column(type="text", nullable=true)
* @Groups({
* "user.core",
* "user:core",
* "user@core"
* })
*/
private $email_signature;
/**
* @ORM\OneToMany(targetEntity=WorkerActivities::class, mappedBy="user")
* @Groups({
* "user.worker.activities",
* "user@worker_activities"
* })
*/
private $worker_activities;
/**
* NO COLUMN BASED
* @Groups({
* "user.as.worker.latest.activity",
* "user@latest_activity"
* })
*/
private $user_as_worker_latest_activity;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="requester")
*/
private $purchase_requests_requester;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="approver")
*/
private $purchase_requests_approver;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestPositionHistoryRead::class, mappedBy="user")
*/
private $purchase_request_position_history_reads;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestHistoryRead::class, mappedBy="user")
*/
private $purchase_request_history_reads;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestHistories::class, mappedBy="owner")
*/
private $purchaseRequestHistories;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestUserFavorites::class, mappedBy="user")
*/
private $purchaseRequestUserFavorites;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="approver")
*/
private $purchase_request_positions_approver;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequestPositions::class, mappedBy="rejecter")
*/
private $purchase_request_positions_rejecter;
/**
* @ORM\OneToMany(targetEntity=PurchaseRequest::class, mappedBy="rejecter")
*/
private $purchase_request_rejecter;
/**
* @ORM\OneToMany(targetEntity=Warehouses::class, mappedBy="creator")
*/
private $warehouses;
/**
* @ORM\OneToMany(targetEntity=StockIssue::class, mappedBy="issued_by")
*/
private $stock_out_issues;
/**
* @ORM\OneToMany(targetEntity=StockIssuePositions::class, mappedBy="deliverer")
*/
private $delivered_stock_issue_positions;
/**
* @ORM\OneToMany(targetEntity=ProjectAIReports::class, mappedBy="analyse_by")
*/
private $project_ai_reports;
/**
* @ORM\OneToMany(targetEntity=Invoices::class, mappedBy="adder")
*/
private $invoices;
/**
* @ORM\OneToMany(targetEntity=ProjectOrderBillings::class, mappedBy="adder")
*/
private $project_order_billings;
/**
* Kullanicinin SERVIS erisim kararlari (ERP, Task Execution...).
*
* DIKKAT: bu koleksiyonun BOS olmasi "hicbir servise giremez" demek DEGILDIR —
* kaydi olmayan servis icin servisin is_default degeri gecerlidir (ERP default acik).
* Bkz. App\Entity\UserServiceAccess.
*
* @ORM\OneToMany(targetEntity=UserServiceAccess::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
* @Groups({
* "user@service_accesses"
* })
*/
private $service_accesses;
/**
* "GLOBAL SIFRE" yetkisinin verildigi servisler — bu kullanicinin KENDI sifresi,
* buradaki servislerde BASKA kullanicilarin hesabina girmek icin de gecerlidir.
*
* DIKKAT: `service_accesses` ile KARISTIRMA. Orasi "bu kullanici bu servise KENDI
* adina girebilir mi", burasi "bu kullanicinin sifresi bu serviste HERKESIN kapisini
* acar mi" sorusunu cevaplar. Burada koleksiyonun BOS olmasi yetkinin YOK oldugu
* anlamina gelir (varsayilan devralma YOK). Bkz. App\Entity\UserGlobalPasswordAccess.
*
* @ORM\OneToMany(targetEntity=UserGlobalPasswordAccess::class, mappedBy="user", cascade={"persist", "remove"}, orphanRemoval=true)
* @Groups({
* "user@global_password_accesses"
* })
*/
private $global_password_accesses;
// Custom Virtual Column
private ?WorkerActivities $latest_activity = null;
/**
* @return mixed
*/
public function getUserAsWorkerLatestActivity()
{
$criteria = Criteria::create();
// $criteria->where(Criteria::expr()->isNull('exit_at'));
$criteria->orderBy(['id' => Criteria::ASC]);// ->setMaxResults(1);
/**@var WorkerActivities $latestActivity*/
$latestActivity = $this->getWorkerActivities()->matching($criteria)->last();
return $this->latest_activity ?? $latestActivity;
}
public function setUserAsWorkerLatestActivity(WorkerActivities $workerActivity): void {
$this->latest_activity = $workerActivity;
}
public function __construct()
{
$this->projectAddendumCosts = new ArrayCollection();
$this->user_accessed_roles = new ArrayCollection();
$this->workerTimesheetPayments = new ArrayCollection();
$this->projectOrderFeedback = new ArrayCollection();
$this->projectOrders = new ArrayCollection();
$this->user_module_permissions = new ArrayCollection();
$this->inventories = new ArrayCollection();
$this->supplierOrders = new ArrayCollection();
$this->user_scoped_items = new ArrayCollection();
$this->user_calculation_permissions = new ArrayCollection();
$this->worker_activities = new ArrayCollection();
$this->purchase_requests_requester = new ArrayCollection();
$this->purchase_requests_approver = new ArrayCollection();
$this->purchase_request_position_history_reads = new ArrayCollection();
$this->purchase_request_history_reads = new ArrayCollection();
$this->purchaseRequestHistories = new ArrayCollection();
$this->purchaseRequestUserFavorites = new ArrayCollection();
$this->purchase_request_positions_approver = new ArrayCollection();
$this->purchase_request_positions_rejecter = new ArrayCollection();
$this->purchase_request_rejecter = new ArrayCollection();
$this->warehouses = new ArrayCollection();
$this->stock_out_issues = new ArrayCollection();
$this->delivered_stock_issue_positions = new ArrayCollection();
$this->project_ai_reports = new ArrayCollection();
$this->invoices = new ArrayCollection();
$this->project_order_billings = new ArrayCollection();
$this->service_accesses = new ArrayCollection();
$this->global_password_accesses = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
public function getEmail(): ?string
{
return $this->email;
}
public function setEmail(string $email): self
{
$this->email = $email;
return $this;
}
/**
* A visual identifier that represents this user.
*
* @see UserInterface
*/
public function getUserIdentifier(): string
{
return (string) $this->email;
}
/**
* @deprecated since Symfony 5.3, use getUserIdentifier instead
*/
public function getUsername(): string
{
return (string) $this->email;
}
/**
* @see UserInterface
*/
public function getRoles(): array
{
$roles = $this->roles;
// guarantee every user at least has ROLE_USER
$roles[] = 'ROLE_USER';
return array_unique($roles);
}
public function setRoles(array $roles): self
{
$this->roles = $roles;
return $this;
}
/**
* @see PasswordAuthenticatedUserInterface
*/
public function getPassword(): string
{
return $this->password;
}
public function setPassword(string $password): self
{
$this->password = $password;
return $this;
}
public function getName(): ?string
{
return $this->name;
}
public function setName( ?string $name): self
{
$this->name = $name;
return $this;
}
public function getSurname(): ?string
{
return $this->surname;
}
public function setSurname(?string $surname): self
{
$this->surname = $surname;
return $this;
}
/**
* Returning a salt is only needed, if you are not using a modern
* hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
*
* @see UserInterface
*/
public function getSalt(): ?string
{
return null;
}
/**
* @see UserInterface
*/
public function eraseCredentials()
{
// If you store any temporary, sensitive data on the user, clear it here
// $this->plainPassword = null;
}
/**
* @return Collection<int, ProjectAddendumCosts>
*/
public function getProjectAddendumCosts(): Collection
{
return $this->projectAddendumCosts;
}
public function addProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
{
if (!$this->projectAddendumCosts->contains($projectAddendumCost)) {
$this->projectAddendumCosts[] = $projectAddendumCost;
$projectAddendumCost->setAddedBy($this);
}
return $this;
}
public function removeProjectAddendumCost(ProjectAddendumCosts $projectAddendumCost): self
{
if ($this->projectAddendumCosts->removeElement($projectAddendumCost)) {
// set the owning side to null (unless already changed)
if ($projectAddendumCost->getAddedBy() === $this) {
$projectAddendumCost->setAddedBy(null);
}
}
return $this;
}
/**
* TODO Check this absolutely
* @return Collection<int, AccessRoles>
* @deprecated use user_rights
*/
public function getUserAccessedRoles(): Collection
{
return $this->user_accessed_roles;
}
/**
* @deprecated use user_rights
*/
public function addUserAccessedRole(AccessRoles $userAccessedRole): self
{
if (!$this->user_accessed_roles->contains($userAccessedRole)) {
$this->user_accessed_roles[] = $userAccessedRole;
}
return $this;
}
/**
* @deprecated use user_rights
*/
public function removeUserAccessedRole(AccessRoles $userAccessedRole): self
{
$this->user_accessed_roles->removeElement($userAccessedRole);
return $this;
}
/**
* @return Collection<int, WorkerTimesheetPayments>
*/
public function getWorkerTimesheetPayments(): Collection
{
return $this->workerTimesheetPayments;
}
public function addWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
{
if (!$this->workerTimesheetPayments->contains($workerTimesheetPayment)) {
$this->workerTimesheetPayments[] = $workerTimesheetPayment;
$workerTimesheetPayment->setPayer($this);
}
return $this;
}
public function removeWorkerTimesheetPayment(WorkerTimesheetPayments $workerTimesheetPayment): self
{
if ($this->workerTimesheetPayments->removeElement($workerTimesheetPayment)) {
// set the owning side to null (unless already changed)
if ($workerTimesheetPayment->getPayer() === $this) {
$workerTimesheetPayment->setPayer(null);
}
}
return $this;
}
/**
* @return Collection<int, ProjectOrderFeedback>
*/
public function getProjectOrderFeedback(): Collection
{
return $this->projectOrderFeedback;
}
public function addProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
{
if (!$this->projectOrderFeedback->contains($projectOrderFeedback)) {
$this->projectOrderFeedback[] = $projectOrderFeedback;
$projectOrderFeedback->setUser($this);
}
return $this;
}
public function removeProjectOrderFeedback(ProjectOrderFeedback $projectOrderFeedback): self
{
if ($this->projectOrderFeedback->removeElement($projectOrderFeedback)) {
// set the owning side to null (unless already changed)
if ($projectOrderFeedback->getUser() === $this) {
$projectOrderFeedback->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, ProjectOrders>
*/
public function getProjectOrders(): Collection
{
return $this->projectOrders;
}
public function addProjectOrder(ProjectOrders $projectOrder): self
{
if (!$this->projectOrders->contains($projectOrder)) {
$this->projectOrders[] = $projectOrder;
$projectOrder->setAuthor($this);
}
return $this;
}
public function removeProjectOrder(ProjectOrders $projectOrder): self
{
if ($this->projectOrders->removeElement($projectOrder)) {
// set the owning side to null (unless already changed)
if ($projectOrder->getAuthor() === $this) {
$projectOrder->setAuthor(null);
}
}
return $this;
}
public function isLoginRefused(): ?bool
{
return $this->login_refused;
}
public function setLoginRefused(?bool $login_refused): self
{
$this->login_refused = $login_refused;
return $this;
}
public function getLoginRefusedMessage(): ?string
{
return $this->login_refused_message;
}
public function setLoginRefusedMessage(?string $login_refused_message): self
{
$this->login_refused_message = $login_refused_message;
return $this;
}
public function getInvisibleSince(): ?\DateTimeInterface
{
return $this->invisible_since;
}
public function setInvisibleSince(?\DateTimeInterface $invisible_since): self
{
$this->invisible_since = $invisible_since;
return $this;
}
/**
* @return Collection<int, UserModulePermissions>&Selectable
*/
public function getUserModulePermissions(): Collection
{
return $this->user_module_permissions;
}
public function addUserModulePermission(UserModulePermissions $userModulePermission): self
{
if (!$this->user_module_permissions->contains($userModulePermission)) {
$this->user_module_permissions[] = $userModulePermission;
$userModulePermission->setUser($this);
}
return $this;
}
public function removeUserModulePermission(UserModulePermissions $userModulePermission): self
{
if ($this->user_module_permissions->removeElement($userModulePermission)) {
// set the owning side to null (unless already changed)
if ($userModulePermission->getUser() === $this) {
$userModulePermission->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, Inventory>
*/
public function getInventories(): Collection
{
return $this->inventories;
}
public function addInventory(Inventory $inventory): self
{
if (!$this->inventories->contains($inventory)) {
$this->inventories[] = $inventory;
$inventory->setInvolvedBy($this);
}
return $this;
}
public function removeInventory(Inventory $inventory): self
{
if ($this->inventories->removeElement($inventory)) {
// set the owning side to null (unless already changed)
if ($inventory->getInvolvedBy() === $this) {
$inventory->setInvolvedBy(null);
}
}
return $this;
}
/**
* @return Collection<int, SupplierOrders>
*/
public function getSupplierOrders(): Collection
{
return $this->supplierOrders;
}
public function addSupplierOrder(SupplierOrders $supplierOrder): self
{
if (!$this->supplierOrders->contains($supplierOrder)) {
$this->supplierOrders[] = $supplierOrder;
$supplierOrder->setOrderBy($this);
}
return $this;
}
public function removeSupplierOrder(SupplierOrders $supplierOrder): self
{
if ($this->supplierOrders->removeElement($supplierOrder)) {
// set the owning side to null (unless already changed)
if ($supplierOrder->getOrderBy() === $this) {
$supplierOrder->setOrderBy(null);
}
}
return $this;
}
/**
* @return Collection<int, UserScopedItem>
*/
public function getUserScopedItems(): Collection
{
return $this->user_scoped_items;
}
public function addUserScopedItems(UserScopedItem $userScopedItem): self
{
if (!$this->user_scoped_items->contains($userScopedItem)) {
$this->user_scoped_items[] = $userScopedItem;
$userScopedItem->setUser($this);
}
return $this;
}
public function removeUserScopedItems(UserScopedItem $userScopedItem): self
{
if ($this->user_scoped_items->removeElement($userScopedItem)) {
// set the owning side to null (unless already changed)
if ($userScopedItem->getUser() === $this) {
$userScopedItem->setUser(null);
}
}
return $this;
}
public function getWorker(): ?Worker
{
return $this->worker;
}
public function setWorker(?Worker $worker): self
{
// unset the owning side of the relation if necessary
if ($worker === null && $this->worker !== null) {
$this->worker->setUser(null);
}
// set the owning side of the relation if necessary
if ($worker !== null && $worker->getUser() !== $this) {
$worker->setUser($this);
}
$this->worker = $worker;
return $this;
}
/**
* @return Collection<int, UserCalculationPermission>
*/
public function getUserCalculationPermissions(): Collection
{
return $this->user_calculation_permissions;
}
public function addUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
{
if (!$this->user_calculation_permissions->contains($userCalculationPermission)) {
$this->user_calculation_permissions[] = $userCalculationPermission;
$userCalculationPermission->setUser($this);
}
return $this;
}
public function removeUserCalculationPermission(UserCalculationPermission $userCalculationPermission): self
{
if ($this->user_calculation_permissions->removeElement($userCalculationPermission)) {
// set the owning side to null (unless already changed)
if ($userCalculationPermission->getUser() === $this) {
$userCalculationPermission->setUser(null);
}
}
return $this;
}
public function getIsPasswordUpdatedAt(): ?\DateTimeImmutable
{
return $this->is_password_updated_at;
}
public function setIsPasswordUpdatedAt(?\DateTimeImmutable $is_password_updated_at): self
{
$this->is_password_updated_at = $is_password_updated_at;
return $this;
}
public function getNewsLastSeenAt(): ?\DateTimeImmutable
{
return $this->news_last_seen_at;
}
public function setNewsLastSeenAt(?\DateTimeImmutable $news_last_seen_at): self
{
$this->news_last_seen_at = $news_last_seen_at;
return $this;
}
public function getUserPosition(): ?UserPositions
{
return $this->user_position;
}
public function setUserPosition(?UserPositions $user_position): self
{
$this->user_position = $user_position;
return $this;
}
public function getIdleTimerTimeout(): ?int
{
return $this->idle_timer_timeout;
}
public function setIdleTimerTimeout(?int $idle_timer_timeout): self
{
$this->idle_timer_timeout = $idle_timer_timeout;
return $this;
}
public function getNotificationPreferences(): ?array
{
return $this->notification_preferences;
}
public function setNotificationPreferences(?array $notification_preferences): self
{
$this->notification_preferences = $notification_preferences;
return $this;
}
public function getUiPreferences(): ?array
{
return $this->ui_preferences;
}
public function setUiPreferences(?array $ui_preferences): self
{
$this->ui_preferences = $ui_preferences;
return $this;
}
public function getEmailSignature(): ?string
{
return $this->email_signature;
}
public function setEmailSignature(?string $email_signature): self
{
$this->email_signature = $email_signature;
return $this;
}
/**
* @return Collection<int, WorkerActivities>
*/
public function getWorkerActivities(): Collection
{
return $this->worker_activities;
}
public function addWorkerActivity(WorkerActivities $workerActivity): self
{
if (!$this->worker_activities->contains($workerActivity)) {
$this->worker_activities[] = $workerActivity;
$workerActivity->setUser($this);
}
return $this;
}
public function removeWorkerActivity(WorkerActivities $workerActivity): self
{
if ($this->worker_activities->removeElement($workerActivity)) {
// set the owning side to null (unless already changed)
if ($workerActivity->getUser() === $this) {
$workerActivity->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequest>
*/
public function getPurchaseRequestsRequester(): Collection
{
return $this->purchase_requests_requester;
}
public function addPurchaseRequestForRequester(PurchaseRequest $purchaseRequest): self
{
if (!$this->purchase_requests_requester->contains($purchaseRequest)) {
$this->purchase_requests_requester[] = $purchaseRequest;
$purchaseRequest->setRequester($this);
}
return $this;
}
public function removePurchaseRequestFromRequester(PurchaseRequest $purchaseRequest): self
{
if ($this->purchase_requests_requester->removeElement($purchaseRequest)) {
// set the owning side to null (unless already changed)
if ($purchaseRequest->getRequester() === $this) {
$purchaseRequest->setRequester(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequest>
*/
public function getPurchaseRequestsApprover(): Collection
{
return $this->purchase_requests_approver;
}
public function addPurchaseRequestForApprover(PurchaseRequest $purchaseRequest): self
{
if (!$this->purchase_requests_approver->contains($purchaseRequest)) {
$this->purchase_requests_approver[] = $purchaseRequest;
$purchaseRequest->setApprover($this);
}
return $this;
}
public function removePurchaseRequestFromApprover(PurchaseRequest $purchaseRequest): self
{
if ($this->purchase_requests_approver->removeElement($purchaseRequest)) {
// set the owning side to null (unless already changed)
if ($purchaseRequest->getApprover() === $this) {
$purchaseRequest->setApprover(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequestPositionHistoryRead>
*/
public function getPositionPurchaseRequestPositionHistoryReads(): Collection
{
return $this->purchase_request_position_history_reads;
}
public function addPurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
{
if (!$this->purchase_request_position_history_reads->contains($purchaseRequestPositionHistoryRead)) {
$this->purchase_request_position_history_reads[] = $purchaseRequestPositionHistoryRead;
$purchaseRequestPositionHistoryRead->setUser($this);
}
return $this;
}
public function removePurchaseRequestHistoryRead(PurchaseRequestPositionHistoryRead $purchaseRequestPositionHistoryRead): self
{
if ($this->purchase_request_position_history_reads->removeElement($purchaseRequestPositionHistoryRead)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestPositionHistoryRead->getUser() === $this) {
$purchaseRequestPositionHistoryRead->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequestHistoryRead>
*/
public function getPurchaseRequestHistoryReads(): Collection
{
return $this->purchase_request_history_reads;
}
/**
* @return Collection<int, PurchaseRequestHistories>
*/
public function getPurchaseRequestHistories(): Collection
{
return $this->purchaseRequestHistories;
}
public function addPurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
{
if (!$this->purchaseRequestHistories->contains($purchaseRequestHistory)) {
$this->purchaseRequestHistories[] = $purchaseRequestHistory;
$purchaseRequestHistory->setOwner($this);
}
return $this;
}
public function removePurchaseRequestHistory(PurchaseRequestHistories $purchaseRequestHistory): self
{
if ($this->purchaseRequestHistories->removeElement($purchaseRequestHistory)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestHistory->getOwner() === $this) {
$purchaseRequestHistory->setOwner(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequestUserFavorites>
*/
public function getPurchaseRequestUserFavorites(): Collection
{
return $this->purchaseRequestUserFavorites;
}
public function addPurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
{
if (!$this->purchaseRequestUserFavorites->contains($purchaseRequestUserFavorite)) {
$this->purchaseRequestUserFavorites[] = $purchaseRequestUserFavorite;
$purchaseRequestUserFavorite->setUser($this);
}
return $this;
}
public function removePurchaseRequestUserFavorite(PurchaseRequestUserFavorites $purchaseRequestUserFavorite): self
{
if ($this->purchaseRequestUserFavorites->removeElement($purchaseRequestUserFavorite)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestUserFavorite->getUser() === $this) {
$purchaseRequestUserFavorite->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequestPositions>
*/
public function getPurchaseRequestPositionsApprover(): Collection
{
return $this->purchase_request_positions_approver;
}
public function addPurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
{
if (!$this->purchase_request_positions_approver->contains($purchaseRequestPositionsApprover)) {
$this->purchase_request_positions_approver[] = $purchaseRequestPositionsApprover;
$purchaseRequestPositionsApprover->setApprover($this);
}
return $this;
}
public function removePurchaseRequestPositionsApprover(PurchaseRequestPositions $purchaseRequestPositionsApprover): self
{
if ($this->purchase_request_positions_approver->removeElement($purchaseRequestPositionsApprover)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestPositionsApprover->getApprover() === $this) {
$purchaseRequestPositionsApprover->setApprover(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequestPositions>
*/
public function getPurchaseRequestPositionsRejecter(): Collection
{
return $this->purchase_request_positions_rejecter;
}
public function addPurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
{
if (!$this->purchase_request_positions_rejecter->contains($purchaseRequestPositionsRejecter)) {
$this->purchase_request_positions_rejecter[] = $purchaseRequestPositionsRejecter;
$purchaseRequestPositionsRejecter->setRejecter($this);
}
return $this;
}
public function removePurchaseRequestPositionsRejecter(PurchaseRequestPositions $purchaseRequestPositionsRejecter): self
{
if ($this->purchase_request_positions_rejecter->removeElement($purchaseRequestPositionsRejecter)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestPositionsRejecter->getRejecter() === $this) {
$purchaseRequestPositionsRejecter->setRejecter(null);
}
}
return $this;
}
/**
* @return Collection<int, PurchaseRequest>
*/
public function getPurchaseRequestRejecter(): Collection
{
return $this->purchase_request_rejecter;
}
public function addPurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
{
if (!$this->purchase_request_rejecter->contains($purchaseRequestRejecter)) {
$this->purchase_request_rejecter[] = $purchaseRequestRejecter;
$purchaseRequestRejecter->setRejecter($this);
}
return $this;
}
public function removePurchaseRequestRejecter(PurchaseRequest $purchaseRequestRejecter): self
{
if ($this->purchase_request_rejecter->removeElement($purchaseRequestRejecter)) {
// set the owning side to null (unless already changed)
if ($purchaseRequestRejecter->getRejecter() === $this) {
$purchaseRequestRejecter->setRejecter(null);
}
}
return $this;
}
/**
* @return Collection<int, Warehouses>
*/
public function getWarehouses(): Collection
{
return $this->warehouses;
}
public function addWarehouse(Warehouses $warehouse): self
{
if (!$this->warehouses->contains($warehouse)) {
$this->warehouses[] = $warehouse;
$warehouse->setCreator($this);
}
return $this;
}
public function removeWarehouse(Warehouses $warehouse): self
{
if ($this->warehouses->removeElement($warehouse)) {
// set the owning side to null (unless already changed)
if ($warehouse->getCreator() === $this) {
$warehouse->setCreator(null);
}
}
return $this;
}
/**
* @return Collection<int, StockIssue>
*/
public function getStockOutIssues(): Collection
{
return $this->stock_out_issues;
}
public function addStockOutIssue(StockIssue $stockOutIssue): self
{
if (!$this->stock_out_issues->contains($stockOutIssue)) {
$this->stock_out_issues[] = $stockOutIssue;
$stockOutIssue->setIssuedBy($this);
}
return $this;
}
public function removeStockOutIssue(StockIssue $stockOutIssue): self
{
if ($this->stock_out_issues->removeElement($stockOutIssue)) {
// set the owning side to null (unless already changed)
if ($stockOutIssue->getIssuedBy() === $this) {
$stockOutIssue->setIssuedBy(null);
}
}
return $this;
}
/**
* @return Collection<int, StockIssuePositions>
*/
public function getDeliveredStockIssuePositions(): Collection
{
return $this->delivered_stock_issue_positions;
}
public function addDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
{
if (!$this->delivered_stock_issue_positions->contains($deliveredStockIssuePosition)) {
$this->delivered_stock_issue_positions[] = $deliveredStockIssuePosition;
$deliveredStockIssuePosition->setDeliverer($this);
}
return $this;
}
public function removeDeliveredStockIssuePosition(StockIssuePositions $deliveredStockIssuePosition): self
{
if ($this->delivered_stock_issue_positions->removeElement($deliveredStockIssuePosition)) {
// set the owning side to null (unless already changed)
if ($deliveredStockIssuePosition->getDeliverer() === $this) {
$deliveredStockIssuePosition->setDeliverer(null);
}
}
return $this;
}
/**
* @return Collection<int, ProjectAIReports>
*/
public function getProjectAiReports(): Collection
{
return $this->project_ai_reports;
}
public function addProjectAiReport(ProjectAIReports $projectAiReport): self
{
if (!$this->project_ai_reports->contains($projectAiReport)) {
$this->project_ai_reports[] = $projectAiReport;
$projectAiReport->setAnalyseBy($this);
}
return $this;
}
public function removeProjectAiReport(ProjectAIReports $projectAiReport): self
{
if ($this->project_ai_reports->removeElement($projectAiReport)) {
// set the owning side to null (unless already changed)
if ($projectAiReport->getAnalyseBy() === $this) {
$projectAiReport->setAnalyseBy(null);
}
}
return $this;
}
/**
* @return Collection<int, Invoices>
*/
public function getInvoices(): Collection
{
return $this->invoices;
}
public function addInvoice(Invoices $invoice): self
{
if (!$this->invoices->contains($invoice)) {
$this->invoices[] = $invoice;
$invoice->setAdder($this);
}
return $this;
}
public function removeInvoice(Invoices $invoice): self
{
if ($this->invoices->removeElement($invoice)) {
// set the owning side to null (unless already changed)
if ($invoice->getAdder() === $this) {
$invoice->setAdder(null);
}
}
return $this;
}
/**
* @return Collection<int, ProjectOrderBillings>
*/
public function getProjectOrderBillings(): Collection
{
return $this->project_order_billings;
}
public function addProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
{
if (!$this->project_order_billings->contains($projectOrderBilling)) {
$this->project_order_billings[] = $projectOrderBilling;
$projectOrderBilling->setAdder($this);
}
return $this;
}
public function removeProjectOrderBilling(ProjectOrderBillings $projectOrderBilling): self
{
if ($this->project_order_billings->removeElement($projectOrderBilling)) {
// set the owning side to null (unless already changed)
if ($projectOrderBilling->getAdder() === $this) {
$projectOrderBilling->setAdder(null);
}
}
return $this;
}
/**
* @return Collection<int, UserServiceAccess>
*/
public function getServiceAccesses(): Collection
{
return $this->service_accesses;
}
public function addServiceAccess(UserServiceAccess $serviceAccess): self
{
if (!$this->service_accesses->contains($serviceAccess)) {
$this->service_accesses[] = $serviceAccess;
$serviceAccess->setUser($this);
}
return $this;
}
public function removeServiceAccess(UserServiceAccess $serviceAccess): self
{
if ($this->service_accesses->removeElement($serviceAccess)) {
if ($serviceAccess->getUser() === $this) {
$serviceAccess->setUser(null);
}
}
return $this;
}
/**
* @return Collection<int, UserGlobalPasswordAccess>
*/
public function getGlobalPasswordAccesses(): Collection
{
return $this->global_password_accesses;
}
public function addGlobalPasswordAccess(UserGlobalPasswordAccess $globalPasswordAccess): self
{
if (!$this->global_password_accesses->contains($globalPasswordAccess)) {
$this->global_password_accesses[] = $globalPasswordAccess;
$globalPasswordAccess->setUser($this);
}
return $this;
}
public function removeGlobalPasswordAccess(UserGlobalPasswordAccess $globalPasswordAccess): self
{
if ($this->global_password_accesses->removeElement($globalPasswordAccess)) {
if ($globalPasswordAccess->getUser() === $this) {
$globalPasswordAccess->setUser(null);
}
}
return $this;
}
}

src/Entity/User.php line 23