src/Entity/User.php line 15

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use App\String\Constant;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  9. use Doctrine\ORM\Mapping as ORM;
  10. use PhpParser\Node\Expr\BinaryOp\BooleanOr;
  11. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  12. use Symfony\Component\Security\Core\User\UserInterface;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. class User implements UserInterface, PasswordAuthenticatedUserInterface
  16. {
  17.     #[ORM\Id]
  18.     #[ORM\GeneratedValue]
  19.     #[ORM\Column(type: 'integer')]
  20.     private $id;
  22.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  23.     private $email;
  25.     #[ORM\Column(type: 'json')]
  26.     private $roles = [];
  28.     #[ORM\Column(type: 'string')]
  29.     private $password;
  31.     #[ORM\OneToOne(mappedBy: 'user', targetEntity: UserProfile::class, cascade: ['persist', 'remove'])]
  32.     private $userProfile;
  34.     #[ORM\OneToOne(mappedBy: 'user', targetEntity: UserAddress::class, cascade: ['persist', 'remove'])]
  35.     private $userAddress;
  37.     #[ORM\OneToOne(mappedBy: 'user', targetEntity: UserInformation::class, cascade: ['persist', 'remove'])]
  38.     private $userInformation;
  40.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  41.     private $firstName;
  43.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  44.     private $lastName;
  46.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  47.     private $phone;
  49.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  50.     private $gender;
  52.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  53.     private $isDiverse;
  55.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: OrderDetails::class)]
  56.     private $orderDetails;
  58.     #[ORM\OneToMany(mappedBy: 'owner', targetEntity: FilmProject::class)]
  59.     private $filmProjects;
  61.     #[ORM\OneToMany(mappedBy: 'user', targetEntity: UserBilling::class)]
  62.     private $userBillings;
  64.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  65.     private $organisation;
  67.     #[ORM\Column(type: 'array', nullable: true)]
  68.     private $areaInterest = [];
  70.     #[ORM\ManyToMany(targetEntity: UserCategory::class, inversedBy: 'users')]
  71.     private $categories;
  73.     #[ORM\ManyToMany(targetEntity: FilmProject::class, inversedBy: 'users')]
  74.     private $followedFilmProjects;
  76.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  77.     private $accountSalesforceId;
  79.     #[ORM\ManyToMany(targetEntity: ProjectNotification::class, mappedBy: 'user')]
  80.     private Collection $projectNotifications;
  82.     #[ORM\Column(length: 255, nullable: true)]
  83.     private ?string $isAborigin = null;
  85.     #[ORM\Column(nullable: true)]
  86.     private ?bool $isSuccess = null;
  88.     #[ORM\Column(nullable: true)]
  89.     private ?bool $isGuest = null;
  91.     private ?bool $isAdmin;
  93.     // Honeypot fields
  94.     private ?string $emailAddress = null;
  95.     private ?string $fullName = null;
  97.     public function __construct()
  98.     {
  99.         $this->orderDetails = new ArrayCollection();
  100.         $this->filmProjects = new ArrayCollection();
  101.         $this->userBillings = new ArrayCollection();
  102.         $this->categories = new ArrayCollection();
  103.         $this->followedFilmProjects = new ArrayCollection();
  104.         $this->projectNotifications = new ArrayCollection();
  105.     }
  107.     public function getId(): ?int
  108.     {
  109.         return $this->id;
  110.     }
  112.     public function getEmail(): ?string
  113.     {
  114.         return $this->email;
  115.     }
  117.     public function setEmail(string $email): self
  118.     {
  119.         $this->email = $email;
  121.         return $this;
  122.     }
  124.     /**
  125.      * A visual identifier that represents this user.
  126.      *
  127.      * @see UserInterface
  128.      */
  129.     public function getUserIdentifier(): string
  130.     {
  131.         return (string) $this->email;
  132.     }
  134.     /**
  135.      * @see UserInterface
  136.      */
  137.     public function getRoles(): array
  138.     {
  139.         $roles = $this->roles;
  140.         // guarantee every user at least has ROLE_USER
  141.         $roles[] = 'ROLE_USER';
  143.         return array_unique($roles);
  144.     }
  146.     public function setRoles(array $roles): self
  147.     {
  148.         // ALWAYS SET USERPORTAL ROLE
  149.         $roles = array_merge($roles, ['ROLE_PORTALUSER']);
  151.         $this->roles = $roles;
  152.         
  153.         return $this;
  154.     }
  155.     
  156.     public function setSpecificRoles(array $roles): self
  157.     {
  158.         $this->roles = $roles;
  159.         
  160.         return $this;
  161.     }
  162.     
  163.     public function getFullRoles(): ?string
  164.     {
  165.         $roles = $this->roles;
  166.         $roles[] = 'ROLE_USER';
  168.         $newRoles = [];
  169.         foreach ($roles as $role) {
  170.             switch ($role) {
  171.                 case 'ROLE_PARTNER': 
  172.                     array_push($newRoles, 'Filmmaker'); break;
  173.                 case 'ROLE_FUNDER':
  174.                     array_push($newRoles, 'Sponsor'); break; // impact partner
  175.                 case 'ROLE_DONOR':
  176.                     array_push($newRoles, 'Donor'); break;
  177.                 case 'ROLE_ADMIN':
  178.                     array_push($newRoles, 'Administrator'); break;
  179.                 case 'ROLE_FIN_ADMIN':
  180.                     array_push($newRoles, 'Finance Admin'); break;
  181.                 case 'ROLE_DOCUMENTARY_LOVER':
  182.                     array_push($newRoles, 'Documentary Lover'); break;
  183.             }
  184.         }
  186.         $newRoles = array_unique($newRoles);
  187.         return implode(', ', $newRoles);
  188.     }
  190.     /**
  191.      * @see PasswordAuthenticatedUserInterface
  192.      */
  193.     public function getPassword(): string
  194.     {
  195.         return $this->password;
  196.     }
  198.     public function setPassword(string $password): self
  199.     {
  200.         $this->password = $password;
  202.         return $this;
  203.     }
  205.     /**
  206.      * @see UserInterface
  207.      */
  208.     public function eraseCredentials()
  209.     {
  210.         // If you store any temporary, sensitive data on the user, clear it here
  211.         // $this->plainPassword = null;
  212.     }
  214.     public function getUserProfile(): ?UserProfile
  215.     {
  216.         return $this->userProfile;
  217.     }
  219.     public function setUserProfile(?UserProfile $userProfile): self
  220.     {
  221.         // unset the owning side of the relation if necessary
  222.         if ($userProfile === null && $this->userProfile !== null) {
  223.             $this->userProfile->setUser(null);
  224.         }
  226.         // set the owning side of the relation if necessary
  227.         if ($userProfile !== null && $userProfile->getUser() !== $this) {
  228.             $userProfile->setUser($this);
  229.         }
  231.         $this->userProfile = $userProfile;
  233.         return $this;
  234.     }
  236.     public function getUserAddress(): ?UserAddress
  237.     {
  238.         return $this->userAddress;
  239.     }
  241.     public function setUserAddress(?UserAddress $userAddress): self
  242.     {
  243.         // unset the owning side of the relation if necessary
  244.         if ($userAddress === null && $this->userAddress !== null) {
  245.             $this->userAddress->setUser(null);
  246.         }
  248.         // set the owning side of the relation if necessary
  249.         if ($userAddress !== null && $userAddress->getUser() !== $this) {
  250.             $userAddress->setUser($this);
  251.         }
  253.         $this->userAddress = $userAddress;
  255.         return $this;
  256.     }
  258.     public function getUserInformation(): ?UserInformation
  259.     {
  260.         return $this->userInformation;
  261.     }
  263.     public function setUserInformation(?UserInformation $userInformation): self
  264.     {
  265.         // unset the owning side of the relation if necessary
  266.         if ($userInformation === null && $this->userInformation !== null) {
  267.             $this->userInformation->setUser(null);
  268.         }
  270.         // set the owning side of the relation if necessary
  271.         if ($userInformation !== null && $userInformation->getUser() !== $this) {
  272.             $userInformation->setUser($this);
  273.         }
  275.         $this->userInformation = $userInformation;
  277.         return $this;
  278.     }
  280.     public function getFirstName(): ?string
  281.     {
  282.         return $this->firstName;
  283.     }
  285.     public function setFirstName(?string $firstName): self
  286.     {
  287.         $this->firstName = $firstName;
  289.         return $this;
  290.     }
  292.     public function getLastName(): ?string
  293.     {
  294.         return $this->lastName;
  295.     }
  297.     public function setLastName(?string $lastName): self
  298.     {
  299.         $this->lastName = $lastName;
  301.         return $this;
  302.     }
  304.     public function getFullName(): ?string
  305.     {
  306.         return $this->firstName . ' ' . $this->lastName;
  307.     }
  309.     public function getPhone(): ?string
  310.     {
  311.         return $this->phone;
  312.     }
  314.     public function setPhone(?string $phone): self
  315.     {
  316.         $this->phone = $phone;
  318.         return $this;
  319.     }
  321.     public function getGender(): ?string
  322.     {
  323.         return $this->gender;
  324.     }
  326.     public function setGender(?string $gender): self
  327.     {
  328.         $this->gender = $gender;
  330.         return $this;
  331.     }
  333.     // public function isIsDiverse(): ?bool
  334.     // {
  335.     //     return $this->isDiverse;
  336.     // }
  338.     // public function setIsDiverse(?bool $isDiverse): self
  339.     // {
  340.     //     $this->isDiverse = $isDiverse;
  342.     //     return $this;
  343.     // }
  344.     public function getIsDiverse(): ?string
  345.     {
  346.         return $this->isDiverse;
  347.     }
  349.     public function setIsDiverse(?string $isDiverse): self
  350.     {
  351.         $this->isDiverse = $isDiverse;
  353.         return $this;
  354.     }
  356.     /**
  357.      * @return Collection<int, OrderDetails>
  358.      */
  359.     public function getOrderDetails(): Collection
  360.     {
  361.         return $this->orderDetails;
  362.     }
  364.     public function addOrderDetail(OrderDetails $orderDetail): self
  365.     {
  366.         if (!$this->orderDetails->contains($orderDetail)) {
  367.             $this->orderDetails[] = $orderDetail;
  368.             $orderDetail->setUser($this);
  369.         }
  371.         return $this;
  372.     }
  374.     public function removeOrderDetail(OrderDetails $orderDetail): self
  375.     {
  376.         if ($this->orderDetails->removeElement($orderDetail)) {
  377.             // set the owning side to null (unless already changed)
  378.             if ($orderDetail->getUser() === $this) {
  379.                 $orderDetail->setUser(null);
  380.             }
  381.         }
  383.         return $this;
  384.     }
  386.     /**
  387.      * @return Collection<int, FilmProject>
  388.      */
  389.     public function getFilmProjects(): Collection
  390.     {
  391.         return $this->filmProjects;
  392.     }
  394.     public function addFilmProject(FilmProject $filmProject): self
  395.     {
  396.         if (!$this->filmProjects->contains($filmProject)) {
  397.             $this->filmProjects[] = $filmProject;
  398.             $filmProject->setOwner($this);
  399.         }
  401.         return $this;
  402.     }
  404.     public function removeFilmProject(FilmProject $filmProject): self
  405.     {
  406.         if ($this->filmProjects->removeElement($filmProject)) {
  407.             // set the owning side to null (unless already changed)
  408.             if ($filmProject->getOwner() === $this) {
  409.                 $filmProject->setOwner(null);
  410.             }
  411.         }
  413.         return $this;
  414.     }
  416.     public function isAdmin(): bool
  417.     {
  418.         $isAdmin = false;
  420.         foreach ($this->roles as $role) {
  421.             if ($role == 'ROLE_ADMIN') {
  422.                 $isAdmin = true;
  423.                 break;
  424.             }
  425.         }
  427.         return $isAdmin;
  428.     }
  430.     public function isFinanceAdmin(): bool
  431.     {
  432.         $isFinanceAdmin = false;
  434.         foreach ($this->roles as $role) {
  435.             if ($role == 'ROLE_FIN_ADMIN') {
  436.                 $isFinanceAdmin = true;
  437.                 break;
  438.             }
  439.         }
  441.         return $isFinanceAdmin;
  442.     }
  445.     public function isFilmmaker(): bool
  446.     {
  447.         $isFilmmaker = false;
  449.         foreach ($this->roles as $role) {
  450.             if ($role == Constant::ROLE_FILMMAKER) {
  451.                 $isFilmmaker = true;
  452.                 break;
  453.             }
  454.         }
  456.         return $isFilmmaker;
  457.     }
  459.     /**
  460.      * @return Collection<int, UserBilling>
  461.      */
  462.     public function getUserBillings(): Collection
  463.     {
  464.         return $this->userBillings;
  465.     }
  467.     public function addUserBilling(UserBilling $userBilling): self
  468.     {
  469.         if (!$this->userBillings->contains($userBilling)) {
  470.             $this->userBillings[] = $userBilling;
  471.             $userBilling->setUser($this);
  472.         }
  474.         return $this;
  475.     }
  477.     public function removeUserBilling(UserBilling $userBilling): self
  478.     {
  479.         if ($this->userBillings->removeElement($userBilling)) {
  480.             // set the owning side to null (unless already changed)
  481.             if ($userBilling->getUser() === $this) {
  482.                 $userBilling->setUser(null);
  483.             }
  484.         }
  486.         return $this;
  487.     }
  489.     public function getOrganisation(): ?string
  490.     {
  491.         return $this->organisation;
  492.     }
  494.     public function setOrganisation(?string $organisation): self
  495.     {
  496.         $this->organisation = $organisation;
  498.         return $this;
  499.     }
  501.     public function getAreaInterest(): ?array
  502.     {
  503.         return $this->areaInterest;
  504.     }
  506.     public function setAreaInterest(?array $areaInterest): self
  507.     {
  508.         $this->areaInterest = $areaInterest;
  510.         return $this;
  511.     }
  513.     /**
  514.      * @return Collection<int, UserCategory>
  515.      */
  516.     public function getCategories(): Collection
  517.     {
  518.         return $this->categories;
  519.     }
  521.     public function addCategory(UserCategory $category): self
  522.     {
  523.         if (!$this->categories->contains($category)) {
  524.             $this->categories[] = $category;
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeCategory(UserCategory $category): self
  531.     {
  532.         $this->categories->removeElement($category);
  534.         return $this;
  535.     }
  537.     /**
  538.      * @return Collection<int, FilmProject>
  539.      */
  540.     public function getFollowedFilmProjects(): Collection
  541.     {
  542.         return $this->followedFilmProjects;
  543.     }
  545.     public function addFollowedFilmProject(FilmProject $followedFilmProject): self
  546.     {
  547.         if (!$this->followedFilmProjects->contains($followedFilmProject)) {
  548.             $this->followedFilmProjects[] = $followedFilmProject;
  549.         }
  551.         return $this;
  552.     }
  554.     public function removeFollowedFilmProject(FilmProject $followedFilmProject): self
  555.     {
  556.         $this->followedFilmProjects->removeElement($followedFilmProject);
  558.         return $this;
  559.     }
  561.     public function getAccountSalesforceId(): ?string
  562.     {
  563.         return $this->accountSalesforceId;
  564.     }
  566.     public function setAccountSalesforceId(?string $accountSalesforceId): self
  567.     {
  568.         $this->accountSalesforceId = $accountSalesforceId;
  570.         return $this;
  571.     }
  573.     /**
  574.      * @return Collection<int, ProjectNotification>
  575.      */
  576.     public function getProjectNotifications(): Collection
  577.     {
  578.         return $this->projectNotifications;
  579.     }
  581.     public function addProjectNotification(ProjectNotification $projectNotification): self
  582.     {
  583.         if (!$this->projectNotifications->contains($projectNotification)) {
  584.             $this->projectNotifications->add($projectNotification);
  585.             $projectNotification->addUser($this);
  586.         }
  588.         return $this;
  589.     }
  591.     public function removeProjectNotification(ProjectNotification $projectNotification): self
  592.     {
  593.         if ($this->projectNotifications->removeElement($projectNotification)) {
  594.             $projectNotification->removeUser($this);
  595.         }
  597.         return $this;
  598.     }
  600.     public function getIsAborigin(): ?string
  601.     {
  602.         return $this->isAborigin;
  603.     }
  605.     public function setIsAborigin(?string $isAborigin): self
  606.     {
  607.         $this->isAborigin = $isAborigin;
  609.         return $this;
  610.     }
  612.     public function isIsSuccess(): ?bool
  613.     {
  614.         return $this->isSuccess;
  615.     }
  617.     public function setIsSuccess(?bool $isSuccess): self
  618.     {
  619.         $this->isSuccess = $isSuccess;
  621.         return $this;
  622.     }
  624.     public function isIsGuest(): ?bool
  625.     {
  626.         return $this->isGuest;
  627.     }
  629.     public function setIsGuest(?bool $isGuest): self
  630.     {
  631.         $this->isGuest = $isGuest;
  633.         return $this;
  634.     }
  636.     public function getEmailAddress(): ?string
  637.     {
  638.         return $this->emailAddress;
  639.     }
  641.     public function setEmailAddress(?string $emailAddress): self
  642.     {
  643.         $this->emailAddress = $emailAddress;
  645.         return $this;
  646.     }
  648.     public function setFullName(?string $fullName): self
  649.     {
  650.         $this->fullName = $fullName;
  652.         return $this;
  653.     }
  655.     public function toString() {
  656.         if ($this->email) {
  657.             return $this->email;
  658.         }
  660.         return '';
  661.     }
  663.     public function __toString() {
  664.         return $this->toString();
  665.     }
  666. }