src/Entity/AppUser.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\Dispatch\Dispatch;
  6. use App\Entity\Documentation\CargoManifest;
  7. use App\Entity\Documentation\Document;
  8. use App\Entity\Documentation\ShippingCargoManifest;
  9. use App\Entity\Documentation\MasterGuide;
  10. use App\Entity\Documentation\ShippingPackingList;
  11. use App\Entity\Expedient\Log;
  12. use App\Entity\Quote\Quote;
  13. use App\Repository\AppUserRepository;
  14. use Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  20. /**
  21.  * @ORM\Entity(repositoryClass=AppUserRepository::class)
  22.  */
  23. class AppUser implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     /**
  26.      * @ORM\Id
  27.      * @ORM\GeneratedValue
  28.      * @ORM\Column(type="integer")
  29.      */
  30.     private $id;
  32.     /**
  33.      * @ORM\Column(type="string", length=180, unique=true)
  34.      */
  35.     private $username;
  37.     /**
  38.      * @ORM\Column(type="json")
  39.      */
  40.     private $roles = [];
  42.     /**
  43.      * @var string The hashed password
  44.      * @ORM\Column(type="string")
  45.      */
  46.     private $password;
  48.     /**
  49.      * @ORM\ManyToOne(targetEntity=CurrencyChange::class, inversedBy="users")
  50.      */
  51.     private $currency;
  53.     /**
  54.      * @ORM\Column(type="string", length=1024)
  55.      */
  56.     private $fullName;
  58.     /**
  59.      * @ORM\OneToMany(targetEntity=Log::class, mappedBy="generatedBy")
  60.      */
  61.     private $logs;
  63.     /**
  64.      * @ORM\OneToMany(targetEntity=Dispatch::class, mappedBy="createdBy")
  65.      */
  66.     private $dispatches;
  68.     /**
  69.      * @ORM\OneToMany(targetEntity=MasterGuide::class, mappedBy="generatedBy")
  70.      */
  71.     private $masterGuides;
  73.     /**
  74.      * @ORM\OneToMany(targetEntity=CargoManifest::class, mappedBy="generatedBy")
  75.      */
  76.     private $cargoManifests;
  78.     /**
  79.      * @ORM\OneToMany(targetEntity=Document::class, mappedBy="generatedBy")
  80.      */
  81.     private $documents;
  83.     /**
  84.      * @ORM\OneToMany(targetEntity=ShippingCargoManifest::class, mappedBy="generatedBy")
  85.      */
  86.     private $shippingCargoManifests;
  88.     /**
  89.      * @ORM\OneToMany(targetEntity=ShippingPackingList::class, mappedBy="generatedBy")
  90.      */
  91.     private $shippingPackingLists;
  93.     /**
  94.      * @ORM\OneToMany(targetEntity=\App\Entity\Dispatch\Log::class, mappedBy="createdBy")
  95.      */
  96.     private $dispatchLogs;
  98.     /**
  99.      * @ORM\OneToMany(targetEntity=Shipping::class, mappedBy="createdBy")
  100.      */
  101.     private $shippings;
  103.     /**
  104.      * @ORM\OneToMany(targetEntity=Quote::class, mappedBy="createdBy")
  105.      */
  106.     private $quotes;
  108.     /**
  109.      * @ORM\OneToMany(targetEntity=\App\Entity\Quote\Log::class, mappedBy="createdBy")
  110.      */
  111.     private $quoteLogs;
  114.     public function __construct()
  115.     {
  116.         $this->logs = new ArrayCollection();
  117.         $this->dispatches = new ArrayCollection();
  118.         $this->masterGuides = new ArrayCollection();
  119.         $this->cargoManifests = new ArrayCollection();
  120.         $this->documents = new ArrayCollection();
  121.         $this->shippingCargoManifests = new ArrayCollection();
  122.         $this->shippingPackingLists = new ArrayCollection();
  123.         $this->dispatchLogs = new ArrayCollection();
  124.         $this->shippings = new ArrayCollection();
  125.         $this->quotes = new ArrayCollection();
  126.         $this->quoteLogs = new ArrayCollection();
  127.     }
  129.     public function getId(): ?int
  130.     {
  131.         return $this->id;
  132.     }
  134.     /**
  135.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  136.      */
  137.     public function getUsername(): string
  138.     {
  139.         return (string)$this->username;
  140.     }
  142.     public function setUsername(string $username): self
  143.     {
  144.         $this->username = $username;
  146.         return $this;
  147.     }
  149.     /**
  150.      * A visual identifier that represents this user.
  151.      *
  152.      * @see UserInterface
  153.      */
  154.     public function getUserIdentifier(): string
  155.     {
  156.         return (string)$this->username;
  157.     }
  159.     /**
  160.      * @see UserInterface
  161.      */
  162.     public function getRoles(): array
  163.     {
  164.         $roles = $this->roles;
  165.         // guarantee every user at least has ROLE_USER
  166.         $roles[] = 'ROLE_ADMIN';
  168.         return array_unique($roles);
  169.     }
  171.     public function setRoles(array $roles): self
  172.     {
  173.         $this->roles = $roles;
  175.         return $this;
  176.     }
  178.     /**
  179.      * @see PasswordAuthenticatedUserInterface
  180.      */
  181.     public function getPassword(): string
  182.     {
  183.         return $this->password;
  184.     }
  186.     public function setPassword(string $password): self
  187.     {
  188.         $this->password = $password;
  190.         return $this;
  191.     }
  193.     /**
  194.      * Returning a salt is only needed, if you are not using a modern
  195.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  196.      *
  197.      * @see UserInterface
  198.      */
  199.     public function getSalt(): ?string
  200.     {
  201.         return null;
  202.     }
  204.     /**
  205.      * @see UserInterface
  206.      */
  207.     public function eraseCredentials()
  208.     {
  209.         // If you store any temporary, sensitive data on the user, clear it here
  210.         // $this->plainPassword = null;
  211.     }
  213.     public function getCurrency(): ?CurrencyChange
  214.     {
  215.         return $this->currency;
  216.     }
  218.     public function setCurrency(?CurrencyChange $currency): self
  219.     {
  220.         $this->currency = $currency;
  222.         return $this;
  223.     }
  225.     public function getFullName(): ?string
  226.     {
  227.         return $this->fullName;
  228.     }
  230.     public function setFullName(string $fullName): self
  231.     {
  232.         $this->fullName = $fullName;
  234.         return $this;
  235.     }
  237.     /**
  238.      * @return Collection<int, Log>
  239.      */
  240.     public function getLogs(): Collection
  241.     {
  242.         return $this->logs;
  243.     }
  245.     public function addLog(Log $log): self
  246.     {
  247.         if (!$this->logs->contains($log)) {
  248.             $this->logs[] = $log;
  249.             $log->setGeneratedBy($this);
  250.         }
  252.         return $this;
  253.     }
  255.     public function removeLog(Log $log): self
  256.     {
  257.         if ($this->logs->removeElement($log)) {
  258.             // set the owning side to null (unless already changed)
  259.             if ($log->getGeneratedBy() === $this) {
  260.                 $log->setGeneratedBy(null);
  261.             }
  262.         }
  264.         return $this;
  265.     }
  267.     /**
  268.      * @return Collection<int, Dispatch>
  269.      */
  270.     public function getDispatches(): Collection
  271.     {
  272.         return $this->dispatches;
  273.     }
  275.     public function addDispatch(Dispatch $dispatch): self
  276.     {
  277.         if (!$this->dispatches->contains($dispatch)) {
  278.             $this->dispatches[] = $dispatch;
  279.             $dispatch->setCreatedBy($this);
  280.         }
  282.         return $this;
  283.     }
  285.     public function removeDispatch(Dispatch $dispatch): self
  286.     {
  287.         if ($this->dispatches->removeElement($dispatch)) {
  288.             // set the owning side to null (unless already changed)
  289.             if ($dispatch->getCreatedBy() === $this) {
  290.                 $dispatch->setCreatedBy(null);
  291.             }
  292.         }
  294.         return $this;
  295.     }
  297.     /**
  298.      * @return Collection<int, MasterGuide>
  299.      */
  300.     public function getMasterGuides(): Collection
  301.     {
  302.         return $this->masterGuides;
  303.     }
  305.     public function addMasterGuide(MasterGuide $masterGuide): self
  306.     {
  307.         if (!$this->masterGuides->contains($masterGuide)) {
  308.             $this->masterGuides[] = $masterGuide;
  309.             $masterGuide->setGeneratedBy($this);
  310.         }
  312.         return $this;
  313.     }
  315.     public function removeMasterGuide(MasterGuide $masterGuide): self
  316.     {
  317.         if ($this->masterGuides->removeElement($masterGuide)) {
  318.             // set the owning side to null (unless already changed)
  319.             if ($masterGuide->getGeneratedBy() === $this) {
  320.                 $masterGuide->setGeneratedBy(null);
  321.             }
  322.         }
  324.         return $this;
  325.     }
  327.     /**
  328.      * @return Collection<int, CargoManifest>
  329.      */
  330.     public function getCargoManifests(): Collection
  331.     {
  332.         return $this->cargoManifests;
  333.     }
  335.     public function addCargoManifest(CargoManifest $cargoManifest): self
  336.     {
  337.         if (!$this->cargoManifests->contains($cargoManifest)) {
  338.             $this->cargoManifests[] = $cargoManifest;
  339.             $cargoManifest->setGeneratedBy($this);
  340.         }
  342.         return $this;
  343.     }
  345.     public function removeCargoManifest(CargoManifest $cargoManifest): self
  346.     {
  347.         if ($this->cargoManifests->removeElement($cargoManifest)) {
  348.             // set the owning side to null (unless already changed)
  349.             if ($cargoManifest->getGeneratedBy() === $this) {
  350.                 $cargoManifest->setGeneratedBy(null);
  351.             }
  352.         }
  354.         return $this;
  355.     }
  357.     /**
  358.      * @return Collection<int, Document>
  359.      */
  360.     public function getDocuments(): Collection
  361.     {
  362.         return $this->documents;
  363.     }
  365.     public function addDocument(Document $document): self
  366.     {
  367.         if (!$this->documents->contains($document)) {
  368.             $this->documents[] = $document;
  369.             $document->setGeneratedBy($this);
  370.         }
  372.         return $this;
  373.     }
  375.     public function removeDocument(Document $document): self
  376.     {
  377.         if ($this->documents->removeElement($document)) {
  378.             // set the owning side to null (unless already changed)
  379.             if ($document->getGeneratedBy() === $this) {
  380.                 $document->setGeneratedBy(null);
  381.             }
  382.         }
  384.         return $this;
  385.     }
  387.     /**
  388.      * @return Collection<int, ShippingCargoManifest>
  389.      */
  390.     public function getShippingCargoManifests(): Collection
  391.     {
  392.         return $this->shippingCargoManifests;
  393.     }
  395.     public function addShippingCargoManifest(ShippingCargoManifest $shippingCargoManifest): self
  396.     {
  397.         if (!$this->shippingCargoManifests->contains($shippingCargoManifest)) {
  398.             $this->shippingCargoManifests[] = $shippingCargoManifest;
  399.             $shippingCargoManifest->setGeneratedBy($this);
  400.         }
  402.         return $this;
  403.     }
  405.     public function removeShippingCargoManifest(ShippingCargoManifest $shippingCargoManifest): self
  406.     {
  407.         if ($this->shippingCargoManifests->removeElement($shippingCargoManifest)) {
  408.             // set the owning side to null (unless already changed)
  409.             if ($shippingCargoManifest->getGeneratedBy() === $this) {
  410.                 $shippingCargoManifest->setGeneratedBy(null);
  411.             }
  412.         }
  414.         return $this;
  415.     }
  417.     /**
  418.      * @return Collection<int, ShippingPackingList>
  419.      */
  420.     public function getShippingPackingLists(): Collection
  421.     {
  422.         return $this->shippingPackingLists;
  423.     }
  425.     public function addShippingPackingList(ShippingPackingList $shippingPackingList): self
  426.     {
  427.         if (!$this->shippingPackingLists->contains($shippingPackingList)) {
  428.             $this->shippingPackingLists[] = $shippingPackingList;
  429.             $shippingPackingList->setGeneratedBy($this);
  430.         }
  432.         return $this;
  433.     }
  435.     public function removeShippingPackingList(ShippingPackingList $shippingPackingList): self
  436.     {
  437.         if ($this->shippingPackingLists->removeElement($shippingPackingList)) {
  438.             // set the owning side to null (unless already changed)
  439.             if ($shippingPackingList->getGeneratedBy() === $this) {
  440.                 $shippingPackingList->setGeneratedBy(null);
  441.             }
  442.         }
  444.         return $this;
  445.     }
  447.     public function __toString()
  448.     {
  449.         return $this->fullName;
  450.     }
  452.     /**
  453.      * @return Collection<int, \App\Entity\Dispatch\Log>
  454.      */
  455.     public function getDispatchLogs(): Collection
  456.     {
  457.         return $this->dispatchLogs;
  458.     }
  460.     public function addDispatchLog(\App\Entity\Dispatch\Log $dispatchLog): self
  461.     {
  462.         if (!$this->dispatchLogs->contains($dispatchLog)) {
  463.             $this->dispatchLogs[] = $dispatchLog;
  464.             $dispatchLog->setCreatedBy($this);
  465.         }
  467.         return $this;
  468.     }
  470.     public function removeDispatchLog(\App\Entity\Dispatch\Log $dispatchLog): self
  471.     {
  472.         if ($this->dispatchLogs->removeElement($dispatchLog)) {
  473.             // set the owning side to null (unless already changed)
  474.             if ($dispatchLog->getCreatedBy() === $this) {
  475.                 $dispatchLog->setCreatedBy(null);
  476.             }
  477.         }
  479.         return $this;
  480.     }
  482.     /**
  483.      * @return Collection<int, Shipping>
  484.      */
  485.     public function getShippings(): Collection
  486.     {
  487.         return $this->shippings;
  488.     }
  490.     public function addShipping(Shipping $shipping): self
  491.     {
  492.         if (!$this->shippings->contains($shipping)) {
  493.             $this->shippings[] = $shipping;
  494.             $shipping->setCreatedBy($this);
  495.         }
  497.         return $this;
  498.     }
  500.     public function removeShipping(Shipping $shipping): self
  501.     {
  502.         if ($this->shippings->removeElement($shipping)) {
  503.             // set the owning side to null (unless already changed)
  504.             if ($shipping->getCreatedBy() === $this) {
  505.                 $shipping->setCreatedBy(null);
  506.             }
  507.         }
  509.         return $this;
  510.     }
  512.     /**
  513.      * @return Collection<int, Quote>
  514.      */
  515.     public function getQuotes(): Collection
  516.     {
  517.         return $this->quotes;
  518.     }
  520.     public function addQuote(Quote $quote): self
  521.     {
  522.         if (!$this->quotes->contains($quote)) {
  523.             $this->quotes[] = $quote;
  524.             $quote->setCreatedBy($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeQuote(Quote $quote): self
  531.     {
  532.         if ($this->quotes->removeElement($quote)) {
  533.             // set the owning side to null (unless already changed)
  534.             if ($quote->getCreatedBy() === $this) {
  535.                 $quote->setCreatedBy(null);
  536.             }
  537.         }
  539.         return $this;
  540.     }
  542.     /**
  543.      * @return Collection<int, \App\Entity\Quote\Log>
  544.      */
  545.     public function getQuoteLogs(): Collection
  546.     {
  547.         return $this->quoteLogs;
  548.     }
  550.     public function addQuoteLog(\App\Entity\Quote\Log $quoteLog): self
  551.     {
  552.         if (!$this->quoteLogs->contains($quoteLog)) {
  553.             $this->quoteLogs[] = $quoteLog;
  554.             $quoteLog->setCreatedBy($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeQuoteLog(\App\Entity\Quote\Log $quoteLog): self
  561.     {
  562.         if ($this->quoteLogs->removeElement($quoteLog)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($quoteLog->getCreatedBy() === $this) {
  565.                 $quoteLog->setCreatedBy(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  573. }