src/Entity/User.php line 19

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use App\Entity\SuperClass\BaseEntity;
  6. use App\Repository\UserRepository;
  7. use Doctrine\Common\Collections\ArrayCollection;
  8. use Doctrine\Common\Collections\Collection;
  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;
  13. use Symfony\Component\Validator\Constraints as Assert;
  15. /**
  16. * @ORM\Entity(repositoryClass=UserRepository::class)
  17. * @UniqueEntity("email" , message="Email is already registered")
  18. */
  19. class User extends BaseEntity implements UserInterface, PasswordAuthenticatedUserInterface
  20. {
  21. /**
  22. * @ORM\Column(type="string", length=180, unique=true)
  23. * @Assert\NotBlank
  24. * @Assert\Email(
  25. * message = "The email '{{ value }}' is not a valid email."
  26. * )
  27. */
  28. private $email;
  30. /**
  31. * @ORM\Column(type="json")
  32. */
  33. private $roles = [];
  35. /**
  36. * @var string The hashed password
  37. * @ORM\Column(type="string")
  38. * @Assert\NotBlank
  39. * @Assert\Length(
  40. * min = 8,
  41. * max = 100
  42. * )
  43. */
  44. private $password;
  46. /**
  47. * @ORM\OneToMany(targetEntity=Blog::class, mappedBy="created_by", cascade={"persist"})
  48. */
  49. private $blogs;
  51. /**
  52. * @ORM\OneToMany(targetEntity=Templates::class, mappedBy="created_by", cascade={"persist"})
  53. */
  54. private $templates;
  56. /**
  57. * @ORM\OneToMany(targetEntity=MediaObject::class, mappedBy="created_by")
  58. */
  59. private $mediaObjects;
  61. /**
  62. * @ORM\OneToMany(targetEntity=Comment::class, mappedBy="created_by")
  63. */
  64. private $comments;
  66. /**
  67. * @ORM\OneToMany(targetEntity=Category::class, mappedBy="created_by")
  68. */
  69. private $categories;
  71. /**
  72. * @ORM\OneToMany(targetEntity=Post::class, mappedBy="created_by")
  73. */
  74. private $posts;
  76. /**
  77. * @ORM\OneToMany(targetEntity=Product::class, mappedBy="created_by")
  78. */
  79. private $products;
  81. /**
  82. * @ORM\OneToOne(targetEntity=Customer::class, mappedBy="owner", cascade={"persist", "remove"})
  83. */
  84. private $customer;
  86. /**
  87. * @ORM\Column(type="boolean")
  88. */
  89. private $enabled = 0;
  91. /**
  92. * @ORM\OneToOne(targetEntity=Profile::class, mappedBy="owner", cascade={"persist", "remove"})
  93. */
  94. private $profile;
  96. /**
  97. * @ORM\OneToMany(targetEntity=Address::class, mappedBy="owner", cascade={"persist"})
  98. */
  99. private $addresses;
  101. /**
  102. * @ORM\OneToMany(targetEntity=Source::class, mappedBy="owner")
  103. */
  104. private $sources;
  106. /**
  107. * @ORM\ManyToOne(targetEntity=User::class, inversedBy="created_by")
  108. */
  109. private $user;
  111. /**
  112. * @ORM\OneToMany(targetEntity=User::class, mappedBy="user")
  113. */
  114. private $created_by;
  116. /**
  117. * @ORM\OneToMany(targetEntity=Cart::class, mappedBy="created_by")
  118. */
  119. private $carts;
  121. /**
  122. * @ORM\OneToMany(targetEntity=Cart::class, mappedBy="owner")
  123. */
  124. private $cart;
  126. /**
  127. * @ORM\OneToMany(targetEntity=Profile::class, mappedBy="created_by")
  128. */
  129. private $profiles;
  131. public function __construct()
  132. {
  133. $this->blogs = new ArrayCollection();
  134. $this->templates = new ArrayCollection();
  135. $this->mediaObjects = new ArrayCollection();
  136. $this->comments = new ArrayCollection();
  137. $this->categories = new ArrayCollection();
  138. $this->posts = new ArrayCollection();
  139. $this->products = new ArrayCollection();
  140. $this->addresses = new ArrayCollection();
  141. $this->sources = new ArrayCollection();
  142. $this->created_by = new ArrayCollection();
  143. $this->carts = new ArrayCollection();
  144. $this->cart = new ArrayCollection();
  145. $this->profiles = new ArrayCollection();
  146. }
  148. public function getId(): ?int
  149. {
  150. return $this->id;
  151. }
  153. public function getEmail(): ?string
  154. {
  155. return $this->email;
  156. }
  158. public function setEmail(string $email): self
  159. {
  160. $this->email = $email;
  162. return $this;
  163. }
  165. /**
  166. * A visual identifier that represents this user.
  167. *
  168. * @see UserInterface
  169. */
  170. public function getUserIdentifier(): string
  171. {
  172. return (string) $this->email;
  173. }
  175. /**
  176. * @deprecated since Symfony 5.3, use getUserIdentifier instead
  177. */
  178. public function getUsername(): string
  179. {
  180. return (string) $this->email;
  181. }
  183. /**
  184. * @see UserInterface
  185. */
  186. public function getRoles(): array
  187. {
  188. $roles = $this->roles;
  189. // guarantee every user at least has ROLE_USER
  190. $roles[] = 'ROLE_USER';
  192. return array_unique($roles);
  193. }
  195. public function setRoles(array $roles): self
  196. {
  197. $this->roles = $roles;
  199. return $this;
  200. }
  202. /**
  203. * @see PasswordAuthenticatedUserInterface
  204. */
  205. public function getPassword(): string
  206. {
  207. return $this->password;
  208. }
  210. public function setPassword(string $password): self
  211. {
  212. $this->password = $password;
  214. return $this;
  215. }
  217. /**
  218. * Returning a salt is only needed, if you are not using a modern
  219. * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  220. *
  221. * @see UserInterface
  222. */
  223. public function getSalt(): ?string
  224. {
  225. return null;
  226. }
  228. /**
  229. * @see UserInterface
  230. */
  231. public function eraseCredentials()
  232. {
  233. // If you store any temporary, sensitive data on the user, clear it here
  234. // $this->plainPassword = null;
  235. }
  237. /**
  238. * @return Collection|Blog[]
  239. */
  240. public function getBlogs(): Collection
  241. {
  242. return $this->blogs;
  243. }
  245. public function addBlog(Blog $blog): self
  246. {
  247. if (!$this->blogs->contains($blog)) {
  248. $this->blogs[] = $blog;
  249. $blog->setCreatedBy($this);
  250. }
  252. return $this;
  253. }
  255. public function removeBlog(Blog $blog): self
  256. {
  257. if ($this->blogs->removeElement($blog)) {
  258. // set the owning side to null (unless already changed)
  259. if ($blog->getCreatedBy() === $this) {
  260. $blog->setCreatedBy(null);
  261. }
  262. }
  264. return $this;
  265. }
  267. /**
  268. * @return Collection|Templates[]
  269. */
  270. public function getTemplates(): Collection
  271. {
  272. return $this->templates;
  273. }
  275. public function addTemplate(Templates $template): self
  276. {
  277. if (!$this->templates->contains($template)) {
  278. $this->templates[] = $template;
  279. $template->setCreatedBy($this);
  280. }
  282. return $this;
  283. }
  285. public function removeTemplate(Templates $template): self
  286. {
  287. if ($this->templates->removeElement($template)) {
  288. // set the owning side to null (unless already changed)
  289. if ($template->getCreatedBy() === $this) {
  290. $template->setCreatedBy(null);
  291. }
  292. }
  294. return $this;
  295. }
  297. /**
  298. * @return Collection|MediaObject[]
  299. */
  300. public function getMediaObjects(): Collection
  301. {
  302. return $this->mediaObjects;
  303. }
  305. public function addMediaObject(MediaObject $mediaObject): self
  306. {
  307. if (!$this->mediaObjects->contains($mediaObject)) {
  308. $this->mediaObjects[] = $mediaObject;
  309. $mediaObject->setCreatedBy($this);
  310. }
  312. return $this;
  313. }
  315. public function removeMediaObject(MediaObject $mediaObject): self
  316. {
  317. if ($this->mediaObjects->removeElement($mediaObject)) {
  318. // set the owning side to null (unless already changed)
  319. if ($mediaObject->getCreatedBy() === $this) {
  320. $mediaObject->setCreatedBy(null);
  321. }
  322. }
  324. return $this;
  325. }
  327. /**
  328. * @return Collection|Comment[]
  329. */
  330. public function getComments(): Collection
  331. {
  332. return $this->comments;
  333. }
  335. public function addComment(Comment $comment): self
  336. {
  337. if (!$this->comments->contains($comment)) {
  338. $this->comments[] = $comment;
  339. $comment->setCreatedBy($this);
  340. }
  342. return $this;
  343. }
  345. public function removeComment(Comment $comment): self
  346. {
  347. if ($this->comments->removeElement($comment)) {
  348. // set the owning side to null (unless already changed)
  349. if ($comment->getCreatedBy() === $this) {
  350. $comment->setCreatedBy(null);
  351. }
  352. }
  354. return $this;
  355. }
  357. /**
  358. * @return Collection|Category[]
  359. */
  360. public function getCategories(): Collection
  361. {
  362. return $this->categories;
  363. }
  365. public function addCategory(Category $category): self
  366. {
  367. if (!$this->categories->contains($category)) {
  368. $this->categories[] = $category;
  369. $category->setCreatedBy($this);
  370. }
  372. return $this;
  373. }
  375. public function removeCategory(Category $category): self
  376. {
  377. if ($this->categories->removeElement($category)) {
  378. // set the owning side to null (unless already changed)
  379. if ($category->getCreatedBy() === $this) {
  380. $category->setCreatedBy(null);
  381. }
  382. }
  384. return $this;
  385. }
  387. /**
  388. * @return Collection|Post[]
  389. */
  390. public function getPosts(): Collection
  391. {
  392. return $this->posts;
  393. }
  395. public function addPost(Post $post): self
  396. {
  397. if (!$this->posts->contains($post)) {
  398. $this->posts[] = $post;
  399. $post->setCreatedBy($this);
  400. }
  402. return $this;
  403. }
  405. public function removePost(Post $post): self
  406. {
  407. if ($this->posts->removeElement($post)) {
  408. // set the owning side to null (unless already changed)
  409. if ($post->getCreatedBy() === $this) {
  410. $post->setCreatedBy(null);
  411. }
  412. }
  414. return $this;
  415. }
  417. /**
  418. * @return Collection|Product[]
  419. */
  420. public function getProducts(): Collection
  421. {
  422. return $this->products;
  423. }
  425. public function addProduct(Product $product): self
  426. {
  427. if (!$this->products->contains($product)) {
  428. $this->products[] = $product;
  429. $product->setCreatedBy($this);
  430. }
  432. return $this;
  433. }
  435. public function removeProduct(Product $product): self
  436. {
  437. if ($this->products->removeElement($product)) {
  438. // set the owning side to null (unless already changed)
  439. if ($product->getCreatedBy() === $this) {
  440. $product->setCreatedBy(null);
  441. }
  442. }
  444. return $this;
  445. }
  447. public function getCustomer(): ?Customer
  448. {
  449. return $this->customer;
  450. }
  452. public function setCustomer(Customer $customer): self
  453. {
  454. // set the owning side of the relation if necessary
  455. if ($customer->getOwner() !== $this) {
  456. $customer->setOwner($this);
  457. }
  459. $this->customer = $customer;
  461. return $this;
  462. }
  464. public function getEnabled(): ?bool
  465. {
  466. return $this->enabled;
  467. }
  469. public function setEnabled(bool $enabled): self
  470. {
  471. $this->enabled = $enabled;
  473. return $this;
  474. }
  476. public function getProfile(): ?Profile
  477. {
  478. return $this->profile;
  479. }
  481. public function setProfile(?Profile $profile): self
  482. {
  483. // unset the owning side of the relation if necessary
  484. if ($profile === null && $this->profile !== null) {
  485. $this->profile->setOwner(null);
  486. }
  488. // set the owning side of the relation if necessary
  489. if ($profile !== null && $profile->getCreatedBy() !== $this) {
  490. $profile->setCreatedBy($this);
  491. }
  493. $this->profile = $profile;
  495. return $this;
  496. }
  498. /**
  499. * @return Collection|Address[]
  500. */
  501. public function getAddresses(): Collection
  502. {
  503. return $this->addresses;
  504. }
  506. public function addAddress(Address $address): self
  507. {
  508. if (!$this->addresses->contains($address)) {
  509. $this->addresses[] = $address;
  510. $address->setOwner($this);
  511. }
  513. return $this;
  514. }
  516. public function removeAddress(Address $address): self
  517. {
  518. if ($this->addresses->removeElement($address)) {
  519. // set the owning side to null (unless already changed)
  520. if ($address->getOwner() === $this) {
  521. $address->setOwner(null);
  522. }
  523. }
  525. return $this;
  526. }
  528. public function __toString()
  529. {
  530. return $this->getEmail();
  531. }
  533. /**
  534. * @return Collection|Source[]
  535. */
  536. public function getSources(): Collection
  537. {
  538. return $this->sources;
  539. }
  541. public function addSource(Source $source): self
  542. {
  543. if (!$this->sources->contains($source)) {
  544. $this->sources[] = $source;
  545. $source->setOwner($this);
  546. }
  548. return $this;
  549. }
  551. public function removeSource(Source $source): self
  552. {
  553. if ($this->sources->removeElement($source)) {
  554. // set the owning side to null (unless already changed)
  555. if ($source->getOwner() === $this) {
  556. $source->setOwner(null);
  557. }
  558. }
  560. return $this;
  561. }
  563. public function getUser(): ?self
  564. {
  565. return $this->user;
  566. }
  568. public function setUser(?self $user): self
  569. {
  570. $this->user = $user;
  572. return $this;
  573. }
  575. /**
  576. * @return Collection<int, self>
  577. */
  578. public function getCreatedBy(): Collection
  579. {
  580. return $this->created_by;
  581. }
  583. public function addCreatedBy(self $createdBy): self
  584. {
  585. if (!$this->created_by->contains($createdBy)) {
  586. $this->created_by[] = $createdBy;
  587. $createdBy->setUser($this);
  588. }
  590. return $this;
  591. }
  593. public function removeCreatedBy(self $createdBy): self
  594. {
  595. if ($this->created_by->removeElement($createdBy)) {
  596. // set the owning side to null (unless already changed)
  597. if ($createdBy->getUser() === $this) {
  598. $createdBy->setUser(null);
  599. }
  600. }
  602. return $this;
  603. }
  605. /**
  606. * @return Collection<int, Cart>
  607. */
  608. public function getCarts(): Collection
  609. {
  610. return $this->carts;
  611. }
  613. public function addCart(Cart $cart): self
  614. {
  615. if (!$this->carts->contains($cart)) {
  616. $this->carts[] = $cart;
  617. $cart->setCreatedBy($this);
  618. }
  620. return $this;
  621. }
  623. public function removeCart(Cart $cart): self
  624. {
  625. if ($this->carts->removeElement($cart)) {
  626. // set the owning side to null (unless already changed)
  627. if ($cart->getCreatedBy() === $this) {
  628. $cart->setCreatedBy(null);
  629. }
  630. }
  632. return $this;
  633. }
  635. /**
  636. * @return Collection<int, Cart>
  637. */
  638. public function getCart(): Collection
  639. {
  640. return $this->cart;
  641. }
  643. /**
  644. * @return Collection<int, Profile>
  645. */
  646. public function getProfiles(): Collection
  647. {
  648. return $this->profiles;
  649. }
  651. public function addProfile(Profile $profile): self
  652. {
  653. if (!$this->profiles->contains($profile)) {
  654. $this->profiles[] = $profile;
  655. $profile->setCreatedBy($this);
  656. }
  658. return $this;
  659. }
  661. public function removeProfile(Profile $profile): self
  662. {
  663. if ($this->profiles->removeElement($profile)) {
  664. // set the owning side to null (unless already changed)
  665. if ($profile->getCreatedBy() === $this) {
  666. $profile->setCreatedBy(null);
  667. }
  668. }
  670. return $this;
  671. }
  672. }