src/Entity/User.php line 23

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use Serializable;
  6. use Doctrine\ORM\Mapping as ORM;
  7. use App\Repository\UserRepository;
  8. use Doctrine\ORM\Mapping\InheritanceType;
  9. use Doctrine\ORM\Mapping\DiscriminatorMap;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\ORM\Mapping\DiscriminatorColumn;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Symfony\Component\Validator\Constraints as Assert;
  14. use Symfony\Component\Security\Core\User\UserInterface;
  15. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  16. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. #[ORM\Entity(repositoryClass: UserRepository::class)]
  19. #[UniqueEntity(fields: ['email'], message: 'Un compte existe déjà avec cet email')]
  20. #[InheritanceType('JOINED')]
  21. #[DiscriminatorColumn(name: 'type', type: 'string')]
  22. #[DiscriminatorMap(['coach' => 'Coach', 'club' => 'Club', 'operator' => 'Operator', 'user' => 'User', 'trainee' => 'Trainee', 'admin' => 'Admin'])]
  23. abstract class User implements UserInterface, PasswordAuthenticatedUserInterface
  24. {
  25.     #[ORM\Id]
  26.     #[ORM\GeneratedValue]
  27.     #[ORM\Column(type: 'integer')]
  28.     private $id;
  30.     #[ORM\Column(type: 'string', length: 255)]
  31.     private $firstname;
  33.     #[ORM\Column(type: 'string', length: 255)]
  34.     private $lastname;
  36.     #[ORM\Column(type: 'string', length: 50, nullable: true)]
  37.     private $telephone;
  39.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  40.     private $email;
  42.     /**
  43.      * @var string The hashed password
  44.      */
  45.     #[ORM\Column(type: 'string')]
  46.     private $password;
  48.     #[ORM\Column(type: 'boolean')]
  49.     private $activated;
  51.     #[ORM\Column(type: 'boolean')]
  52.     private $notification;
  54.     #[ORM\OneToOne(targetEntity: Address::class, inversedBy: 'owner', cascade: ['persist', 'remove'])]
  55.     private $address;
  57.     #[ORM\Column(type: 'datetime', nullable: true)]
  58.     private $registeredAt;
  60.     #[ORM\Column(type: 'string', length: 255)]
  61.     private $token;
  63.     #[ORM\ManyToMany(targetEntity: Role::class, inversedBy: 'users')]
  64.     private $userRoles;
  66.     #[ORM\Column(type: 'string', length: 255)]
  67.     private $photo;
  69.     #[ORM\Column(type: 'string', length: 255)]
  70.     private $slug;
  72.     #[ORM\Column(type: 'boolean')]
  73.     private $isPro;
  75.     #[ORM\OneToMany(targetEntity: Subscription::class, mappedBy: 'pro')]
  76.     private $subscriptions;
  78.     #[ORM\OneToMany(targetEntity: Course::class, mappedBy: 'owner')]
  79.     private $courses;
  81.     #[ORM\OneToOne(targetEntity: ProInfo::class, inversedBy: 'pro', cascade: ['persist', 'remove'])]
  82.     private $proInfo;
  84.     #[ORM\Column(type: 'boolean', nullable: true)]
  85.     private $hasAccess;
  87.     #[ORM\ManyToMany(targetEntity: Language::class, inversedBy: 'users')]
  88.     private $languages;
  90.     #[ORM\OneToOne(targetEntity: StripeInfo::class, inversedBy: 'user', cascade: ['persist', 'remove'])]
  91.     private $stripeInfo;
  93.     #[ORM\OneToMany(targetEntity: Message::class, mappedBy: 'sender')]
  94.     private $sentMessages;
  96.     #[ORM\OneToMany(targetEntity: Participant::class, mappedBy: 'user')]
  97.     private $participations;
  99.     #[ORM\OneToMany(targetEntity: Conversation::class, mappedBy: 'trainee')]
  100.     private $traineeConversations;
  102.     #[ORM\OneToMany(targetEntity: Conversation::class, mappedBy: 'pro')]
  103.     private $proConversations;
  105.     #[ORM\OneToMany(targetEntity: ProViewsStat::class, mappedBy: 'pro', orphanRemoval: true)]
  106.     private $proViewsStats;
  108.     #[ORM\Column(type: 'string', length: 255)]
  109.     private $status;
  111.     #[ORM\Column(type: 'boolean')]
  112.     private $hasAcceptedTerms;
  114.     #[ORM\ManyToMany(targetEntity: Trainee::class, mappedBy: 'proFavorites')]
  115.     private $traineesFavorites;
  117.     #[ORM\OneToMany(targetEntity: Invoice::class, mappedBy: 'pro')]
  118.     private $invoices;
  120.     #[ORM\Column(type: 'boolean', nullable: true)]
  121.     private $isAmbassador;
  123.     #[ORM\Column(type: 'string', length: 255)]
  124.     private $language;
  126.     #[ORM\OneToMany(targetEntity: Address::class, mappedBy: 'pro', orphanRemoval: true)]
  127.     private $areas;
  129.     #[ORM\Column(length: 255, nullable: true)]
  130.     private ?string $timezone = null;
  132.     #[ORM\Column(length: 255, nullable: true)]
  133.     private ?string $phoneCode = null;
  135.     #[ORM\Column(nullable: true)]
  136.     private ?bool $newsletter = null;
  138.     #[ORM\OneToMany(mappedBy: 'pro', targetEntity: ProDescription::class)]
  139.     private Collection $proDescriptions;
  141.     #[ORM\ManyToMany(targetEntity: Note::class, mappedBy: 'associatedPros')]
  142.     private Collection $notes;
  144.     #[ORM\OneToMany(mappedBy: 'pro', targetEntity: NoteRequest::class)]
  145.     private Collection $noteRequests;
  148.     public function __construct()
  149.     {
  150.         $this->userRoles = new ArrayCollection();
  151.         $this->subscriptions = new ArrayCollection();
  152.         $this->courses = new ArrayCollection();
  153.         $this->languages = new ArrayCollection();
  154.         $this->sentMessages = new ArrayCollection();
  155.         $this->participations = new ArrayCollection();
  156.         $this->traineeConversations = new ArrayCollection();
  157.         $this->proConversations = new ArrayCollection();
  158.         $this->proViewsStats = new ArrayCollection();
  159.         $this->traineesFavorites = new ArrayCollection();
  160.         $this->invoices = new ArrayCollection();
  161.         $this->areas = new ArrayCollection();
  162.         $this->proDescriptions = new ArrayCollection();
  163.         $this->notes = new ArrayCollection();
  164.         $this->noteRequests = new ArrayCollection();
  165.     }
  167.     //Getters and Setters
  168.     public function getId(): ?int
  169.     {
  170.         return $this->id;
  171.     }
  173.     public function fullname() {
  174.         return $this->firstname . ' ' . $this->lastname;
  175.     }
  177.     public function getProType() {
  178.         if ($this instanceof Coach) {
  179.             $type = 'coach';
  180.         } else if ($this instanceof Club) {
  181.             $type = 'club';
  182.         } else {
  183.             $type = 'operator';
  184.         }
  186.         return $type;
  187.     }
  189.     public function getCurrentSubscription() {
  190.         return $this->subscriptions->last() ?? null;
  191.     }
  193.     /**
  194.      * Get the value of firstname
  195.      */ 
  196.     public function getFirstname()
  197.     {
  198.         return $this->firstname;
  199.     }
  201.     /**
  202.      * Set the value of firstname
  203.      *
  204.      * @return  self
  205.      */ 
  206.     public function setFirstname($firstname)
  207.     {
  208.         $this->firstname = $firstname;
  210.         return $this;
  211.     }
  213.     /**
  214.      * Get the value of lastname
  215.      */ 
  216.     public function getLastname()
  217.     {
  218.         return $this->lastname;
  219.     }
  221.     /**
  222.      * Set the value of lastname
  223.      *
  224.      * @return  self
  225.      */ 
  226.     public function setLastname($lastname)
  227.     {
  228.         $this->lastname = $lastname;
  230.         return $this;
  231.     }
  233.     /**
  234.      * Get the value of telephone
  235.      */ 
  236.     public function getTelephone()
  237.     {
  238.         return $this->telephone;
  239.     }
  241.     /**
  242.      * Set the value of telephone
  243.      *
  244.      * @return  self
  245.      */ 
  246.     public function setTelephone($telephone)
  247.     {
  248.         $this->telephone = $telephone;
  250.         return $this;
  251.     }
  253.     public function getEmail(): ?string
  254.     {
  255.         return $this->email;
  256.     }
  258.     public function setEmail(string $email): self
  259.     {
  260.         $this->email = $email;
  262.         return $this;
  263.     }
  265.     /**
  266.      * @see UserInterface
  267.      */
  268.     public function getPassword(): string
  269.     {
  270.         return (string) $this->password;
  271.     }
  273.     public function setPassword(string $password): self
  274.     {
  275.         $this->password = $password;
  277.         return $this;
  278.     }
  280.     /**
  281.      * Get the value of activated
  282.      */ 
  283.     public function getActivated()
  284.     {
  285.         return $this->activated;
  286.     }
  288.     /**
  289.      * Set the value of activated
  290.      *
  291.      * @return  self
  292.      */ 
  293.     public function setActivated($activated)
  294.     {
  295.         $this->activated = $activated;
  297.         return $this;
  298.     }
  300.     /**
  301.      * Get the value of notification
  302.      */ 
  303.     public function getNotification()
  304.     {
  305.         return $this->notification;
  306.     }
  308.     /**
  309.      * Set the value of notification
  310.      *
  311.      * @return  self
  312.      */ 
  313.     public function setNotification($notification)
  314.     {
  315.         $this->notification = $notification;
  317.         return $this;
  318.     }
  320.     public function getAddress(): ?Address
  321.     {
  322.         return $this->address;
  323.     }
  325.     public function setAddress(?Address $address): self
  326.     {
  327.         $this->address = $address;
  329.         return $this;
  330.     }
  332.     public function getRegisteredAt(): ?\DateTimeInterface
  333.     {
  334.         return $this->registeredAt;
  335.     }
  337.     public function setRegisteredAt(?\DateTimeInterface $registeredAt): self
  338.     {
  339.         $this->registeredAt = $registeredAt;
  341.         return $this;
  342.     }
  344.     public function getToken(): ?string
  345.     {
  346.         return $this->token;
  347.     }
  349.     public function setToken(string $token): self
  350.     {
  351.         $this->token = $token;
  353.         return $this;
  354.     }
  356.     public function getSalt(){}
  358.     public function eraseCredentials(){}
  360.     public function getRoles()
  361.     {
  362.         $roles = $this->userRoles->map(function($role){
  363.             return $role->getTitle();
  364.         })->toArray();
  366.         $roles[] = 'ROLE_USER';
  368.         return $roles;
  369.     }
  371.     /**
  372.      * A visual identifier that represents this user.
  373.      *
  374.      * @see UserInterface
  375.      */
  376.     public function getUsername()
  377.     {
  378.         return $this->email;
  379.     }
  381.     /**
  382.      * @return Collection|Role[]
  383.      */
  384.     public function getUserRoles(): Collection
  385.     {
  386.         return $this->userRoles;
  387.     }
  389.     public function addUserRole(Role $userRole): self
  390.     {
  391.         if ($this->userRoles == null || !$this->userRoles->contains($userRole)) {
  392.             $this->userRoles[] = $userRole;
  393.         }
  395.         return $this;
  396.     }
  398.     public function removeUserRole(Role $userRole): self
  399.     {
  400.         $this->userRoles->removeElement($userRole);
  402.         return $this;
  403.     }
  405.     public function getPhoto()
  406.     {
  407.         return $this->photo;
  408.     }
  410.     public function setPhoto($photo): self
  411.     {
  412.         $this->photo = $photo;
  414.         return $this;
  415.     }
  417.     public function getSlug(): ?string
  418.     {
  419.         return $this->slug;
  420.     }
  422.     public function setSlug(string $slug): self
  423.     {
  424.         $this->slug = $slug;
  426.         return $this;
  427.     }
  429.     public function getIsPro(): ?bool
  430.     {
  431.         return $this->isPro;
  432.     }
  434.     public function setIsPro(bool $isPro): self
  435.     {
  436.         $this->isPro = $isPro;
  438.         return $this;
  439.     }
  441.     /**
  442.      * @return Collection|Subscription[]
  443.      */
  444.     public function getSubscriptions(): Collection
  445.     {
  446.         return $this->subscriptions;
  447.     }
  449.     public function addSubscription(Subscription $subscription): self
  450.     {
  451.         if (!$this->subscriptions->contains($subscription)) {
  452.             $this->subscriptions[] = $subscription;
  453.             $subscription->setPro($this);
  454.         }
  456.         return $this;
  457.     }
  459.     public function removeSubscription(Subscription $subscription): self
  460.     {
  461.         if ($this->subscriptions->removeElement($subscription)) {
  462.             // set the owning side to null (unless already changed)
  463.             if ($subscription->getPro() === $this) {
  464.                 $subscription->setPro(null);
  465.             }
  466.         }
  468.         return $this;
  469.     }
  471.     /**
  472.      * @return Collection|Course[]
  473.      */
  474.     public function getCourses(): Collection
  475.     {
  476.         return $this->courses;
  477.     }
  479.     public function addCourse(Course $course): self
  480.     {
  481.         if (!$this->courses->contains($course)) {
  482.             $this->courses[] = $course;
  483.             $course->setOwner($this);
  484.         }
  486.         return $this;
  487.     }
  489.     public function removeCourse(Course $course): self
  490.     {
  491.         if ($this->courses->removeElement($course)) {
  492.             // set the owning side to null (unless already changed)
  493.             if ($course->getOwner() === $this) {
  494.                 $course->setOwner(null);
  495.             }
  496.         }
  498.         return $this;
  499.     }
  501.     public function getProInfo(): ?ProInfo
  502.     {
  503.         return $this->proInfo;
  504.     }
  506.     public function setProInfo(?ProInfo $proInfo): self
  507.     {
  508.         $this->proInfo = $proInfo;
  510.         return $this;
  511.     }
  513.     public function getHasAccess(): ?bool
  514.     {
  515.         return $this->hasAccess;
  516.     }
  518.     public function setHasAccess(bool $hasAccess): self
  519.     {
  520.         $this->hasAccess = $hasAccess;
  522.         return $this;
  523.     }
  525.     /**
  526.      * @return Collection|Language[]
  527.      */
  528.     public function getLanguages(): Collection
  529.     {
  530.         return $this->languages;
  531.     }
  533.     public function addLanguage(Language $language): self
  534.     {
  535.         if (!$this->languages->contains($language)) {
  536.             $this->languages[] = $language;
  537.         }
  539.         return $this;
  540.     }
  542.     public function removeLanguage(Language $language): self
  543.     {
  544.         $this->languages->removeElement($language);
  546.         return $this;
  547.     }
  549.     public function getStripeInfo(): ?StripeInfo
  550.     {
  551.         return $this->stripeInfo;
  552.     }
  554.     public function setStripeInfo(?StripeInfo $stripeInfo): self
  555.     {
  556.         $this->stripeInfo = $stripeInfo;
  558.         return $this;
  559.     }
  561.     /**
  562.      * @return Collection|Message[]
  563.      */
  564.     public function getSentMessages(): Collection
  565.     {
  566.         return $this->sentMessages;
  567.     }
  569.     public function addSentMessage(Message $sentMessage): self
  570.     {
  571.         if (!$this->sentMessages->contains($sentMessage)) {
  572.             $this->sentMessages[] = $sentMessage;
  573.             $sentMessage->setSender($this);
  574.         }
  576.         return $this;
  577.     }
  579.     public function removeSentMessage(Message $sentMessage): self
  580.     {
  581.         if ($this->sentMessages->removeElement($sentMessage)) {
  582.             // set the owning side to null (unless already changed)
  583.             if ($sentMessage->getSender() === $this) {
  584.                 $sentMessage->setSender(null);
  585.             }
  586.         }
  588.         return $this;
  589.     }
  591.     /**
  592.      * @return Collection|Participant[]
  593.      */
  594.     public function getParticipations(): Collection
  595.     {
  596.         return $this->participations;
  597.     }
  599.     public function addParticipation(Participant $participation): self
  600.     {
  601.         if (!$this->participations->contains($participation)) {
  602.             $this->participations[] = $participation;
  603.             $participation->setUser($this);
  604.         }
  606.         return $this;
  607.     }
  609.     public function removeParticipation(Participant $participation): self
  610.     {
  611.         if ($this->participations->removeElement($participation)) {
  612.             // set the owning side to null (unless already changed)
  613.             if ($participation->getUser() === $this) {
  614.                 $participation->setUser(null);
  615.             }
  616.         }
  618.         return $this;
  619.     }
  621.     /**
  622.      * @return Collection|Conversation[]
  623.      */
  624.     public function getTraineeConversations(): Collection
  625.     {
  626.         return $this->traineeConversations;
  627.     }
  629.     public function addTraineeConversation(Conversation $traineeConversation): self
  630.     {
  631.         if (!$this->traineeConversations->contains($traineeConversation)) {
  632.             $this->traineeConversations[] = $traineeConversation;
  633.             $traineeConversation->setTrainee($this);
  634.         }
  636.         return $this;
  637.     }
  639.     public function removeTraineeConversation(Conversation $traineeConversation): self
  640.     {
  641.         if ($this->traineeConversations->removeElement($traineeConversation)) {
  642.             // set the owning side to null (unless already changed)
  643.             if ($traineeConversation->getTrainee() === $this) {
  644.                 $traineeConversation->setTrainee(null);
  645.             }
  646.         }
  648.         return $this;
  649.     }
  651.     /**
  652.      * @return Collection|Conversation[]
  653.      */
  654.     public function getProConversations(): Collection
  655.     {
  656.         return $this->proConversations;
  657.     }
  659.     public function addProConversation(Conversation $proConversation): self
  660.     {
  661.         if (!$this->proConversations->contains($proConversation)) {
  662.             $this->proConversations[] = $proConversation;
  663.             $proConversation->setPro($this);
  664.         }
  666.         return $this;
  667.     }
  669.     public function removeProConversation(Conversation $proConversation): self
  670.     {
  671.         if ($this->proConversations->removeElement($proConversation)) {
  672.             // set the owning side to null (unless already changed)
  673.             if ($proConversation->getPro() === $this) {
  674.                 $proConversation->setPro(null);
  675.             }
  676.         }
  678.         return $this;
  679.     }
  681.     /**
  682.      * @return Collection|ProViewsStat[]
  683.      */
  684.     public function getProViewsStats(): Collection
  685.     {
  686.         return $this->proViewsStats;
  687.     }
  689.     public function addProViewsStat(ProViewsStat $proViewsStat): self
  690.     {
  691.         if (!$this->proViewsStats->contains($proViewsStat)) {
  692.             $this->proViewsStats[] = $proViewsStat;
  693.             $proViewsStat->setPro($this);
  694.         }
  696.         return $this;
  697.     }
  699.     public function removeProViewsStat(ProViewsStat $proViewsStat): self
  700.     {
  701.         if ($this->proViewsStats->removeElement($proViewsStat)) {
  702.             // set the owning side to null (unless already changed)
  703.             if ($proViewsStat->getPro() === $this) {
  704.                 $proViewsStat->setPro(null);
  705.             }
  706.         }
  708.         return $this;
  709.     }
  711.     public function getStatus(): ?string
  712.     {
  713.         return $this->status;
  714.     }
  716.     public function setStatus(string $status): self
  717.     {
  718.         $this->status = $status;
  720.         return $this;
  721.     }
  723.     public function getHasAcceptedTerms(): ?bool
  724.     {
  725.         return $this->hasAcceptedTerms;
  726.     }
  728.     public function setHasAcceptedTerms(bool $hasAcceptedTerms): self
  729.     {
  730.         $this->hasAcceptedTerms = $hasAcceptedTerms;
  732.         return $this;
  733.     }
  735.     /**
  736.      * @return Collection|Trainee[]
  737.      */
  738.     public function getTraineesFavorites(): Collection
  739.     {
  740.         return $this->traineesFavorites;
  741.     }
  743.     public function addTraineesFavorite(Trainee $traineesFavorite): self
  744.     {
  745.         if (!$this->traineesFavorites->contains($traineesFavorite)) {
  746.             $this->traineesFavorites[] = $traineesFavorite;
  747.             $traineesFavorite->addProFavorite($this);
  748.         }
  750.         return $this;
  751.     }
  753.     public function removeTraineesFavorite(Trainee $traineesFavorite): self
  754.     {
  755.         if ($this->traineesFavorites->removeElement($traineesFavorite)) {
  756.             $traineesFavorite->removeProFavorite($this);
  757.         }
  759.         return $this;
  760.     }
  762.     /**
  763.      * @return Collection|Invoice[]
  764.      */
  765.     public function getInvoices(): Collection
  766.     {
  767.         return $this->invoices;
  768.     }
  770.     public function addInvoice(Invoice $invoice): self
  771.     {
  772.         if (!$this->invoices->contains($invoice)) {
  773.             $this->invoices[] = $invoice;
  774.             $invoice->setPro($this);
  775.         }
  777.         return $this;
  778.     }
  780.     public function removeInvoice(Invoice $invoice): self
  781.     {
  782.         if ($this->invoices->removeElement($invoice)) {
  783.             // set the owning side to null (unless already changed)
  784.             if ($invoice->getPro() === $this) {
  785.                 $invoice->setPro(null);
  786.             }
  787.         }
  789.         return $this;
  790.     }
  792.     public function getIsAmbassador(): ?bool
  793.     {
  794.         return $this->isAmbassador;
  795.     }
  797.     public function setIsAmbassador(?bool $isAmbassador): self
  798.     {
  799.         $this->isAmbassador = $isAmbassador;
  801.         return $this;
  802.     }
  804.     public function getLanguage(): ?string
  805.     {
  806.         return $this->language;
  807.     }
  809.     public function setLanguage(string $language): self
  810.     {
  811.         $this->language = $language;
  813.         return $this;
  814.     }
  816.     /**
  817.      * @return Collection<int, Address>
  818.      */
  819.     public function getAreas(): Collection
  820.     {
  821.         return $this->areas;
  822.     }
  824.     public function addArea(Address $area): self
  825.     {
  826.         if (!$this->areas->contains($area)) {
  827.             $this->areas[] = $area;
  828.             $area->setPro($this);
  829.         }
  831.         return $this;
  832.     }
  834.     public function removeArea(Address $area): self
  835.     {
  836.         if ($this->areas->removeElement($area)) {
  837.             // set the owning side to null (unless already changed)
  838.             if ($area->getPro() === $this) {
  839.                 $area->setPro(null);
  840.             }
  841.         }
  843.         return $this;
  844.     }
  846.     public function getTimezone(): ?string
  847.     {
  848.         return $this->timezone;
  849.     }
  851.     public function setTimezone(?string $timezone): static
  852.     {
  853.         $this->timezone = $timezone;
  855.         return $this;
  856.     }
  858.     public function getPhoneCode(): ?string
  859.     {
  860.         return $this->phoneCode;
  861.     }
  863.     public function setPhoneCode(?string $phoneCode): static
  864.     {
  865.         $this->phoneCode = $phoneCode;
  867.         return $this;
  868.     }
  870.     public function getNewsletter(): ?bool
  871.     {
  872.         return $this->newsletter;
  873.     }
  875.     public function setNewsletter(?bool $newsletter): static
  876.     {
  877.         $this->newsletter = $newsletter;
  879.         return $this;
  880.     }
  882.     /**
  883.      * @return Collection<int, ProDescription>
  884.      */
  885.     public function getProDescriptions(): Collection
  886.     {
  887.         return $this->proDescriptions;
  888.     }
  890.     public function addProDescription(ProDescription $proDescription): static
  891.     {
  892.         if (!$this->proDescriptions->contains($proDescription)) {
  893.             $this->proDescriptions->add($proDescription);
  894.             $proDescription->setPro($this);
  895.         }
  897.         return $this;
  898.     }
  900.     public function removeProDescription(ProDescription $proDescription): static
  901.     {
  902.         if ($this->proDescriptions->removeElement($proDescription)) {
  903.             // set the owning side to null (unless already changed)
  904.             if ($proDescription->getPro() === $this) {
  905.                 $proDescription->setPro(null);
  906.             }
  907.         }
  909.         return $this;
  910.     }
  912.     /**
  913.      * @return Collection<int, Note>
  914.      */
  915.     public function getNotes(): Collection
  916.     {
  917.         return $this->notes;
  918.     }
  920.     public function addNote(Note $note): static
  921.     {
  922.         if (!$this->notes->contains($note)) {
  923.             $this->notes->add($note);
  924.             $note->addAssociatedPro($this);
  925.         }
  927.         return $this;
  928.     }
  930.     public function removeNote(Note $note): static
  931.     {
  932.         if ($this->notes->removeElement($note)) {
  933.             $note->removeAssociatedPro($this);
  934.         }
  936.         return $this;
  937.     }
  939.     /**
  940.      * @return Collection<int, NoteRequest>
  941.      */
  942.     public function getNoteRequests(): Collection
  943.     {
  944.         return $this->noteRequests;
  945.     }
  947.     public function addNoteRequest(NoteRequest $noteRequest): static
  948.     {
  949.         if (!$this->noteRequests->contains($noteRequest)) {
  950.             $this->noteRequests->add($noteRequest);
  951.             $noteRequest->setPro($this);
  952.         }
  954.         return $this;
  955.     }
  957.     public function removeNoteRequest(NoteRequest $noteRequest): static
  958.     {
  959.         if ($this->noteRequests->removeElement($noteRequest)) {
  960.             // set the owning side to null (unless already changed)
  961.             if ($noteRequest->getPro() === $this) {
  962.                 $noteRequest->setPro(null);
  963.             }
  964.         }
  966.         return $this;
  967.     }
  968. }