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\ORM\Mapping as ORM;
  9. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  10. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  11. use Symfony\Component\Security\Core\User\UserInterface;
  13. #[ORM\Entity(repositoryClass: UserRepository::class)]
  14. #[ORM\Table(name: '`user`')]
  15. #[UniqueEntity(fields: ['email'], message: 'An account with this email already exists. Please log in instead.')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  19.     const ROLE_USER = 'ROLE_USER';
  20.     const ROLE_ADMIN = 'ROLE_ADMIN';
  21.     const VALIDITY_IN_DAYS = 730;
  22.     const REJECT_REASON_INVALID_IDENTITY = 'II';
  23.     const REJECT_REASON_MEMBERSHIP_FEE_NOT_RECEIVED = 'MN';
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column]
  29.     private ?int $id = null;
  31.     #[ORM\Column(length: 180, unique: true)]
  32.     private ?string $email = null;
  34.     #[ORM\Column]
  35.     private array $roles = [];
  37.     /**
  38.      * @var string The hashed password
  39.      */
  40.     #[ORM\Column]
  41.     private ?string $password = null;
  43.     #[ORM\Column(length: 255)]
  44.     private ?string $firstName = null;
  46.     #[ORM\Column(length: 255, nullable: true)]
  47.     private ?string $lastName = null;
  49.     #[ORM\Column(length: 255, nullable: true)]
  50.     private ?string $address = null;
  52.     #[ORM\Column(length: 255, nullable: true)]
  53.     private ?string $phoneNo = null;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserImage::class, orphanRemoval: true)]
  56.     #@ORM\JoinColumn(name="id", referencedColumnName="user_id")
  57.     private Collection $userImages;
  59.     #[ORM\ManyToOne(inversedBy: 'users', fetch:"EAGER")]
  60.     #[ORM\JoinColumn(name:"user_status_code", referencedColumnName: "user_status_code", nullable: false)]
  61.     private ?UserStatus $userStatus = null;
  63.     #[ORM\Column(length: 2, nullable: true)]
  64.     private ?string $gender = null;
  66.     #[ORM\OneToOne(mappedBy: 'user', fetch:"EAGER", cascade: ['persist', 'remove'])]
  67.     private ?UserDetail $userDetail = null;
  69.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: TeamMember::class)]
  70.     private Collection $teamMembers;
  72.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserInvoice::class)]
  73.     private Collection $userInvoices;
  75.     #[ORM\Column(type:"datetime", nullable:true)]
  76.     private $createdAt;
  77.     #[ORM\Column(type:"datetime", nullable:true)]
  78.     private $approvedAt;
  79.     #[ORM\Column(type:"datetime", nullable:true)]
  80.     private $validAt;
  82.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: EmailArchive::class)]
  83.     private Collection $emailArchives;
  85.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Payment::class)]
  86.     private Collection $payments;
  88.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: PartyPillar::class)]
  89.     private Collection $partyPillars;
  91.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: Donation::class)]
  92.     private Collection $donations;
  94.     public function __construct()
  95.     {
  96.         $this->userImages = new ArrayCollection();
  97.         $this->teamMembers = new ArrayCollection();
  98.         $this->userInvoices = new ArrayCollection();
  99.         $this->emailArchives = new ArrayCollection();
  100.         $this->payments = new ArrayCollection();
  101.         $this->partyPillars = new ArrayCollection();
  102.         $this->donations = new ArrayCollection();
  103.     }
  105.     public function getId(): ?int
  106.     {
  107.         return $this->id;
  108.     }
  110.     public function getEmail(): ?string
  111.     {
  112.         return $this->email;
  113.     }
  115.     public function setEmail(string $email): self
  116.     {
  117.         $this->email = $email;
  119.         return $this;
  120.     }
  122.     /**
  123.      * A visual identifier that represents this user.
  124.      *
  125.      * @see UserInterface
  126.      */
  127.     public function getUserIdentifier(): string
  128.     {
  129.         return (string) $this->email;
  130.     }
  132.     /**
  133.      * @see UserInterface
  134.      */
  135.     public function getRoles(): array
  136.     {
  137.         $roles = $this->roles;
  138.         // guarantee every user at least has ROLE_USER
  139.         $roles[] = 'ROLE_USER';
  141.         return array_unique($roles);
  142.     }
  144.     public function setRoles(array $roles): self
  145.     {
  146.         $this->roles = (!empty($roles)) ?? self::ROLE_USER ;
  148.         return $this;
  149.     }
  151.     /**
  152.      * @see PasswordAuthenticatedUserInterface
  153.      */
  154.     public function getPassword(): string
  155.     {
  156.         return $this->password;
  157.     }
  159.     public function setPassword(string $password): self
  160.     {
  161.         $this->password = $password;
  163.         return $this;
  164.     }
  166.     /**
  167.      * @see UserInterface
  168.      */
  169.     public function eraseCredentials()
  170.     {
  171.         // If you store any temporary, sensitive data on the user, clear it here
  172.         // $this->plainPassword = null;
  173.     }
  175.     public function getFirstName(): ?string
  176.     {
  177.         return $this->firstName;
  178.     }
  180.     public function setFirstName(string $firstName): self
  181.     {
  182.         $this->firstName = $firstName;
  184.         return $this;
  185.     }
  187.     public function getLastName(): ?string
  188.     {
  189.         return $this->lastName;
  190.     }
  192.     public function setLastName(?string $lastName): self
  193.     {
  194.         $this->lastName = $lastName;
  196.         return $this;
  197.     }
  199.     public function getAddress(): ?string
  200.     {
  201.         return $this->address;
  202.     }
  204.     public function setAddress(?string $address): self
  205.     {
  206.         $this->address = $address;
  208.         return $this;
  209.     }
  211.     public function getPhoneNo(): ?string
  212.     {
  213.         return $this->phoneNo;
  214.     }
  216.     public function setPhoneNo(?string $phoneNo): self
  217.     {
  218.         $this->phoneNo = $phoneNo;
  220.         return $this;
  221.     }
  223.     /**
  224.      * @return Collection<int, UserImage>
  225.      */
  226.     public function getUserImages(): Collection
  227.     {
  228.         return $this->userImages;
  229.     }
  231.     public function getUserImagesByuserImageTypeCode(string $userImageTypeCode){
  232.         if (!empty($this->userImages)){
  233.             foreach($this->getUserImages() as $userImage){
  234.                 if($userImage->getUserImageType()->getUserImageTypeCode() != $userImageTypeCode){
  235.                     continue;
  236.                 }
  237.                 return $userImage;
  238.             }
  239.         }
  240.         return null;
  241.     }
  243.     public function getUserInvoiceByImageMetadata(?ImageMetadata $imageMetadata){
  244.         if (!empty($this->userInvoices)){
  245.             foreach($this->getUserInvoices() as $userInvoice){
  246.                 if($userInvoice->getInvoice()->getImageMetadata()->getImageMetadataUid() != $imageMetadata->getImageMetadataUid()){
  247.                     continue;
  248.                 }
  249.                 return $userInvoice;
  250.             }
  251.         }
  252.         return null;
  253.     }
  255. //    public function addUserImageTypeCode(UserImage $userImageTypeCode): self
  256. //    {
  257. //        if (!$this->userImages->contains($userImageTypeCode)) {
  258. //            $this->userImages->add($userImageTypeCode);
  259. //            $userImageTypeCode->setUser($this);
  260. //        }
  261. //
  262. //        return $this;
  263. //    }
  264. //
  265. //    public function removeUserImageTypeCode(UserImage $userImageTypeCode): self
  266. //    {
  267. //        if ($this->userImages->removeElement($userImageTypeCode)) {
  268. //            // set the owning side to null (unless already changed)
  269. //            if ($userImageTypeCode->getUser() === $this) {
  270. //                $userImageTypeCode->setUser(null);
  271. //            }
  272. //        }
  273. //
  274. //        return $this;
  275. //    }
  277.     public function getUserStatus(): ?UserStatus
  278.     {
  279.         return $this->userStatus;
  280.     }
  282.     public function setUserStatus(?UserStatus $userStatus): static
  283.     {
  284.         $this->userStatus = $userStatus;
  286.         return $this;
  287.     }
  289.     public function getGender(): ?string
  290.     {
  291.         return $this->gender;
  292.     }
  294.     public function setGender(?string $gender): static
  295.     {
  296.         $this->gender = $gender;
  298.         return $this;
  299.     }
  301.     public function getUserDetail(): ?UserDetail
  302.     {
  303.         return $this->userDetail;
  304.     }
  306.     public function setUserDetail(?UserDetail $userDetail): static
  307.     {
  308.         // unset the owning side of the relation if necessary
  309.         if ($userDetail === null && $this->userDetail !== null) {
  310.             $this->userDetail->setUser(null);
  311.         }
  313.         // set the owning side of the relation if necessary
  314.         if ($userDetail !== null && $userDetail->getUser() !== $this) {
  315.             $userDetail->setUser($this);
  316.         }
  318.         $this->userDetail = $userDetail;
  320.         return $this;
  321.     }
  323.     /**
  324.      * @return Collection<int, TeamMember>
  325.      */
  326.     public function getTeamMembers(): Collection
  327.     {
  328.         return $this->teamMembers;
  329.     }
  330.     public function getDisplayTeamMember():string {
  331.         foreach ($this->teamMembers as $teamMember){
  332.             return $teamMember->getDesignation()->getName(); //Fixme: TBD designation priority order
  333.         }
  334.         return "General Member";
  335.     }
  337.     public function addTeamMember(TeamMember $teamMember): static
  338.     {
  339.         if (!$this->teamMembers->contains($teamMember)) {
  340.             $this->teamMembers->add($teamMember);
  341.             $teamMember->setUser($this);
  342.         }
  344.         return $this;
  345.     }
  347.     public function removeTeamMember(TeamMember $teamMember): static
  348.     {
  349.         if ($this->teamMembers->removeElement($teamMember)) {
  350.             // set the owning side to null (unless already changed)
  351.             if ($teamMember->getUser() === $this) {
  352.                 $teamMember->setUser(null);
  353.             }
  354.         }
  356.         return $this;
  357.     }
  359.     /**
  360.      * @return Collection<int, UserInvoice>
  361.      */
  362.     public function getUserInvoices(): Collection
  363.     {
  364.         return $this->userInvoices;
  365.     }
  367.     public function addUserInvoice(UserInvoice $userInvoice): static
  368.     {
  369.         if (!$this->userInvoices->contains($userInvoice)) {
  370.             $this->userInvoices->add($userInvoice);
  371.             $userInvoice->setUser($this);
  372.         }
  374.         return $this;
  375.     }
  377.     public function removeUserInvoice(UserInvoice $userInvoice): static
  378.     {
  379.         if ($this->userInvoices->removeElement($userInvoice)) {
  380.             // set the owning side to null (unless already changed)
  381.             if ($userInvoice->getUser() === $this) {
  382.                 $userInvoice->setUser(null);
  383.             }
  384.         }
  386.         return $this;
  387.     }
  389.     /**
  390.      * @return \DateTimeInterface
  391.      */
  392.     public function getCreatedAt(): ?\DateTimeInterface
  393.     {
  394.         return $this->createdAt;
  395.     }
  397.     /**
  398.      * @param mixed $createdAt
  399.      */
  400.     public function setCreatedAt(? \DateTimeInterface $createdAt): self
  401.     {
  402.         $this->createdAt = $createdAt;
  403.         return $this;
  404.     }
  406.     /**
  407.      * @return mixed
  408.      */
  409.     public function getApprovedAt(): ?\DateTimeInterface
  410.     {
  411.         return $this->approvedAt;
  412.     }
  414.     /**
  415.      * @param mixed $approvedAt
  416.      */
  417.     public function setApprovedAt(?\DateTimeInterface $approvedAt): self
  418.     {
  419.         $this->approvedAt = $approvedAt;
  420.         return $this;
  421.     }
  423.     /**
  424.      * @return mixed
  425.      */
  426.     public function getValidAt(): ?\DateTimeInterface
  427.     {
  428.         return $this->validAt;
  429.     }
  431.     /**
  432.      * @param mixed $validAt
  433.      */
  434.     public function setValidAt($validAt): self
  435.     {
  436.         $this->validAt = $validAt;
  437.         return $this;
  438.     }
  440.     /**
  441.      * @return Collection<int, EmailArchive>
  442.      */
  443.     public function getEmailArchives(): Collection
  444.     {
  445.         return $this->emailArchives;
  446.     }
  448.     public function addEmailArchive(EmailArchive $emailArchive): static
  449.     {
  450.         if (!$this->emailArchives->contains($emailArchive)) {
  451.             $this->emailArchives->add($emailArchive);
  452.             $emailArchive->setUser($this);
  453.         }
  455.         return $this;
  456.     }
  458.     public function removeEmailArchive(EmailArchive $emailArchive): static
  459.     {
  460.         if ($this->emailArchives->removeElement($emailArchive)) {
  461.             // set the owning side to null (unless already changed)
  462.             if ($emailArchive->getUser() === $this) {
  463.                 $emailArchive->setUser(null);
  464.             }
  465.         }
  467.         return $this;
  468.     }
  470.     /**
  471.      * @return Collection<int, Payment>
  472.      */
  473.     public function getPayments(): Collection
  474.     {
  475.         return $this->payments;
  476.     }
  478.     public function addPayment(Payment $payment): static
  479.     {
  480.         if (!$this->payments->contains($payment)) {
  481.             $this->payments->add($payment);
  482.             $payment->setUser($this);
  483.         }
  485.         return $this;
  486.     }
  488.     public function removePayment(Payment $payment): static
  489.     {
  490.         if ($this->payments->removeElement($payment)) {
  491.             // set the owning side to null (unless already changed)
  492.             if ($payment->getUser() === $this) {
  493.                 $payment->setUser(null);
  494.             }
  495.         }
  497.         return $this;
  498.     }
  500.     /**
  501.      * @return Collection<int, PartyPillar>
  502.      */
  503.     public function getPartyPillars(): Collection
  504.     {
  505.         return $this->partyPillars;
  506.     }
  508.     public function addPartyPillar(PartyPillar $partyPillar): static
  509.     {
  510.         if (!$this->partyPillars->contains($partyPillar)) {
  511.             $this->partyPillars->add($partyPillar);
  512.             $partyPillar->setUser($this);
  513.         }
  515.         return $this;
  516.     }
  518.     public function removePartyPillar(PartyPillar $partyPillar): static
  519.     {
  520.         if ($this->partyPillars->removeElement($partyPillar)) {
  521.             // set the owning side to null (unless already changed)
  522.             if ($partyPillar->getUser() === $this) {
  523.                 $partyPillar->setUser(null);
  524.             }
  525.         }
  527.         return $this;
  528.     }
  530.     public function isPaid( string $paymentType):?int {
  531.         foreach($this->getPayments() as $payment){
  532.             if(
  533.                 $payment->getPaymentType()->getPaymentTypeCode() == $paymentType
  534.                 && $payment->getPaymentStatus()->getPaymentStatusCode() == PaymentStatus::STATUS_PAID
  535.             ){
  536.                 return $payment->getPaymentId();
  537.             }
  538.         }
  539.         return null;
  540.     }
  542.     /**
  543.      * @return Collection<int, Donation>
  544.      */
  545.     public function getDonations(): Collection
  546.     {
  547.         return $this->donations;
  548.     }
  550.     public function addDonation(Donation $donation): static
  551.     {
  552.         if (!$this->donations->contains($donation)) {
  553.             $this->donations->add($donation);
  554.             $donation->setUser($this);
  555.         }
  557.         return $this;
  558.     }
  560.     public function removeDonation(Donation $donation): static
  561.     {
  562.         if ($this->donations->removeElement($donation)) {
  563.             // set the owning side to null (unless already changed)
  564.             if ($donation->getUser() === $this) {
  565.                 $donation->setUser(null);
  566.             }
  567.         }
  569.         return $this;
  570.     }
  571. }