src/Entity/User.php line 87

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiProperty;
  6. use ApiPlatform\Core\Annotation\ApiResource;
  7. use ApiPlatform\Core\Annotation\ApiFilter;
  8. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  9. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  10. use ApiPlatform\Core\Serializer\Filter\PropertyFilter;
  11. use App\Repository\UserRepository;
  12. use App\Trait\TimestampableEntity;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  17. use Symfony\Component\Security\Core\User\UserInterface;
  18. use Symfony\Component\Validator\Constraints as Assert;
  19. use Symfony\Component\Serializer\Annotation\Groups;
  20. use Symfony\Component\Serializer\Annotation\MaxDepth;
  21. use Ramsey\Uuid\Uuid;
  22. use Ramsey\Uuid\UuidInterface;
  24. #[ORM\Entity(repositoryClass: UserRepository::class)]
  25. #[ApiResource(
  26.     iri: 'User', 
  27.     itemOperations: [
  28.         'get' => [
  29.             // 'security' => "is_granted('ROLE_USER')",
  30.             'normalization_context' => [
  31.                 'groups' => 'user:item:get',
  32.                 'enable_max_depth' => true
  33.             ]
  34.         ],
  35.         'put' => [
  36.             // 'security' => "is_granted('ROLE_USER')",
  37.             'normalization_context' => [
  38.                 'groups' => 'user:item:put',
  39.                 'enable_max_depth' => true
  40.             ],
  41.             'denormalization_context' => [
  42.                 'groups' => 'user:item:put',
  43.                 'enable_max_depth' => true
  44.             ]
  45.         ],
  46.         'delete' => [
  47.             // 'security' => "is_granted('ROLE_USER')",
  48.         ]
  49.     ],
  50.     collectionOperations: [
  51.         'get' => [
  52.             // 'security' => "is_granted('ROLE_USER')",
  53.             'normalization_context' => [
  54.                 'groups' => ['user:collection:get', 'createdAt'],
  55.                 'enable_max_depth' => true
  56.             ]
  57.         ],
  58.         'post' => [
  59.             // 'security' => "is_granted('ROLE_USER')",
  60.             'normalization_context' => [
  61.                 'groups' => 'user:collection:post',
  62.                 'enable_max_depth' => true
  63.             ],
  64.             'denormalization_context' => [
  65.                 'groups' => 'user:collection:post',
  66.                 'enable_max_depth' => true
  67.             ]
  68.         ],
  69.     ]
  70. )]
  71. #[ApiFilter(SearchFilter::class, properties: [
  72.     'brokers.broker' => 'exact', 
  73.     'insureds.insured' => 'exact',
  74.     'insurers.insurer' => 'exact',
  75.     // 'channels.channel' => 'exact',
  76.     'roles' => 'partial',
  77.     'email' => 'partial',
  78.     'name' => 'partial',
  79.     'createdAt' => 'start',
  80. ])]
  81. #[ApiFilter(OrderFilter::class, properties: [
  82.     'name',
  83.     'email', 
  84.     'createdAt',
  85. ])]
  86. #[ApiFilter(PropertyFilter::class)]
  87. class User implements UserInterface, PasswordAuthenticatedUserInterface
  88. {
  89.     use TimestampableEntity;
  90.     
  91.     #[ORM\Id]
  92.     #[ORM\GeneratedValue(strategy: 'NONE')]
  93.     #[ORM\Column(type: 'uuid', unique: true)]
  94.     #[ApiProperty(iri: 'https://schema.org/identifier')]
  95.     #[Groups([
  96.         'user:collection:get',
  97.         'user:item:get',
  98.     ])]
  99.     private ?UuidInterface $id = null;
  101.     /**
  102.      * The name of the item.
  103.      *
  104.      * @see https://schema.org/name
  105.      */
  106.     #[ORM\Column(type: 'string', nullable: false)]
  107.     #[ApiProperty(iri: 'https://schema.org/name')]
  108.     #[Assert\Type('string')]
  109.     #[Groups([
  110.         'user:collection:get',
  111.         'user:collection:post',
  112.         'user:item:get',
  113.         'user:item:put',
  114.         'contract:item:get', 
  115.         'contract:item:put', 
  116.         'contract:collection:get', 
  117.         'contract:collection:post'
  118.     ])]
  119.     private ?string $name = null;
  121.     #[ORM\Column(type: 'string', length: 180, unique: true)]
  122.     #[ApiProperty(iri: 'https://schema.org/email')]
  123.     #[Groups([
  124.         'user:collection:get',
  125.         'user:collection:post',
  126.         'user:item:get',
  127.         'user:item:put',
  128.     ])]
  129.     private $email;
  131.     #[ORM\Column(type: 'json')]
  132.     #[ApiProperty()]
  133.     #[Groups([
  134.         'user:collection:get',
  135.         'user:collection:post',
  136.         'user:item:get',
  137.         'user:item:put',
  138.     ])]
  139.     private array $roles = [];
  141.     #[ORM\Column(type: 'string')]
  142.     private $password;
  144.     #[Groups([
  145.         'user:collection:post',
  146.         'user:item:put',
  147.     ])]
  148.     protected $plainPassword;
  150.     #[ORM\Column(type: 'string', length: 255, nullable: true)]
  151.     private $confirmationToken;
  153.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: BrokerUser::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  154.     // #[Groups([
  155.     //     'user:collection:post',
  156.     //     'user:item:get',
  157.     //     'user:item:put',
  158.     // ])]
  159.     // #[MaxDepth(1)]
  160.     // private $brokers;
  162.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: InsuredUser::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  163.     // #[Groups([
  164.     //     'user:collection:post',
  165.     //     'user:item:get',
  166.     //     'user:item:put',
  167.     // ])]
  168.     // #[MaxDepth(1)]
  169.     // private $insureds;
  171.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: InsurerUser::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  172.     // #[Groups([
  173.     //     'user:collection:post',
  174.     //     'user:item:get',
  175.     //     'user:item:put',
  176.     // ])]
  177.     // #[MaxDepth(1)]
  178.     // private $insurers;
  180.     // #[ORM\OneToMany(mappedBy: 'user', targetEntity: ChannelUser::class, cascade: ['persist', 'remove'], orphanRemoval: true)]
  181.     // #[Groups([
  182.     //     'user:collection:post',
  183.     //     'user:item:get',
  184.     //     'user:item:put',
  185.     // ])]
  186.     // #[MaxDepth(1)]
  187.     // private $channels;
  189.     #[ApiProperty(iri: 'https://schema.org/image')]
  190.     #[ORM\ManyToOne(targetEntity: Media::class, cascade: ["persist", "remove"])]
  191.     #[ORM\JoinColumn(nullable: true)]
  192.     #[Groups([
  193.         'user:collection:get',
  194.         'user:collection:post',
  195.         'user:item:get',
  196.         'user:item:put',
  197.     ])]
  198.     #[MaxDepth(1)]
  199.     private $avatar;
  201.     #[ORM\Column(type: 'string', nullable: true)]
  202.     #[ApiProperty(iri: 'https://schema.org/desk')]
  203.     #[Assert\Type('string')]
  204.     #[Groups([
  205.         'user:collection:get',
  206.         'user:collection:post',
  207.         'user:item:get',
  208.         'user:item:put',
  209.     ])]
  210.     private ?string $desk = null;
  212.     #[ORM\OneToMany(targetEntity: 'App\Entity\Contract', mappedBy: 'broker')]
  213.     #[ApiProperty(iri: 'https://schema.org/Contract')]
  214.     #[Groups(['user:collection:get', 'user:collection:post', 'user:item:get', 'user:item:put'])]
  215.     #[MaxDepth(1)]
  216.     private ?Collection $contracts = null;
  218.     #[ORM\OneToMany(targetEntity: 'App\Entity\Contract', mappedBy: 'operator')]
  219.     #[ApiProperty(iri: 'https://schema.org/Contract')]
  220.     #[Groups(['user:collection:get', 'user:collection:post', 'user:item:get', 'user:item:put'])]
  221.     #[MaxDepth(1)]
  222.     private ?Collection $operations = null;
  224.     // #[ORM\OneToMany(targetEntity: 'App\Entity\Lifting', mappedBy: 'operator')]
  225.     // #[ApiProperty(iri: 'https://schema.org/Lifting')]
  226.     // #[Groups(['user:collection:get', 'user:collection:post', 'user:item:get', 'user:item:put'])]
  227.     // #[MaxDepth(1)]
  228.     // private ?Collection $liftings = null;
  230.     public function __construct()
  231.     {
  232.         $this->id = Uuid::uuid4();
  233.         // $this->brokers = new ArrayCollection();
  234.         // $this->insureds = new ArrayCollection();
  235.         // $this->insurers = new ArrayCollection();
  236.         // $this->channels = new ArrayCollection();
  237.         $this->contracts = new ArrayCollection();
  238.         $this->operations = new ArrayCollection();
  239.         // $this->liftings = new ArrayCollection();
  240.     }
  242.     public function getId(): ?UuidInterface
  243.     {
  244.         return $this->id;
  245.     }
  247.     public function setName(?string $name): void
  248.     {
  249.         $this->name = $name;
  250.     }
  252.     public function getName(): ?string
  253.     {
  254.         return $this->name;
  255.     }
  257.     public function getEmail(): ?string
  258.     {
  259.         return $this->email;
  260.     }
  262.     public function setEmail(string $email): self
  263.     {
  264.         $this->email = $email;
  266.         return $this;
  267.     }
  269.     /**
  270.      * A visual identifier that represents this user.
  271.      *
  272.      * @see UserInterface
  273.      */
  274.     public function getUserIdentifier(): string
  275.     {
  276.         return (string) $this->email;
  277.     }
  279.     /**
  280.      * @see UserInterface
  281.      */
  282.     public function getRoles(): array
  283.     {
  284.         $roles = $this->roles;
  285.         // guarantee every user at least has ROLE_USER
  286.         $roles[] = 'ROLE_USER';
  288.         return array_unique($roles);
  289.     }
  291.     public function setRoles(array $roles): self
  292.     {
  293.         $this->roles = $roles;
  295.         return $this;
  296.     }
  298.     /**
  299.      * @see PasswordAuthenticatedUserInterface
  300.      */
  301.     public function getPassword(): string
  302.     {
  303.         return $this->password;
  304.     }
  306.     public function setPassword(string $password): self
  307.     {
  308.         $this->password = $password;
  310.         return $this;
  311.     }
  313.     public function getPlainPassword(): ?string
  314.     {
  315.         return $this->plainPassword;
  316.     }
  318.     public function setPlainPassword(?string $plainPassword): self
  319.     {
  320.         $this->plainPassword = $plainPassword;
  322.         return $this;
  323.     }
  325.     /**
  326.      * @see UserInterface
  327.      */
  328.     public function eraseCredentials(): void
  329.     {
  330.         // If you store any temporary, sensitive data on the user, clear it here
  331.         // $this->plainPassword = null;
  332.     }
  334.     // /**
  335.     //  * @return Collection|BrokerUser[]
  336.     //  */
  337.     // public function getBrokers(): Collection
  338.     // {
  339.     //     return $this->brokers;
  340.     // }
  342.     // public function addBroker(BrokerUser $broker): self
  343.     // {
  344.     //     if (!$this->brokers->contains($broker)) {
  345.     //         $this->brokers[] = $broker;
  346.     //         $broker->setUser($this);
  347.     //     }
  349.     //     return $this;
  350.     // }
  352.     // public function removeBroker(BrokerUser $broker): self
  353.     // {
  354.     //     if ($this->brokers->removeElement($broker)) {
  355.     //         // set the owning side to null (unless already changed)
  356.     //         if ($broker->getUser() === $this) {
  357.     //             $broker->setUser(null);
  358.     //         }
  359.     //     }
  361.     //     return $this;
  362.     // }
  364.     // /**
  365.     //  * @return Collection|InsuredUser[]
  366.     //  */
  367.     // public function getInsureds(): Collection
  368.     // {
  369.     //     return $this->insureds;
  370.     // }
  372.     // public function addInsured(InsuredUser $insured): self
  373.     // {
  374.     //     if (!$this->insureds->contains($insured)) {
  375.     //         $this->insureds[] = $insured;
  376.     //         $insured->setUser($this);
  377.     //     }
  379.     //     return $this;
  380.     // }
  382.     // public function removeInsured(InsuredUser $insured): self
  383.     // {
  384.     //     if ($this->insureds->removeElement($insured)) {
  385.     //         // set the owning side to null (unless already changed)
  386.     //         if ($insured->getUser() === $this) {
  387.     //             $insured->setUser(null);
  388.     //         }
  389.     //     }
  391.     //     return $this;
  392.     // }
  394.     // /**
  395.     //  * @return Collection|InsurerUser[]
  396.     //  */
  397.     // public function getInsurers(): Collection
  398.     // {
  399.     //     return $this->insurers;
  400.     // }
  402.     // public function addInsurer(InsurerUser $insurer): self
  403.     // {
  404.     //     if (!$this->insurers->contains($insurer)) {
  405.     //         $this->insurers[] = $insurer;
  406.     //         $insurer->setUser($this);
  407.     //     }
  409.     //     return $this;
  410.     // }
  412.     // public function removeInsurer(InsurerUser $insurer): self
  413.     // {
  414.     //     if ($this->insurers->removeElement($insurer)) {
  415.     //         // set the owning side to null (unless already changed)
  416.     //         if ($insurer->getUser() === $this) {
  417.     //             $insurer->setUser(null);
  418.     //         }
  419.     //     }
  421.     //     return $this;
  422.     // }
  424.     public function getConfirmationToken(): ?string
  425.     {
  426.         return $this->confirmationToken;
  427.     }
  429.     public function setConfirmationToken(?string $confirmationToken): self
  430.     {
  431.         $this->confirmationToken = $confirmationToken;
  433.         return $this;
  434.     }
  436.     // /**
  437.     //  * @return Collection|ChannelUser[]
  438.     //  */
  439.     // public function getChannels(): Collection
  440.     // {
  441.     //     return $this->channels;
  442.     // }
  444.     // public function addChannel(ChannelUser $channel): self
  445.     // {
  446.     //     if (!$this->channels->contains($channel)) {
  447.     //         $this->channels[] = $channel;
  448.     //         $channel->setUser($this);
  449.     //     }
  451.     //     return $this;
  452.     // }
  454.     // public function removeChannel(ChannelUser $channel): self
  455.     // {
  456.     //     if ($this->channels->removeElement($channel)) {
  457.     //         // set the owning side to null (unless already changed)
  458.     //         if ($channel->getUser() === $this) {
  459.     //             $channel->setUser(null);
  460.     //         }
  461.     //     }
  463.     //     return $this;
  464.     // }
  466.     public function setAvatar(?Media $avatar): self
  467.     {
  468.         $this->avatar = $avatar;
  470.         return $this;
  471.     }
  473.     public function getAvatar(): ?Media
  474.     {
  475.         return $this->avatar;
  476.     }
  478.     public function setDesk(?string $desk): void
  479.     {
  480.         $this->desk = $desk;
  481.     }
  483.     public function getDesk(): ?string
  484.     {
  485.         return $this->desk;
  486.     }
  488.     
  489.     public function getContracts(): Collection
  490.     {
  491.         return $this->contracts;
  492.     }
  494.     public function addContract(Contract $contract): self
  495.     {
  496.         if (!$this->contracts->contains($contract)) {
  497.             $this->contracts[] = $contract;
  498.             $contract->setBroker($this);
  499.         }
  501.         return $this;
  502.     }
  504.     public function removeContract(Contract $contract): self
  505.     {
  506.         if ($this->contracts->removeElement($contract)) {
  507.             if ($contract->getBroker() === $this) {
  508.                 $contract->setBroker(null);
  509.             }
  510.         }
  512.         return $this;
  513.     }
  515.     public function getOperations(): Collection
  516.     {
  517.         return $this->operations;
  518.     }
  520.     public function addOperation(Contract $operation): self
  521.     {
  522.         if (!$this->operations->contains($operation)) {
  523.             $this->operations[] = $operation;
  524.             $operation->setOperator($this);
  525.         }
  527.         return $this;
  528.     }
  530.     public function removeOperation(Contract $operation): self
  531.     {
  532.         if ($this->operations->removeElement($operation)) {
  533.             if ($operation->getOperator() === $this) {
  534.                 $operation->setOperator(null);
  535.             }
  536.         }
  538.         return $this;
  539.     }
  541.     // public function getLiftings(): Collection
  542.     // {
  543.     //     return $this->liftings;
  544.     // }
  546.     // public function addLifting(Lifting $lifting): self
  547.     // {
  548.     //     if (!$this->liftings->contains($lifting)) {
  549.     //         $this->liftings[] = $lifting;
  550.     //         $lifting->setOperator($this);
  551.     //     }
  553.     //     return $this;
  554.     // }
  556.     // public function removeLifting(Lifting $lifting): self
  557.     // {
  558.     //     if ($this->liftings->removeElement($lifting)) {
  559.     //         if ($lifting->getOperator() === $this) {
  560.     //             $lifting->setOperator(null);
  561.     //         }
  562.     //     }
  564.     //     return $this;
  565.     // }
  566. }