src/Entity/User.php line 16

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Repository\UserRepository;
  6. use Doctrine\DBAL\Types\Types;
  7. use Doctrine\ORM\Mapping as ORM;
  8. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  9. use Symfony\Component\Security\Core\User\UserInterface;
  10. use Symfony\Component\Security\Core\User\EquatableInterface;
  11. use Doctrine\Common\Collections\ArrayCollection;
  12. use Doctrine\Common\Collections\Collection;
  14. #[ORM\Entity(repositoryClass: UserRepository::class)]
  15. #[ORM\Table(name: '`users`')]
  16. class User implements UserInterface, PasswordAuthenticatedUserInterface
  17. {
  18.     #[ORM\Id]
  19.     #[ORM\GeneratedValue]
  20.     #[ORM\Column]
  21.     private ?int $id = null;
  23.    
  24.     #[ORM\Column(length: 180, unique: true)]
  25.     protected ?string $email = null;
  27.     #[ORM\Column(type: 'json_document', options: ['jsonb' => true])]
  28.     private array $roles = ['ROLE_USER'];
  30.     /**
  31.      * @var string The hashed password
  32.      */
  33.     #[ORM\Column (nullable: true)]
  34.     private ?string $password = null;
  36.     #[ORM\Column(length: 255, nullable: true)]
  37.     protected ?string $firstName = null;
  39.     #[ORM\Column(length: 255, nullable: true)]
  40.     protected ?string $lastName = null;
  42.     #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
  43.     protected ?\DateTimeInterface $created_at ;
  45.     #[ORM\Column(nullable: true)]
  46.     protected ?string $phoneNumber = null;
  48.     #[ORM\Column(type: Types::STRING, length: 255, nullable: true)]
  49.     protected ?string $user_address = null;
  51.     /*
  52.     const BROKER = 'broker';
  53.     const ACCOUNTANT = 'accountant';
  54.     const TENANT = 'tenant';
  55.     const LANDLORD = 'landlord';
  56.     const OTHER = 'other';
  58.     /*
  59.     //#[ORM\Column(length: 255, nullable: true)]
  60.     #[ORM\Column(nullable:true)]
  61.     private ?array $userType = null;
  62.     */
  64.     #[ORM\OneToOne(inversedBy: 'users', cascade: ['persist', 'remove'])]
  65.     private ?Broker $broker = null;
  67.     #[ORM\OneToOne(inversedBy: 'users', cascade: ['persist', 'remove'])]
  68.     private ?Accounting $accountant = null;
  70.     #[ORM\OneToOne(inversedBy: 'users', cascade: ['persist', 'remove'])]
  71.     private ?Landlords $landlord = null;
  73.     #[ORM\Column(length: 255, nullable: true)]
  74.     private ?string $userCity = null;
  76.     #[ORM\Column(length: 255, nullable: true)]
  77.     private ?string $userPostcode = null;
  79.     #[ORM\OneToOne(inversedBy: 'users', cascade: ['persist', 'remove'])]
  80.     private ?Tenants $tenant = null;
  82.     #[ORM\Column(length: 255, nullable: true)]
  83.     private ?string $floor = null;
  85.     #[ORM\Column(length: 255, nullable: true)]
  86.     private ?string $bloque = null;
  88.     #[ORM\Column(length: 255, nullable: true)]
  89.     private ?string $escalera = null;
  91.     #[ORM\Column(length: 255, nullable: true)]
  92.     private ?string $province = null;
  94.     #[ORM\Column(length: 255, nullable: true)]
  95.     private ?string $property_number = null;
  97.     #[ORM\Column(length: 255, nullable: true)]
  98.     private ?string $postcode = null;
  100.     #[ORM\OneToMany(mappedBy: 'uploadedByUser', targetEntity: Documents::class,  cascade: ['persist','remove'])]
  101.     private Collection $document;
  103.     #[ORM\OneToMany(mappedBy: 'uploadedByUser', targetEntity: DocsTenants::class, cascade: ['persist','remove'])]
  104.     private Collection $tenantDocument;
  106.     #[ORM\OneToMany(mappedBy: 'generatedBy', targetEntity: MonthlyReport::class, cascade: ['persist','remove'])]
  107.     private Collection $monthlyReports;
  109.     #[ORM\Column(length: 255, nullable: true)]
  110.     private ?string $flatNumber = null;
  112.     #[ORM\Column(type: Types::ARRAY, nullable: true)]
  113.     private ?array $userType = null;
  115.     #[ORM\OneToOne(inversedBy: 'users', cascade: ['persist', 'remove'])]
  116.     private ?PotentialClients $potentialClient = null;
  118.     #[ORM\OneToMany(mappedBy: 'uploadedBy', targetEntity: DocsLandlords::class)]
  119.     private Collection $docsLandlords;
  121.     #[ORM\OneToMany(mappedBy: 'admin', targetEntity: Minutes::class, cascade:['persist','remove'])]
  122.     private Collection $minutes;
  124.     #[ORM\OneToMany(mappedBy: 'uploadedBy', targetEntity: DocsPotentials::class, cascade:['persist','remove'])]
  125.     private Collection $docsPotentials;
  127.     #[ORM\ManyToMany(targetEntity: Event::class, mappedBy: 'users', cascade:['persist','remove'])]
  128.     private Collection $events;
  130.     
  131.     public function __toString(): string
  133.     {
  134.         return $this->getFirstName().' '.$this->getLastname();
  135.     }
  137.     public function getId(): ?int
  138.     {
  139.         return $this->id;
  140.     }
  142.    
  143.     public function getEmail(): ?string
  144.     {
  145.         return $this->email;
  146.     }
  148.     public function setEmail(string $email): self
  149.     {
  150.         $this->email = $email;
  152.         return $this;
  153.     }
  155.     /**
  156.      * A visual identifier that represents this user.
  157.      *
  158.      * @see UserInterface
  159.      */
  160.     public function getUserIdentifier(): string
  161.     {
  162.         return (string) $this->email;
  163.     }
  165.     /**
  166.      * @deprecated since Symfony 5.3, use getUserIdentifier instead
  167.      */
  168.     public function getUsername(): string
  169.     {
  170.         return (string) $this->email;
  171.     }
  174.     
  175.     /**
  176.      * @see UserInterface
  177.      */
  178.     public function getRoles(): array
  179.     {
  180.         if (is_array($this->roles)) {
  181.             $roles = $this->roles;
  182.         } elseif (is_object($this->roles)) {
  183.             $roles = array_values((array) $this->roles);
  184.         } else {
  185.             $roles = [];
  186.         }
  187.     
  188.         // Guarantee every user has at least ROLE_USER
  189.         $roles[] = 'ROLE_USER';
  190.     
  191.         return array_unique($roles);
  192.         
  193.         /*        
  194.         $roles = $this->roles;
  196.         // guarantee every user at least has ROLE_USER
  197.         $roles[] = 'ROLE_USER';
  198.         //$roles[] = 'ROLE_ADMIN';
  201.         return array_unique($roles);
  202.         */
  203.     }
  205.     public function setRoles(array $roles): self
  206.     {
  207.        
  208.         $this->roles = $roles;
  209.         if (!in_array('ROLE_USER', $roles)) {
  210.             $this->roles[] = 'ROLE_USER';
  211.         }
  212.         return $this;
  213.         
  214.     }
  216.     
  218.     /**
  219.      * @see PasswordAuthenticatedUserInterface
  220.      */
  221.     public function getPassword(): string
  222.     {
  223.         return $this->password;
  224.     }
  226.     public function setPassword(string $password): self
  227.     {
  228.         $this->password = $password;
  230.         return $this;
  231.     }
  233.     /**
  234.      * Returning a salt is only needed, if you are not using a modern
  235.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  236.      *
  237.      * @see UserInterface
  238.      */
  239.     public function getSalt(): ?string
  240.     {
  241.         return null;
  242.     }
  244.     /**
  245.      * @see UserInterface
  246.      */
  247.     public function eraseCredentials()
  248.     {
  249.         // If you store any temporary, sensitive data on the user, clear it here
  250.         // $this->plainPassword = null;
  251.     }
  253.     
  255.     public function getFirstName(): ?string
  256.     {
  257.         return $this->firstName;
  258.     }
  260.     public function setFirstName(?string $firstName): self
  261.     {
  262.         $this->firstName = $firstName;
  264.         return $this;
  265.     }
  267.     public function getLastName(): ?string
  268.     {
  269.         return $this->lastName;
  270.     }
  272.     public function setLastName(?string $lastName): self
  273.     {
  274.         $this->lastName = $lastName;
  276.         return $this;
  277.     }
  278.     
  279.     public function getCreatedAt(): ?\DateTimeInterface
  280.     {
  281.         return $this->created_at;
  282.     }
  284.     public function setCreatedAt(\DateTimeInterface $created_at): self
  285.     {
  286.         $this->created_at = $created_at ;
  288.         return $this;
  289.     }
  290.     
  291.     public function __construct()
  292.     {
  293.         $this->created_at = new \DateTime();
  294.         $this->document = new ArrayCollection();
  295.         $this->tenantDocument = new ArrayCollection();
  296.         $this->roles = [];
  297.         $this->monthlyReports = new ArrayCollection();
  298.         $this->docsLandlords = new ArrayCollection();
  299.         $this->minutes = new ArrayCollection();
  300.         $this->docsPotentials = new ArrayCollection();
  301.         $this->events = new ArrayCollection();
  302.     }
  304.     public function getPhoneNumber(): ?string
  305.     {
  306.         return $this->phoneNumber;
  307.     }
  309.     public function setPhoneNumber(?string $phoneNumber): self
  310.     {
  311.         $this->phoneNumber = $phoneNumber;
  313.         return $this;
  314.     }
  316.     public function getUserAddress(): ?string
  317.     {
  318.         return $this->user_address;
  319.     }
  321.     public function setUserAddress(string $user_address): self
  322.     {
  323.         $this->user_address = $user_address;
  325.         return $this;
  326.     }
  328.     /*
  329.     public function getUserType(): array
  330.     {
  331.         return $this->userType;
  332.     }
  334.     public function setUserType(array $userType): void
  335.     {
  336.         $this->userType = $userType;
  338.         //return $this;
  339.     }
  340.     */
  343.     //public static function getUserTypes(): array
  344.     //{
  345.     //    return [
  346.     //        self::BROKER,
  347.     //        self::ACCOUNTANT,
  348.     //        self::TENANT,
  349.     //        self::LANDLORD,
  350.     //        self::OTHER,
  351.     //    ];
  352.     //}
  354.     public function getBroker(): ?Broker
  355.     {
  356.         return $this->broker;
  357.     }
  359.     public function setBroker(?Broker $broker): self
  360.     {
  361.         $this->broker = $broker;
  363.         return $this;
  364.     }
  366.     public function getAccountant(): ?Accounting
  367.     {
  368.         return $this->accountant;
  369.     }
  371.     public function setAccountant(?Accounting $accountant): self
  372.     {
  373.         $this->accountant = $accountant;
  375.         return $this;
  376.     }
  378.     public function getLandlord(): ?Landlords
  379.     {
  380.         return $this->landlord;
  381.     }
  383.     public function setLandlord(?Landlords $landlord): self
  384.     {
  385.         $this->landlord = $landlord;
  387.         return $this;
  388.     }
  390.     public function getUserCity(): ?string
  391.     {
  392.         return $this->userCity;
  393.     }
  395.     public function setUserCity(?string $userCity): self
  396.     {
  397.         $this->userCity = $userCity;
  399.         return $this;
  400.     }
  402.     public function getUserPostcode(): ?string
  403.     {
  404.         return $this->userPostcode;
  405.     }
  407.     public function setUserPostcode(?string $userPostcode): self
  408.     {
  409.         $this->userPostcode = $userPostcode;
  411.         return $this;
  412.     }
  414.     public function getTenant(): ?Tenants
  415.     {
  416.         return $this->tenant;
  417.     }
  419.     public function setTenant(?Tenants $tenant): self
  420.     {
  421.         $this->tenant = $tenant;
  423.         return $this;
  424.     }
  426.     public function getFloor(): ?string
  427.     {
  428.         return $this->floor;
  429.     }
  431.     public function setFloor(?string $floor): self
  432.     {
  433.         $this->floor = $floor;
  435.         return $this;
  436.     }
  438.     public function getBloque(): ?string
  439.     {
  440.         return $this->bloque;
  441.     }
  443.     public function setBloque(?string $bloque): self
  444.     {
  445.         $this->bloque = $bloque;
  447.         return $this;
  448.     }
  450.     public function getEscalera(): ?string
  451.     {
  452.         return $this->escalera;
  453.     }
  455.     public function setEscalera(?string $escalera): self
  456.     {
  457.         $this->escalera = $escalera;
  459.         return $this;
  460.     }
  462.     public function getProvince(): ?string
  463.     {
  464.         return $this->province;
  465.     }
  467.     public function setProvince(?string $province): self
  468.     {
  469.         $this->province = $province;
  471.         return $this;
  472.     }
  474.     public function getPropertyNumber(): ?string
  475.     {
  476.         return $this->property_number;
  477.     }
  479.     public function setPropertyNumber(?string $property_number): self
  480.     {
  481.         $this->property_number = $property_number;
  483.         return $this;
  484.     }
  486.     public function getPostcode(): ?string
  487.     {
  488.         return $this->postcode;
  489.     }
  491.     public function setPostcode(?string $postcode): self
  492.     {
  493.         $this->postcode = $postcode;
  495.         return $this;
  496.     }
  498.     /**
  499.      * @return Collection<int, Documents>
  500.      */
  501.     public function getDocument(): Collection
  502.     {
  503.         return $this->document;
  504.     }
  506.     public function addDocument(Documents $document): self
  507.     {
  508.         if (!$this->document->contains($document)) {
  509.             $this->document->add($document);
  510.             $document->setUploadedByUser($this);
  511.         }
  513.         return $this;
  514.     }
  516.     public function removeDocument(Documents $document): self
  517.     {
  518.         if ($this->document->removeElement($document)) {
  519.             // set the owning side to null (unless already changed)
  520.             if ($document->getUploadedByUser() === $this) {
  521.                 $document->setUploadedByUser(null);
  522.             }
  523.         }
  525.         return $this;
  526.     }
  528.     /**
  529.      * @return Collection<int, DocsTenants>
  530.      */
  531.     public function getTenantDocument(): Collection
  532.     {
  533.         return $this->tenantDocument;
  534.     }
  536.     public function addTenantDocument(DocsTenants $tenantDocument): self
  537.     {
  538.         if (!$this->tenantDocument->contains($tenantDocument)) {
  539.             $this->tenantDocument->add($tenantDocument);
  540.             $tenantDocument->setUploadedByUser($this);
  541.         }
  543.         return $this;
  544.     }
  546.     public function removeTenantDocument(DocsTenants $tenantDocument): self
  547.     {
  548.         if ($this->tenantDocument->removeElement($tenantDocument)) {
  549.             // set the owning side to null (unless already changed)
  550.             if ($tenantDocument->getUploadedByUser() === $this) {
  551.                 $tenantDocument->setUploadedByUser(null);
  552.             }
  553.         }
  555.         return $this;
  556.     }
  558.     /**
  559.      * @return Collection<int, MonthlyReport>
  560.      */
  561.     public function getMonthlyReports(): Collection
  562.     {
  563.         return $this->monthlyReports;
  564.     }
  566.     public function addMonthlyReport(MonthlyReport $monthlyReport): self
  567.     {
  568.         if (!$this->monthlyReports->contains($monthlyReport)) {
  569.             $this->monthlyReports->add($monthlyReport);
  570.             $monthlyReport->setGeneratedBy($this);
  571.         }
  573.         return $this;
  574.     }
  576.     public function removeMonthlyReport(MonthlyReport $monthlyReport): self
  577.     {
  578.         if ($this->monthlyReports->removeElement($monthlyReport)) {
  579.             // set the owning side to null (unless already changed)
  580.             if ($monthlyReport->getGeneratedBy() === $this) {
  581.                 $monthlyReport->setGeneratedBy(null);
  582.             }
  583.         }
  585.         return $this;
  586.     }
  588.     public function getFlatNumber(): ?string
  589.     {
  590.         return $this->flatNumber;
  591.     }
  593.     public function setFlatNumber(?string $flatNumber): self
  594.     {
  595.         $this->flatNumber = $flatNumber;
  597.         return $this;
  598.     }
  600.     public function getUserType(): ?array
  601.     {
  602.         return $this->userType ?? [];
  603.     }
  605.     public function setUserType(?array $userType): self
  606.     {
  607.         $this->userType = $userType;
  609.         return $this;
  610.     }
  612.     public function getPotentialClient(): ?PotentialClients
  613.     {
  614.         return $this->potentialClient;
  615.     }
  617.     public function setPotentialClient(?PotentialClients $potentialClient): self
  618.     {
  619.         $this->potentialClient = $potentialClient;
  621.         return $this;
  622.     }
  624.     /**
  625.      * @return Collection<int, DocsLandlords>
  626.      */
  627.     public function getDocsLandlords(): Collection
  628.     {
  629.         return $this->docsLandlords;
  630.     }
  632.     public function addDocsLandlord(DocsLandlords $docsLandlord): self
  633.     {
  634.         if (!$this->docsLandlords->contains($docsLandlord)) {
  635.             $this->docsLandlords->add($docsLandlord);
  636.             $docsLandlord->setUploadedBy($this);
  637.         }
  639.         return $this;
  640.     }
  642.     public function removeDocsLandlord(DocsLandlords $docsLandlord): self
  643.     {
  644.         if ($this->docsLandlords->removeElement($docsLandlord)) {
  645.             // set the owning side to null (unless already changed)
  646.             if ($docsLandlord->getUploadedBy() === $this) {
  647.                 $docsLandlord->setUploadedBy(null);
  648.             }
  649.         }
  651.         return $this;
  652.     }
  654.     /**
  655.      * @return Collection<int, Minutes>
  656.      */
  657.     public function getMinutes(): Collection
  658.     {
  659.         return $this->minutes;
  660.     }
  662.     public function addMinute(Minutes $minute): self
  663.     {
  664.         if (!$this->minutes->contains($minute)) {
  665.             $this->minutes->add($minute);
  666.             $minute->setAdmin($this);
  667.         }
  669.         return $this;
  670.     }
  672.     public function removeMinute(Minutes $minute): self
  673.     {
  674.         if ($this->minutes->removeElement($minute)) {
  675.             // set the owning side to null (unless already changed)
  676.             if ($minute->getAdmin() === $this) {
  677.                 $minute->setAdmin(null);
  678.             }
  679.         }
  681.         return $this;
  682.     }
  684.     /**
  685.      * @return Collection<int, DocsPotentials>
  686.      */
  687.     public function getDocsPotentials(): Collection
  688.     {
  689.         return $this->docsPotentials;
  690.     }
  692.     public function addDocsPotential(DocsPotentials $docsPotential): static
  693.     {
  694.         if (!$this->docsPotentials->contains($docsPotential)) {
  695.             $this->docsPotentials->add($docsPotential);
  696.             $docsPotential->setUploadedBy($this);
  697.         }
  699.         return $this;
  700.     }
  702.     public function removeDocsPotential(DocsPotentials $docsPotential): static
  703.     {
  704.         if ($this->docsPotentials->removeElement($docsPotential)) {
  705.             // set the owning side to null (unless already changed)
  706.             if ($docsPotential->getUploadedBy() === $this) {
  707.                 $docsPotential->setUploadedBy(null);
  708.             }
  709.         }
  711.         return $this;
  712.     }
  714.     /**
  715.      * @return Collection<int, Event>
  716.      */
  717.     public function getEvents(): Collection
  718.     {
  719.         return $this->events;
  720.     }
  722.     public function addEvent(Event $event): static
  723.     {
  724.         if (!$this->events->contains($event)) {
  725.             $this->events->add($event);
  726.             $event->addUser($this);
  727.         }
  729.         return $this;
  730.     }
  732.     public function removeEvent(Event $event): static
  733.     {
  734.         if ($this->events->removeElement($event)) {
  735.             $event->removeUser($this);
  736.         }
  738.         return $this;
  739.     }
  741.  
  742.   
  743. }