src/Entity/User.php line 24

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Metadata\Post;
  6. use ApiPlatform\Metadata\GetCollection;
  7. use ApiPlatform\Metadata\Delete;
  8. use ApiPlatform\Metadata\Patch;
  9. use ApiPlatform\Metadata\Put;
  10. use ApiPlatform\Metadata\Get;
  11. use ApiPlatform\Metadata\ApiResource;
  12. use App\Repository\UserRepository;
  13. use DateTimeInterface;
  14. use Doctrine\Common\Collections\ArrayCollection;
  15. use Doctrine\Common\Collections\Collection;
  16. use Doctrine\ORM\Mapping as ORM;
  17. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  18. use Symfony\Component\Security\Core\User\UserInterface;
  19. use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
  20. use Symfony\Component\Validator\Constraints as Assert;
  21. #[ApiResource(operations: [new Get(), new Put(security: 'is_granted(\'ROLE_SUPER_ADMIN\')', securityMessage: 'Accès Interdit'), new Patch(security: 'is_granted(\'ROLE_SUPER_ADMIN\')', securityMessage: 'Accès Interdit'), new Delete(security: 'is_granted(\'ROLE_SUPER_ADMIN\')', securityMessage: 'Accès Interdit'), new GetCollection(), new Post(security: 'is_granted(\'ROLE_SUPER_ADMIN\')', securityMessage: 'Accès Interdit')])]
  22. #[ORM\Entity(repositoryClass: UserRepository::class)]
  23. #[UniqueEntity(fields: ['email'], errorPath: 'email', message: 'Cet email est déjà utilisé. Veuillez vous connecter.')]
  24. class User implements UserInterface, PasswordAuthenticatedUserInterface
  25. {
  26.     #[ORM\Id]
  27.     #[ORM\GeneratedValue]
  28.     #[ORM\Column(type: 'integer')]
  29.     private $id;
  30.     #[ORM\Column(type: 'string', length: 180, unique: true, nullable: true)]
  31.     #[Assert\Regex(pattern: '/^\S+@\S+\.\S+$/', message: 'Le champ "Email" doit être une adresse email valide.')]
  32.     private ?string $email = null;
  33.     #[ORM\Column(type: 'json')]
  34.     private array $roles = ['ROLE_USER'];
  35.     /**
  36.      * @var string The hashed password
  37.      */
  38.     #[ORM\Column(type: 'string', nullable: true)]
  39.     #[Assert\Regex(pattern: '/^(?=.{6,}$)(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*?\W).*$/', message: 'Votre mot de passe doit contenir au moins 8 caractères dont une majuscule, un chiffre et un caractère spécial')]
  40.     private ?string $password = null;
  41.     #[ORM\Column(type: 'string', length: 50, nullable: true)]
  42.     private ?string $name = null;
  43.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  44.     private ?string $lastName = null;
  45.     #[Assert\Regex(pattern: '/^(\+\d{2}|\d{2})?\s?\d{2}(\s?\d{2}){3}$/', message: 'Le numéro de téléphone n\'est pas valide.')]
  46.     #[ORM\Column(type: 'string', length: 20, nullable: true)]
  47.     private ?string $phone = null;
  48.     #[ORM\Column(type: 'date', nullable: true)]
  49.     #[Assert\LessThanOrEqual(value: '-15 years', message: "Vous devez être agé d'au moins 15 ans.")]
  50.     private ?DateTimeInterface $birthDate = null;
  51.     #[ORM\Column(type: 'text', nullable: true)]
  52.     private ?string $address = null;
  53.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  54.     private ?string $additionalAddress = null;
  55.     #[ORM\Column(type: 'string', length: 100, nullable: true)]
  56.     private ?string $city = null;
  57.     #[ORM\Column(type: 'string', length: 5, nullable: true)]
  58.     #[Assert\Regex(pattern: '/^(?:[0-8]\d|9[0-8])\d{3}$/', message: 'Le code postal n\'est pas valide.')]
  59.     private ?string $postalCode = null;
  60.     #[ORM\Column(type: 'boolean', nullable: true)]
  61.     private ?bool $isAccept = null;
  62.     #[ORM\Column(type: 'boolean', nullable: true)]
  63.     private ?bool $isActivated = null;
  64.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  65.     private ?string $smsToken = null;
  66.     #[ORM\JoinTable(name: 'entity_admin')]
  67.     #[ORM\ManyToMany(targetEntity: Entity::class, mappedBy: 'admins')]
  68.     private Collection $entitiesAdmins;
  69.     #[ORM\ManyToMany(targetEntity: Profile::class, inversedBy: 'users')]
  70.     private Collection $profiles;
  71.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  72.     private ?string $picture = null;
  73.     #[ORM\ManyToOne(targetEntity: Entity::class, cascade: ['persist'])]
  74.     #[ORM\JoinColumn(name: 'selected_entity_id', referencedColumnName: 'id', onDelete: 'SET NULL')]
  75.     private ?Entity $selectedEntity = null;
  76.     #[ORM\OneToMany(targetEntity: UserEntity::class, mappedBy: 'user', orphanRemoval: true, cascade: ['persist'])]
  77.     private Collection $userEntities;
  78.     #[ORM\OneToMany(targetEntity: Answer::class, mappedBy: 'author')]
  79.     private Collection $answers;
  80.     #[ORM\OneToMany(targetEntity: SavedNotification::class, mappedBy: 'user', orphanRemoval: true)]
  81.     private Collection $notifications;
  82.     #[ORM\OneToMany(targetEntity: Comment::class, mappedBy: 'author', orphanRemoval: true)]
  83.     private array|Collection $comments;
  84.     #[ORM\OneToOne(targetEntity: Device::class, cascade: ['persist', 'remove'])]
  85.     private ?Device $device = null;
  86.     #[ORM\Column(type: 'date')]
  87.     private \DateTime $createdDate;
  88.     #[ORM\OneToMany(targetEntity: Like::class, mappedBy: 'author', orphanRemoval: true)]
  89.     private Collection $likes;
  90.     #[ORM\OneToOne(targetEntity: NotifParams::class, mappedBy: 'user', cascade: ['persist', 'remove'])]
  91.     private NotifParams $notifParams;
  92.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  93.     private ?string $resetToken = null;
  94.     /**
  95.      * @var ArrayCollection
  96.      */
  97.     private Collection $entities;
  98.     /**
  99.      * @var string
  100.      */
  101.     private string $emailVerif;
  102.     #[ORM\Column(type: 'integer', nullable: true)]
  103.     #[Assert\Length(min: 14, max: 14, minMessage: 'Numéro invalide', maxMessage: 'Numéro invalide', exactMessage: 'Numéro invalide')]
  104.     private ?int $numberGU = null;
  105.     #[ORM\OneToMany(targetEntity: UserConnexion::class, mappedBy: 'user', cascade: ['remove'])]
  106.     private Collection $userConnexions;
  107.     #[ORM\OneToMany(targetEntity: Log::class, mappedBy: 'user', cascade: ['remove'])]
  108.     private Collection $logs;
  110.     #[ORM\ManyToMany(targetEntity: Territory::class, mappedBy: 'admins')]
  111.     private Collection $adminTerritories;
  113.     #[ORM\ManyToMany(targetEntity: Territory::class, mappedBy: 'members')]
  114.     private Collection $territories;
  115.     public function __construct()
  116.     {
  117.         $this->profiles = new ArrayCollection();
  118.         $this->answers = new ArrayCollection();
  119.         $this->notifications = new ArrayCollection();
  120.         $this->userEntities = new ArrayCollection();
  121.         $this->entitiesAdmins = new ArrayCollection();
  122.         $this->createdDate = new \DateTime();
  123.         $this->likes = new ArrayCollection();
  124.         $this->entities = new ArrayCollection();
  125.         $this->notifParams = new NotifParams();
  126.         $this->notifParams->setUser($this);
  127.         $this->userConnexions = new ArrayCollection();
  128.         $this->logs = new ArrayCollection();
  129.         $this->adminTerritories = new ArrayCollection();
  130.         $this->territories = new ArrayCollection();
  131.     }
  132.     public function getId() : ?int
  133.     {
  134.         return $this->id;
  135.     }
  136.     public function getEmail() : ?string
  137.     {
  138.         return $this->email;
  139.     }
  140.     public function setEmail(?string $email) : self
  141.     {
  142.         $this->email = $email;
  143.         return $this;
  144.     }
  145.     /**
  146.      * A visual identifier that represents this user.
  147.      *
  148.      * @see UserInterface
  149.      */
  150.     public function getUsername() : string
  151.     {
  152.         return (string) $this->email;
  153.     }
  154.     /**
  155.      * @see UserInterface
  156.      */
  157.     public function getRoles() : array
  158.     {
  159.         $roles = $this->roles;
  160.         // guarantee every user at least has ROLE_USER
  161.         //$roles[] = 'ROLE_USER';
  162.         return array_unique($roles);
  163.     }
  164.     public function setRoles(array $roles) : self
  165.     {
  166.         $this->roles = $roles;
  167.         return $this;
  168.     }
  170.     public function addRole(string $role) : self
  171.     {
  172.         if (!array_search($role, $this->roles)){
  173.             $this->roles[] = $role;
  174.         }
  175.         return $this;
  176.     }
  178.     public function removeRole(string $role) : self
  179.     {
  180.         $index = array_search($role, $this->roles);
  181.         if ($index){
  182.             array_splice($this->roles, $index, 1);
  183.         }
  184.         return $this;
  185.     }
  187.     public function toggleRole(string $role) : self
  188.     {
  189.         $index = array_search($role, $this->roles);
  190.         if ($index){
  191.             array_splice($this->roles, $index, 1);
  192.         } else {
  193.             $this->roles[] = $role;
  194.         }
  195.         return $this;
  196.     }
  198.     /**
  199.      * @see UserInterface
  200.      */
  201.     public function getPassword() : ?string
  202.     {
  203.         return (string) $this->password;
  204.     }
  205.     public function setPassword(?string $password) : self
  206.     {
  207.         $this->password = $password;
  208.         return $this;
  209.     }
  210.     /**
  211.      * Returning a salt is only needed, if you are not using a modern
  212.      * hashing algorithm (e.g. bcrypt or sodium) in your security.yaml.
  213.      *
  214.      * @see UserInterface
  215.      */
  216.     public function getSalt() : ?string
  217.     {
  218.         return null;
  219.     }
  220.     /**
  221.      * @see UserInterface
  222.      */
  223.     public function eraseCredentials()
  224.     {
  225.         // If you store any temporary, sensitive data on the user, clear it here
  226.         // $this->plainPassword = null;
  227.     }
  228.     public function getName() : ?string
  229.     {
  230.         return $this->name;
  231.     }
  232.     public function setName(?string $name) : self
  233.     {
  234.         $this->name = $name;
  235.         return $this;
  236.     }
  237.     public function getLastName() : ?string
  238.     {
  239.         return $this->lastName;
  240.     }
  241.     public function setLastName(?string $lastName) : self
  242.     {
  243.         $this->lastName = $lastName;
  244.         return $this;
  245.     }
  246.     public function getPhone() : ?string
  247.     {
  248.         return $this->phone;
  249.     }
  250.     public function setPhone(?string $phone) : self
  251.     {
  252.         $this->phone = $phone;
  253.         return $this;
  254.     }
  255.     public function getBirthDate() : ?DateTimeInterface
  256.     {
  257.         return $this->birthDate;
  258.     }
  259.     public function setBirthDate(?DateTimeInterface $birthDate) : self
  260.     {
  261.         $this->birthDate = $birthDate;
  262.         return $this;
  263.     }
  264.     public function getAddress() : ?string
  265.     {
  266.         return $this->address;
  267.     }
  268.     public function setAddress(?string $address) : self
  269.     {
  270.         $this->address = $address;
  271.         return $this;
  272.     }
  273.     public function getAdditionalAddress() : ?string
  274.     {
  275.         return $this->additionalAddress;
  276.     }
  277.     public function setAdditionalAddress(?string $additionalAddress) : self
  278.     {
  279.         $this->additionalAddress = $additionalAddress;
  280.         return $this;
  281.     }
  282.     public function getCity() : ?string
  283.     {
  284.         return $this->city;
  285.     }
  286.     public function setCity(?string $city) : self
  287.     {
  288.         $this->city = $city;
  289.         return $this;
  290.     }
  291.     public function getPostalCode() : ?string
  292.     {
  293.         return $this->postalCode;
  294.     }
  295.     public function setPostalCode(?string $postalCode) : self
  296.     {
  297.         $this->postalCode = $postalCode;
  298.         return $this;
  299.     }
  300.     public function getIsAccept() : ?bool
  301.     {
  302.         return $this->isAccept;
  303.     }
  304.     public function setIsAccept(bool $isAccept) : self
  305.     {
  306.         $this->isAccept = $isAccept;
  307.         return $this;
  308.     }
  309.     public function getIsActivated() : ?bool
  310.     {
  311.         return $this->isActivated;
  312.     }
  313.     public function setIsActivated(bool $isActivated) : self
  314.     {
  315.         $this->isActivated = $isActivated;
  316.         return $this;
  317.     }
  318.     public function getSmsToken() : ?string
  319.     {
  320.         return $this->smsToken;
  321.     }
  322.     public function setSmsToken(?string $smsToken) : self
  323.     {
  324.         $this->smsToken = $smsToken;
  325.         return $this;
  326.     }
  327.     /**
  328.      * @return Collection|Entity[]
  329.      */
  330.     public function getEntitiesAdmins() : ?Collection
  331.     {
  332.         return $this->entitiesAdmins;
  333.     }
  334.     public function addEntityAdmins(Entity $entity) : self
  335.     {
  336.         if (!$this->entitiesAdmins->contains($entity)) {
  337.             $this->entitiesAdmins[] = $entity;
  338.             $entity->addAdmin($this);
  339.         }
  340.         return $this;
  341.     }
  342.     public function removeEntityAdmins(Entity $entity) : self
  343.     {
  344.         if ($this->entitiesAdmins->removeElement($entity)) {
  345.             $entity->removeAdmin($this);
  346.         }
  347.         return $this;
  348.     }
  349.     /**
  350.      * @return Collection|Profile[]
  351.      */
  352.     public function getProfiles() : Collection
  353.     {
  354.         return $this->profiles;
  355.     }
  356.     public function addProfile(Profile $profile) : self
  357.     {
  358.         if (!$this->profiles->contains($profile)) {
  359.             $this->profiles[] = $profile;
  360.         }
  361.         return $this;
  362.     }
  363.     public function setProfiles(array $profiles) : self
  364.     {
  365.         $this->profiles[] = $profiles;
  366.         return $this;
  367.     }
  368.     public function removeProfile(Profile $profile) : self
  369.     {
  370.         $this->profiles->removeElement($profile);
  371.         return $this;
  372.     }
  373.     public function getPicture() : ?string
  374.     {
  375.         return $this->picture;
  376.     }
  377.     public function setPicture(?string $picture) : self
  378.     {
  379.         $this->picture = $picture;
  380.         return $this;
  381.     }
  382.     public function getSelectedEntity() : ?Entity
  383.     {
  384.         return $this->selectedEntity;
  385.     }
  386.     public function setSelectedEntity(?Entity $selectedEntity) : self
  387.     {
  388.         $this->selectedEntity = $selectedEntity;
  389.         return $this;
  390.     }
  391.     /**
  392.      * @return Collection|UserEntity[]
  393.      */
  394.     public function getUserEntities() : Collection
  395.     {
  396.         return $this->userEntities;
  397.     }
  398.     public function addUserEntity(UserEntity $userEntity) : self
  399.     {
  400.         if (!$this->userEntities->contains($userEntity)) {
  401.             $this->userEntities[] = $userEntity;
  402.             $userEntity->setUser($this);
  403.         }
  404.         return $this;
  405.     }
  406.     public function removeUserEntity(UserEntity $userEntity) : self
  407.     {
  408.         if ($this->userEntities->removeElement($userEntity)) {
  409.             // set the owning side to null (unless already changed)
  410.             if ($userEntity->getUser() === $this) {
  411.                 $userEntity->setUser(null);
  412.             }
  413.         }
  414.         return $this;
  415.     }
  416.     public function removeAllUserEntity() : self
  417.     {
  418.         foreach ($this->userEntities as $userEntity) {
  419.             if ($this->userEntities->removeElement($userEntity)) {
  420.                 // set the owning side to null (unless already changed)
  421.                 if ($userEntity->getUser() === $this) {
  422.                     $userEntity->setUser(null);
  423.                 }
  424.             }
  425.         }
  426.         return $this;
  427.     }
  428.     public function getAnswers() : Collection
  429.     {
  430.         return $this->answers;
  431.     }
  432.     public function addAnswer(Answer $answer) : self
  433.     {
  434.         if (!$this->answers->contains($answer)) {
  435.             $this->answers[] = $answer;
  436.             $answer->setAuthor($this);
  437.         }
  438.         return $this;
  439.     }
  440.     public function removeAnswer(Answer $answer) : self
  441.     {
  442.         if ($this->answers->removeElement($answer)) {
  443.             // set the owning side to null (unless already changed)
  444.             if ($answer->getAuthor() === $this) {
  445.                 $answer->setAuthor(null);
  446.             }
  447.         }
  448.         return $this;
  449.     }
  450.     public function getNotifications() : Collection
  451.     {
  452.         return $this->notifications;
  453.     }
  454.     public function addNotification(SavedNotification $notification) : self
  455.     {
  456.         if (!$this->notifications->contains($notification)) {
  457.             $this->notifications[] = $notification;
  458.             $notification->setUser($this);
  459.         }
  460.         return $this;
  461.     }
  462.     public function removeNotification(SavedNotification $notification) : self
  463.     {
  464.         if ($this->notifications->removeElement($notification)) {
  465.             // set the owning side to null (unless already changed)
  466.             if ($notification->getUser() === $this) {
  467.                 $notification->setUser(null);
  468.             }
  469.         }
  470.         return $this;
  471.     }
  472.     public function getDevice() : ?Device
  473.     {
  474.         return $this->device;
  475.     }
  476.     public function setDevice(?Device $device) : self
  477.     {
  478.         $this->device = $device;
  479.         return $this;
  480.     }
  481.     public function isUSerAcceptedInEntity($idEntity)
  482.     {
  483.         foreach ($this->getUserEntities() as $userEntity) {
  484.             if ($idEntity == $userEntity->getEntity()->getId()) {
  485.                 return $userEntity->getIsAccepted();
  486.             }
  487.         }
  488.         return false;
  489.     }
  490.     public function getCreatedDate() : ?\DateTimeInterface
  491.     {
  492.         return $this->createdDate;
  493.     }
  494.     public function setCreatedDate(\DateTimeInterface $createdDate) : self
  495.     {
  496.         $this->createdDate = $createdDate;
  497.         return $this;
  498.     }
  499.     /**
  500.      * @return Collection|Like[]
  501.      */
  502.     public function getLikes() : Collection
  503.     {
  504.         return $this->likes;
  505.     }
  506.     public function addLike(Like $like) : self
  507.     {
  508.         if (!$this->likes->contains($like)) {
  509.             $this->likes[] = $like;
  510.             $like->setAuthor($this);
  511.         }
  512.         return $this;
  513.     }
  514.     public function removeLike(Like $like) : self
  515.     {
  516.         if ($this->likes->removeElement($like)) {
  517.             // set the owning side to null (unless already changed)
  518.             if ($like->getAuthor() === $this) {
  519.                 $like->setAuthor(null);
  520.             }
  521.         }
  522.         return $this;
  523.     }
  524.     public function getNotifParams() : ?NotifParams
  525.     {
  526.         return $this->notifParams;
  527.     }
  528.     public function setNotifParams(NotifParams $notifParams) : self
  529.     {
  530.         // set the owning side of the relation if necessary
  531.         if ($notifParams->getUser() !== $this) {
  532.             $notifParams->setUser($this);
  533.         }
  534.         $this->notifParams = $notifParams;
  535.         return $this;
  536.     }
  537.     public function getResetToken() : ?string
  538.     {
  539.         return $this->resetToken;
  540.     }
  541.     public function setResetToken(?string $resetToken) : self
  542.     {
  543.         $this->resetToken = $resetToken;
  544.         return $this;
  545.     }
  546.     /**
  547.      * @return Collection|Comment[]
  548.      */
  549.     public function getComments() : Collection
  550.     {
  551.         return $this->comments;
  552.     }
  553.     public function addComments(Comment $comment) : self
  554.     {
  555.         if (!$this->comments->contains($comment)) {
  556.             $this->comments[] = $comment;
  557.             $comment->setAuthor($this);
  558.         }
  559.         return $this;
  560.     }
  561.     public function removeComments(Comment $comment) : self
  562.     {
  563.         if ($this->comments->removeElement($comment)) {
  564.             // set the owning side to null (unless already changed)
  565.             if ($comment->getAuthor() === $this) {
  566.                 $comment->setAuthor(null);
  567.             }
  568.         }
  569.         return $this;
  570.     }
  571.     public function setEntities(ArrayCollection $arrayCollection) : User
  572.     {
  573.         $this->entities = $arrayCollection;
  574.         return $this;
  575.     }
  576.     /**
  577.      * @return Collection|Entity[]
  578.      */
  579.     public function getEntities() : ?Collection
  580.     {
  581.         return $this->entities;
  582.     }
  583.     public function addEntities(Entity $entities) : User
  584.     {
  585.         $this->entities[] = $entities;
  586.         return $this;
  587.     }
  588.     public function getEmailVerif() : ?string
  589.     {
  590.         return $this->emailVerif;
  591.     }
  592.     public function setEmailVerif(?string $emailVerif) : self
  593.     {
  594.         $this->emailVerif = $emailVerif;
  595.         return $this;
  596.     }
  597.     public function getNumberGU() : ?int
  598.     {
  599.         return $this->numberGU;
  600.     }
  601.     public function setNumberGU(?int $numberGU) : self
  602.     {
  603.         $this->numberGU = $numberGU;
  604.         return $this;
  605.     }
  606.     public function getFormUserAnswers() : ?FormUserAnswers
  607.     {
  608.         return $this->formUserAnswers;
  609.     }
  610.     public function setFormUserAnswers(?FormUserAnswers $formUserAnswers) : self
  611.     {
  612.         $this->formUserAnswers = $formUserAnswers;
  613.         return $this;
  614.     }
  615.     /**
  616.      * @return Collection|Log[]
  617.      */
  618.     public function getLogs() : Collection
  619.     {
  620.         return $this->logs;
  621.     }
  622.     public function addLog(Log $log) : self
  623.     {
  624.         if (!$this->logs->contains($log)) {
  625.             $this->logs[] = $log;
  626.             $log->setUser($this);
  627.         }
  628.         return $this;
  629.     }
  630.     public function removeLog(Log $log) : self
  631.     {
  632.         if ($this->logs->removeElement($log)) {
  633.             // set the owning side to null (unless already changed)
  634.             if ($log->getUser() === $this) {
  635.                 $log->setUser(null);
  636.             }
  637.         }
  638.         return $this;
  639.     }
  640.     public function getUserConnexions() : Collection
  641.     {
  642.         return $this->userConnexions;
  643.     }
  644.     public function addUserConnexion(UserConnexion $userConnexion) : self
  645.     {
  646.         if (!$this->userConnexions->contains($userConnexion)) {
  647.             $this->userConnexions[] = $userConnexion;
  648.             $userConnexion->setUser($this);
  649.         }
  650.         return $this;
  651.     }
  652.     public function removeUserConnexion(UserConnexion $userConnexion) : self
  653.     {
  654.         if ($this->userConnexions->removeElement($userConnexion)) {
  655.             // set the owning side to null (unless already changed)
  656.             if ($userConnexion->getUser() === $this) {
  657.                 $userConnexion->setUser(null);
  658.             }
  659.         }
  660.         return $this;
  661.     }
  662.     public function getUserIdentifier() : string
  663.     {
  664.         return (string) $this->email;
  665.     }
  667.     /**
  668.      * @return Collection<int, Territory>
  669.      */
  670.     public function getAdminTerritories(): Collection
  671.     {
  672.         return $this->adminTerritories;
  673.     }
  675.     public function addAdminTerritory(Territory $adminTerritory): self
  676.     {
  677.         if (!$this->adminTerritories->contains($adminTerritory)) {
  678.             $this->adminTerritories->add($adminTerritory);
  679.             $adminTerritory->addAdmin($this);
  680.         }
  682.         return $this;
  683.     }
  685.     public function removeAdminTerritory(Territory $adminTerritory): self
  686.     {
  687.         if ($this->adminTerritories->removeElement($adminTerritory)) {
  688.             $adminTerritory->removeAdmin($this);
  689.         }
  691.         return $this;
  692.     }
  694.     /**
  695.      * @return Collection<int, Territory>
  696.      */
  697.     public function getTerritories(): Collection
  698.     {
  699.         return $this->territories;
  700.     }
  702.     public function addTerritory(Territory $territory): self
  703.     {
  704.         if (!$this->territories->contains($territory)) {
  705.             $this->territories->add($territory);
  706.             $territory->addMember($this);
  707.         }
  709.         return $this;
  710.     }
  712.     public function removeTerritory(Territory $territory): self
  713.     {
  714.         if ($this->territories->removeElement($territory)) {
  715.             $territory->removeMember($this);
  716.         }
  718.         return $this;
  719.     }
  720. }