src/Entity/User.php line 16

  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\DBAL\Types\Types;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[UniqueEntity(fields: ['email'], message: 'There is already an account with this email')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column(type: 'integer')]
  21.     private $id;
  23.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  24.     private ?string $email;
  26.     #[ORM\Column(type: 'json')]
  27.     private array $roles = [];
  29.     #[ORM\Column(type: 'string')]
  30.     private string $password;
  32.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InventoryEquipment::class, orphanRemoval: true)]
  33.     private Collection $inventoryEquipment;
  35.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InventoryCatchable::class, orphanRemoval: true)]
  36.     private Collection $inventoryCatchables;
  38.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  39.     private ?string $gameToken;
  41.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserGear::class)]
  42.     private Collection $userGears;
  44.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  45.     private ?string $wallet;
  47.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserRecord::class, orphanRemoval: true)]
  48.     private Collection $userRecords;
  50.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  51.     private ?string $googleId;
  53.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: InventoryMaterial::class, orphanRemoval: true)]
  54.     private Collection $inventoryMaterials;
  56. //    #[ORM\OneToOne(mappedBy: 'user', targetEntity: NftQueue::class, cascade: ['persist', 'remove'])]
  57. //    private ?NftQueue $nftQueue;
  59.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: SalvageQueue::class, orphanRemoval: true)]
  60.     private Collection $salvageQueues;
  62.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  63.     private ?string $username;
  65.     #[ORM\Column(type: 'integer', nullable: true)]
  66.     private ?int $walletExtension;
  68.     #[ORM\Column(type: 'json', nullable: true)]
  69.     private array|null $config = [];
  71.     #[ORM\OneToOne(inversedBy: 'user', targetEntity: ThetaWallet::class, cascade: ['persist', 'remove'])]
  72.     private ?ThetaWallet $activeWallet;
  74.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  75.     private ?\DateTimeInterface $lastRecipeHint = null;
  77.     #[ORM\OneToOne(inversedBy: 'user', cascade: ['persist', 'remove'])]
  78.     private ?CatchableQueue $catchableQueue = null;
  80.     #[ORM\Column(type: Types::DECIMAL, precision: 12, scale: '0', nullable: true)]
  81.     private ?string $experience = '0';
  83.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  84.     private ?\DateTimeInterface $shadowBanUntil = null;
  86.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: ShopItemPurchases::class, orphanRemoval: true)]
  87.     private Collection $shopItemPurchases;
  89.     #[ORM\Column(nullable: true)]
  90.     private ?int $shinies = 0;
  92.     #[ORM\ManyToMany(targetEntity: Recipe::class, inversedBy: 'users', cascade: ['persist'])]
  93.     private Collection $unlockedRecipes;
  95.     #[ORM\Column(length: 255, nullable: true)]
  96.     private ?string $gameToken2 = null;
  98.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
  99.     private ?ActProgression $actProgression = null;
  101.     #[ORM\OneToOne(cascade: ['persist', 'remove'])]
  102.     private ?ThetaWallet $thetaDropWallet = null;
  104.     public function __construct()
  105.     {
  106.         $this->userGears = new ArrayCollection();
  107.         $this->inventoryEquipment = new ArrayCollection();
  108.         $this->inventoryCatchables = new ArrayCollection();
  109.         $this->userGears = new ArrayCollection();
  110.         $this->userRecords = new ArrayCollection();
  111.         $this->inventoryMaterials = new ArrayCollection();
  112.         $this->salvageQueues = new ArrayCollection();
  113.         $this->shopItemPurchases = new ArrayCollection();
  114.         $this->unlockedRecipes = new ArrayCollection();
  115.     }
  117.     public function getId(): ?int
  118.     {
  119.         return $this->id;
  120.     }
  122.     public function getEmail(): ?string
  123.     {
  124.         return $this->email;
  125.     }
  127.     public function setEmail(string $email): self
  128.     {
  129.         $this->email = $email;
  131.         return $this;
  132.     }
  134.     /**
  135.      * A visual identifier that represents this user.
  136.      *
  137.      * @see UserInterface
  138.      */
  139.     public function getUserIdentifier(): string
  140.     {
  141.         return (string) $this->email;
  142.     }
  144.     /**
  145.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  146.      */
  147.     public function getUsername(): string
  148.     {
  149.         return (string) $this->username;
  150.     }
  152.     /**
  153.      * @see UserInterface
  154.      */
  155.     public function getRoles(): array
  156.     {
  157.         $roles = $this->roles;
  158.         // guarantee every user at least has ROLE_USER
  159.         $roles[] = 'ROLE_USER';
  161.         return array_unique($roles);
  162.     }
  164.     public function setRoles(array $roles): self
  165.     {
  166.         $this->roles = $roles;
  168.         return $this;
  169.     }
  171.     /**
  172.      * @see PasswordAuthenticatedUserInterface
  173.      */
  174.     public function getPassword(): string
  175.     {
  176.         return $this->password;
  177.     }
  179.     public function setPassword(string $password): self
  180.     {
  181.         $this->password = $password;
  183.         return $this;
  184.     }
  186.     /**
  187.      * Returning a salt is only needed, if you are not using a modern
  188.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  189.      *
  190.      * @see UserInterface
  191.      */
  192.     public function getSalt(): ?string
  193.     {
  194.         return null;
  195.     }
  197.     /**
  198.      * @see UserInterface
  199.      */
  200.     public function eraseCredentials()
  201.     {
  202.         // If you store any temporary, sensitive data on the user, clear it here
  203.         // $this->plainPassword = null;
  204.     }
  206.     /**
  207.      * @return Collection|InventoryEquipment[]
  208.      */
  209.     public function getInventoryEquipment(): Collection
  210.     {
  211.         return $this->inventoryEquipment;
  212.     }
  214.     public function addInventoryEquipment(InventoryEquipment $inventoryEquipment): self
  215.     {
  216.         if (!$this->inventoryEquipment->contains($inventoryEquipment)) {
  217.             $this->inventoryEquipment[] = $inventoryEquipment;
  218.             $inventoryEquipment->setUser($this);
  219.         }
  221.         return $this;
  222.     }
  224.     public function removeInventoryEquipment(InventoryEquipment $inventoryEquipment): self
  225.     {
  226.         if ($this->inventoryEquipment->removeElement($inventoryEquipment)) {
  227.             // set the owning side to null (unless already changed)
  228.             if ($inventoryEquipment->getUser() === $this) {
  229.                 $inventoryEquipment->setUser(null);
  230.             }
  231.         }
  233.         return $this;
  234.     }
  236.     /**
  237.      * @return Collection|InventoryCatchable[]
  238.      */
  239.     public function getInventoryCatchables(): Collection
  240.     {
  241.         return $this->inventoryCatchables;
  242.     }
  244.     public function addInventoryCatchable(InventoryCatchable $inventoryCatchable): self
  245.     {
  246.         if (!$this->inventoryCatchables->contains($inventoryCatchable)) {
  247.             $this->inventoryCatchables[] = $inventoryCatchable;
  248.             $inventoryCatchable->setUser($this);
  249.         }
  251.         return $this;
  252.     }
  254.     public function removeInventoryCatchable(InventoryCatchable $inventoryCatchable): self
  255.     {
  256.         if ($this->inventoryCatchables->removeElement($inventoryCatchable)) {
  257.             // set the owning side to null (unless already changed)
  258.             if ($inventoryCatchable->getUser() === $this) {
  259.                 $inventoryCatchable->setUser(null);
  260.             }
  261.         }
  263.         return $this;
  264.     }
  266.     public function getGameToken(): ?string
  267.     {
  268.         return $this->gameToken;
  269.     }
  271.     public function setGameToken(?string $gameToken): self
  272.     {
  273.         $this->gameToken = $gameToken;
  275.         return $this;
  276.     }
  278.     /**
  279.      * @return Collection|UserGear[]
  280.      */
  281.     public function getUserGears(): Collection
  282.     {
  283.         return $this->userGears;
  284.     }
  286.     public function addUserGear(UserGear $userGear): self
  287.     {
  288.         if (!$this->userGears->contains($userGear)) {
  289.             $this->userGears[] = $userGear;
  290.             $userGear->setUser($this);
  291.         }
  293.         return $this;
  294.     }
  296.     public function removeUserGear(UserGear $userGear): self
  297.     {
  298.         if ($this->userGears->removeElement($userGear)) {
  299.             // set the owning side to null (unless already changed)
  300.             if ($userGear->getUser() === $this) {
  301.                 $userGear->setUser(null);
  302.             }
  303.         }
  305.         return $this;
  306.     }
  308.     public function getWallet(): ?string
  309.     {
  310.         return $this->wallet;
  311.     }
  313.     public function setWallet(?string $wallet): self
  314.     {
  315.         $this->wallet = $wallet;
  317.         return $this;
  318.     }
  320.     /**
  321.      * @return Collection|UserRecord[]
  322.      */
  323.     public function getUserRecords(): Collection
  324.     {
  325.         return $this->userRecords;
  326.     }
  328.     public function addUserRecord(UserRecord $userRecord): self
  329.     {
  330.         if (!$this->userRecords->contains($userRecord)) {
  331.             $this->userRecords[] = $userRecord;
  332.             $userRecord->setUser($this);
  333.         }
  335.         return $this;
  336.     }
  338.     public function removeUserRecord(UserRecord $userRecord): self
  339.     {
  340.         if ($this->userRecords->removeElement($userRecord)) {
  341.             // set the owning side to null (unless already changed)
  342.             if ($userRecord->getUser() === $this) {
  343.                 $userRecord->setUser(null);
  344.             }
  345.         }
  347.         return $this;
  348.     }
  350.     public function getGoogleId(): ?string
  351.     {
  352.         return $this->googleId;
  353.     }
  355.     public function setGoogleId(?string $googleId): self
  356.     {
  357.         $this->googleId = $googleId;
  359.         return $this;
  360.     }
  362.     /**
  363.      * @return Collection|InventoryMaterial[]
  364.      */
  365.     public function getInventoryMaterials(): Collection
  366.     {
  367.         return $this->inventoryMaterials;
  368.     }
  370.     public function addInventoryMaterial(InventoryMaterial $inventoryMaterial): self
  371.     {
  372.         if (!$this->inventoryMaterials->contains($inventoryMaterial)) {
  373.             $this->inventoryMaterials[] = $inventoryMaterial;
  374.             $inventoryMaterial->setUser($this);
  375.         }
  377.         return $this;
  378.     }
  380.     public function removeInventoryMaterial(InventoryMaterial $inventoryMaterial): self
  381.     {
  382.         if ($this->inventoryMaterials->removeElement($inventoryMaterial)) {
  383.             // set the owning side to null (unless already changed)
  384.             if ($inventoryMaterial->getUser() === $this) {
  385.                 $inventoryMaterial->setUser(null);
  386.             }
  387.         }
  389.         return $this;
  390.     }
  392. //    public function getNftQueue(): ?NftQueue
  393. //    {
  394. //        return $this->nftQueue;
  395. //    }
  396. //
  397. //    public function setNftQueue(NftQueue $nftQueue): self
  398. //    {
  399. //        // set the owning side of the relation if necessary
  400. //        if ($nftQueue->getUser() !== $this) {
  401. //            $nftQueue->setUser($this);
  402. //        }
  403. //
  404. //        $this->nftQueue = $nftQueue;
  405. //
  406. //        return $this;
  407. //    }
  409.     /**
  410.      * @return Collection|SalvageQueue[]
  411.      */
  412.     public function getSalvageQueues(): Collection
  413.     {
  414.         return $this->salvageQueues;
  415.     }
  417.     public function addSalvageQueue(SalvageQueue $salvageQueue): self
  418.     {
  419.         if (!$this->salvageQueues->contains($salvageQueue)) {
  420.             $this->salvageQueues[] = $salvageQueue;
  421.             $salvageQueue->setUser($this);
  422.         }
  424.         return $this;
  425.     }
  427.     public function removeSalvageQueue(SalvageQueue $salvageQueue): self
  428.     {
  429.         if ($this->salvageQueues->removeElement($salvageQueue)) {
  430.             // set the owning side to null (unless already changed)
  431.             if ($salvageQueue->getUser() === $this) {
  432.                 $salvageQueue->setUser(null);
  433.             }
  434.         }
  436.         return $this;
  437.     }
  439.     public function setUsername(?string $username): self
  440.     {
  441.         $this->username = $username;
  443.         return $this;
  444.     }
  446.     public function getWalletExtension(): ?int
  447.     {
  448.         return $this->walletExtension;
  449.     }
  451.     public function setWalletExtension(?int $walletExtension): self
  452.     {
  453.         $this->walletExtension = $walletExtension;
  455.         return $this;
  456.     }
  458.     public function getConfig(): ?array
  459.     {
  460.         return $this->config;
  461.     }
  463.     public function setConfig(?array $config): self
  464.     {
  465.         $this->config = $config;
  467.         return $this;
  468.     }
  470.     public function getActiveWallet(): ?ThetaWallet
  471.     {
  472.         return $this->activeWallet;
  473.     }
  475.     public function setActiveWallet(?ThetaWallet $activeWallet): self
  476.     {
  477.         $this->activeWallet = $activeWallet;
  479.         return $this;
  480.     }
  482.     public function getLastRecipeHint(): ?\DateTimeInterface
  483.     {
  484.         return $this->lastRecipeHint;
  485.     }
  487.     public function setLastRecipeHint(?\DateTimeInterface $lastRecipeHint): self
  488.     {
  489.         $this->lastRecipeHint = $lastRecipeHint;
  491.         return $this;
  492.     }
  494.     public function getCatchableQueue(): ?CatchableQueue
  495.     {
  496.         return $this->catchableQueue;
  497.     }
  499.     public function setCatchableQueue(CatchableQueue $catchableQueue): self
  500.     {
  501.         // set the owning side of the relation if necessary
  502.         if ($catchableQueue->getUser() !== $this) {
  503.             $catchableQueue->setUser($this);
  504.         }
  506.         $this->catchableQueue = $catchableQueue;
  508.         return $this;
  509.     }
  511.     public function getExperience(): ?string
  512.     {
  513.         return $this->experience;
  514.     }
  516.     public function setExperience(?string $experience): self
  517.     {
  518.         $this->experience = $experience;
  520.         return $this;
  521.     }
  523.     public function getShadowBanUntil(): ?\DateTimeInterface
  524.     {
  525.         return $this->shadowBanUntil;
  526.     }
  528.     public function setShadowBanUntil(?\DateTimeInterface $shadowBanUntil): self
  529.     {
  530.         $this->shadowBanUntil = $shadowBanUntil;
  532.         return $this;
  533.     }
  535.     /**
  536.      * @return Collection<int, ShopItemPurchases>
  537.      */
  538.     public function getShopItemPurchases(): Collection
  539.     {
  540.         return $this->shopItemPurchases;
  541.     }
  543.     public function addShopItemPurchase(ShopItemPurchases $shopItemPurchase): self
  544.     {
  545.         if (!$this->shopItemPurchases->contains($shopItemPurchase)) {
  546.             $this->shopItemPurchases->add($shopItemPurchase);
  547.             $shopItemPurchase->setUser($this);
  548.         }
  550.         return $this;
  551.     }
  553.     public function removeShopItemPurchase(ShopItemPurchases $shopItemPurchase): self
  554.     {
  555.         if ($this->shopItemPurchases->removeElement($shopItemPurchase)) {
  556.             // set the owning side to null (unless already changed)
  557.             if ($shopItemPurchase->getUser() === $this) {
  558.                 $shopItemPurchase->setUser(null);
  559.             }
  560.         }
  562.         return $this;
  563.     }
  565.     public function getShinies(): ?int
  566.     {
  567.         return $this->shinies;
  568.     }
  570.     public function setShinies(?int $shinies): self
  571.     {
  572.         $this->shinies = $shinies;
  574.         return $this;
  575.     }
  577.     /**
  578.      * @return Collection<int, Recipe>
  579.      */
  580.     public function getUnlockedRecipes(): Collection
  581.     {
  582.         return $this->unlockedRecipes;
  583.     }
  585.     public function addUnlockedRecipe(Recipe $unlockedRecipe): self
  586.     {
  587.         if (!$this->unlockedRecipes->contains($unlockedRecipe)) {
  588.             $this->unlockedRecipes->add($unlockedRecipe);
  589.         }
  591.         return $this;
  592.     }
  594.     public function removeUnlockedRecipe(Recipe $unlockedRecipe): self
  595.     {
  596.         $this->unlockedRecipes->removeElement($unlockedRecipe);
  598.         return $this;
  599.     }
  601.     public function getGameToken2(): ?string
  602.     {
  603.         return $this->gameToken2;
  604.     }
  606.     public function setGameToken2(?string $gameToken2): self
  607.     {
  608.         $this->gameToken2 = $gameToken2;
  610.         return $this;
  611.     }
  613.     public function getActProgression(): ?ActProgression
  614.     {
  615.         return $this->actProgression;
  616.     }
  618.     public function setActProgression(?ActProgression $actProgression): self
  619.     {
  620.         $this->actProgression = $actProgression;
  622.         return $this;
  623.     }
  625.     public function getThetaDropWallet(): ?ThetaWallet
  626.     {
  627.         return $this->thetaDropWallet;
  628.     }
  630.     public function setThetaDropWallet(?ThetaWallet $thetaDropWallet): self
  631.     {
  632.         $this->thetaDropWallet = $thetaDropWallet;
  634.         return $this;
  635.     }
  637. }