src/Entity/Segmentation.php line 61

Open in your IDE?
  1. <?php
  3. namespace App\Entity;
  5. use ApiPlatform\Core\Annotation\ApiFilter;
  6. use ApiPlatform\Core\Annotation\ApiResource;
  7. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  8. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  9. use ApiPlatform\Core\Serializer\Filter\GroupFilter;
  10. use ApiPlatform\Core\Serializer\Filter\PropertyFilter;
  11. use App\Repository\SegmentationRepository;
  12. use Doctrine\Common\Collections\ArrayCollection;
  13. use Doctrine\Common\Collections\Collection;
  14. use Doctrine\ORM\Mapping as ORM;
  15. use Gedmo\Mapping\Annotation as Gedmo;
  16. use Symfony\Component\Serializer\Annotation\SerializedName;
  17. use Symfony\Component\Serializer\Annotation\Groups;
  18. use Symfony\Component\Validator\Constraints as Assert;
  20. /**
  21.  * @ORM\Entity(repositoryClass=SegmentationRepository::class)
  22.  * @ApiResource(
  23.  *      normalizationContext={"groups"={"segmentation:read"}},
  24.  *      denormalizationContext={"groups"={"segmentation:write"}},
  25.  *      itemOperations={
  26.  *          "get"={
  27.  *              "security"="is_granted('ROLE_USER')"
  28.  *          },
  29.  *          "patch"={
  30.  *              "security"="is_granted('ROLE_ADMIN')"
  31.  *          },
  32.  *          "delete"={
  33.  *              "security"="is_granted('ROLE_ADMIN')"
  34.  *          }
  35.  *      },
  36.  *      collectionOperations={
  37.  *          "get"={
  38.  *              "security"="is_granted('ROLE_USER')"
  39.  *          },
  40.  *          "post"={
  41.  *              "security"="is_granted('ROLE_ADMIN')"
  42.  *          }
  43.  *      }
  44.  * )
  45.  * @ApiFilter(SearchFilter::class)
  46.  * @ApiFilter(OrderFilter::class)
  47.  * @ApiFilter(GroupFilter::class, arguments={
  48.  *      "parameterName": "groups", 
  49.  *      "overrideDefaultGroups": true, 
  50.  *      "whitelist": {
  51.  *          "segmentation:form:read"
  52.  *      }
  53.  * }) 
  54.  * @ApiFilter(PropertyFilter::class, 
  55.  *      arguments={
  56.  *          "parameterName"="fields", 
  57.  *          "overrideDefaultProperties"=true
  58.  *     }
  59.  * )
  60.  */
  61. class Segmentation
  62. {
  63.     /**
  64.      * @ORM\Id
  65.      * @ORM\GeneratedValue
  66.      * @ORM\Column(type="integer")
  67.      * @Groups({"search", "segmentation:read", "client:read", "company:read", "client:read"})
  68.      */
  69.     private $id;
  71.     /**
  72.      * @Assert\NotBlank
  73.      * @Assert\NotNull
  74.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="segmentations")
  75.      * @Groups({"segmentation:read", "segmentation:write", "client:read"})
  76.      */
  77.     private $company;
  79.     /**
  80.      * @Assert\NotBlank
  81.      * @Assert\NotNull
  82.      * @ORM\Column(type="string", length=255, nullable=true)
  83.      * @Groups({"segmentation:read", "segmentation:write", "client:read", "company:read", "client:read"})
  84.      */
  85.     private $name;
  87.     /**
  88.      * @Assert\NotBlank
  89.      * @Assert\NotNull
  90.      * @ORM\Column(type="boolean", nullable=true, options={"default": "1"})
  91.      * @Groups({"segmentation:read", "segmentation:write", "client:read", "company:read"})
  92.      */
  93.     private $alone = true;
  95.     /**
  96.      * @Assert\NotBlank
  97.      * @Assert\NotNull
  98.      * @ORM\Column(type="boolean", nullable=true, options={"default": "1"})
  99.      * @Groups({"segmentation:read", "segmentation:write", "client:read", "company:read", "client:read"})
  100.      */
  101.     private $active = true;
  103.     /**
  104.      * Axe générant des classements challenge (pertinent uniquement sur les segmentations parentes)
  105.      * @ORM\Column(type="boolean", options={"default": 0})
  106.      * @Groups({"segmentation:read", "segmentation:write", "company:read", "client:read"})
  107.      */
  108.     private $ranked = false;
  110.     /**
  111.      * Ordre de l'axe dans le questionnaire de segmentation présenté à l'utilisateur.
  112.      * null par défaut ; les axes avec un rank défini sont demandés en premier, triés croissant.
  113.      * (`rank` est un mot réservé MySQL, d'où le name échappé)
  114.      * @ORM\Column(name="`rank`", type="integer", nullable=true)
  115.      * @Groups({"segmentation:read", "segmentation:write", "company:read", "client:read"})
  116.      */
  117.     private $rank = null;
  119.     /**
  120.      * @ORM\Column(type="datetime", nullable=true, options={"default": "CURRENT_TIMESTAMP"})
  121.      * @Groups({"segmentation:read", "segmentation:write", "company:read"})
  122.      * @Gedmo\Timestampable(on="create")
  123.      */
  124.     private $createdAt;
  126.     /**
  127.      * @ORM\Column(type="datetime", nullable=true, options={"default": "CURRENT_TIMESTAMP"})
  128.      * @Groups({"segmentation:read", "segmentation:write", "company:read"})
  129.      * @Gedmo\Timestampable(on="update")
  130.      */
  131.     private $updatedAt;
  133.     /**
  134.      * @ORM\ManyToOne(targetEntity=Segmentation::class, inversedBy="children")
  135.      * @Groups({"segmentation:read", "segmentation:write", "company:read"})
  136.      */
  137.     private $parent;
  139.     /**
  140.      * @ORM\OneToMany(targetEntity=Segmentation::class, mappedBy="parent")
  141.      * @Groups({"segmentation:read", "company:read"})
  142.      */
  143.     private $children;
  145.     /**
  146.      * @ORM\OneToMany(targetEntity=User::class, mappedBy="segmentation")
  147.      * @Groups({"segmentation:read"})
  148.      */
  149.     private $users;
  151.     /**
  152.      * @ORM\ManyToMany(targetEntity=Event::class, mappedBy="segmentations")
  153.      * @Groups({"segmentation:read", "company:read"})
  154.      */
  155.     private $events;
  157.     /**
  158.      * @ORM\OneToMany(targetEntity=Client::class, mappedBy="segmentation")
  159.      * @Groups({"segmentation:read"})
  160.      */
  161.     private $clients;
  163.     /**
  164.      * @ORM\OneToOne(targetEntity=Department::class, mappedBy="segmentation")
  165.      */
  166.     private $department;
  168.     /**
  169.      * @var bool 
  170.      * @Groups({"segmentation:read", "segmentation:write", "company:read"})
  171.      */
  172.     private $isParent = false;
  173.     
  174.     /**
  175.      * @var bool 
  176.      * @Groups({"segmentation:read", "segmentation:write", "company:read"})
  177.      */
  178.     private $isChild = false;
  179.     
  180.     public function __construct()
  181.     {
  182.         $this->children = new ArrayCollection();
  183.         $this->users = new ArrayCollection();
  184.         $this->events = new ArrayCollection();
  185.         $this->clients = new ArrayCollection();
  186.     }
  188.     public function __toString(): string
  189.     {
  190.         return ''.$this->id.' - '.$this->name;
  191.     }
  193.     public function getId(): ?int
  194.     {
  195.         return $this->id;
  196.     }
  198.     public function getCompany(): ?Company
  199.     {
  200.         return $this->company;
  201.     }
  203.     public function setCompany(?Company $company): self
  204.     {
  205.         $this->company = $company;
  207.         return $this;
  208.     }
  210.     public function getName(): ?string
  211.     {
  212.         return $this->name;
  213.     }
  215.     public function setName(?string $name): self
  216.     {
  217.         $this->name = $name;
  219.         return $this;
  220.     }
  222.     public function getAlone(): ?bool
  223.     {
  224.         return $this->alone;
  225.     }
  227.     public function isAlone(): ?bool
  228.     {
  229.         return $this->alone;
  230.     }
  232.     public function setAlone(?bool $alone): self
  233.     {
  234.         $this->alone = $alone;
  236.         return $this;
  237.     }
  239.     public function getActive(): ?bool
  240.     {
  241.         return $this->active;
  242.     }
  244.     public function setActive(?bool $active): self
  245.     {
  246.         $this->active = $active;
  248.         return $this;
  249.     }
  251.     public function isRanked(): bool
  252.     {
  253.         return $this->ranked;
  254.     }
  256.     public function getRanked(): bool
  257.     {
  258.         return $this->ranked;
  259.     }
  261.     public function setRanked(bool $ranked): self
  262.     {
  263.         $this->ranked = $ranked;
  265.         return $this;
  266.     }
  268.     public function getRank(): ?int
  269.     {
  270.         return $this->rank;
  271.     }
  273.     public function setRank(?int $rank): self
  274.     {
  275.         $this->rank = $rank;
  277.         return $this;
  278.     }
  280.     public function getCreatedAt(): ?\DateTimeInterface
  281.     {
  282.         return $this->createdAt;
  283.     }
  285.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  286.     {
  287.         $this->createdAt = $createdAt;
  289.         return $this;
  290.     }
  292.     public function getUpdatedAt(): ?\DateTimeInterface
  293.     {
  294.         return $this->updatedAt;
  295.     }
  297.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  298.     {
  299.         $this->updatedAt = $updatedAt;
  301.         return $this;
  302.     }
  304.     public function getParent(): ?self
  305.     {
  306.         return $this->parent;
  307.     }
  309.     public function setParent(?self $parent): self
  310.     {
  311.         $this->parent = $parent;
  313.         return $this;
  314.     }
  316.     /**
  317.      * @return Collection<int, self>
  318.      */
  319.     public function getChildren(): Collection
  320.     {
  321.         return $this->children;
  322.     }
  324.     public function addChild(self $child): self
  325.     {
  326.         if (!$this->children->contains($child)) {
  327.             $this->children[] = $child;
  328.             $child->setParent($this);
  329.         }
  331.         return $this;
  332.     }
  334.     public function removeChild(self $child): self
  335.     {
  336.         if ($this->children->removeElement($child)) {
  337.             // set the owning side to null (unless already changed)
  338.             if ($child->getParent() === $this) {
  339.                 $child->setParent(null);
  340.             }
  341.         }
  343.         return $this;
  344.     }
  346.     public function isParent(): bool
  347.     {
  348.         $this->isParent = ($this->getChildren()->count() > 0) ? true : false;
  350.         return $this->isParent;
  351.     }
  353.     public function isChild(): bool
  354.     {
  355.         $this->isChild = (!empty($this->getParent())) ? true : false;
  357.         return $this->isChild;
  358.     }
  360.     public function getIsParent(): bool
  361.     {
  362.         return $this->isParent();
  363.     }
  365.     public function getIsChild(): bool
  366.     {
  367.         return $this->isChild();
  368.     }
  370.     /**
  371.      * @return Collection<int, User>
  372.      */
  373.     public function getUsers(): Collection
  374.     {
  375.         return $this->users;
  376.     }
  378.     public function addUser(User $user): self
  379.     {
  380.         if (!$this->users->contains($user)) {
  381.             $this->users[] = $user;
  382.             $user->setSegmentation($this);
  383.         }
  385.         return $this;
  386.     }
  388.     public function removeUser(User $user): self
  389.     {
  390.         if ($this->users->removeElement($user)) {
  391.             // set the owning side to null (unless already changed)
  392.             if ($user->getSegmentation() === $this) {
  393.                 $user->setSegmentation(null);
  394.             }
  395.         }
  397.         return $this;
  398.     }
  400.     /**
  401.      * @return Collection<int, Event>
  402.      */
  403.     public function getEvents(): Collection
  404.     {
  405.         return $this->events;
  406.     }
  408.     public function addEvent(Event $event): self
  409.     {
  410.         if (!$this->events->contains($event)) {
  411.             $this->events[] = $event;
  412.             $event->addSegmentation($this);
  413.         }
  415.         return $this;
  416.     }
  418.     public function removeEvent(Event $event): self
  419.     {
  420.         if ($this->events->removeElement($event)) {
  421.             $event->removeSegmentation($this);
  422.         }
  424.         return $this;
  425.     }
  427.     /**
  428.      * @Groups({"search"})
  429.      * @SerializedName("text")
  430.      * @return string
  431.      */
  432.     public function getText(): string
  433.     {
  434.         return (string)$this;
  435.     }
  437.     /**
  438.      * @return Collection<int, Client>
  439.      */
  440.     public function getClients(): Collection
  441.     {
  442.         return $this->clients;
  443.     }
  445.     public function addClient(Client $client): self
  446.     {
  447.         if (!$this->clients->contains($client)) {
  448.             $this->clients[] = $client;
  449.             $client->setSegmentation($this);
  450.         }
  452.         return $this;
  453.     }
  455.     public function removeClient(Client $client): self
  456.     {
  457.         if ($this->clients->removeElement($client)) {
  458.             // set the owning side to null (unless already changed)
  459.             if ($client->getSegmentation() === $this) {
  460.                 $client->setSegmentation(null);
  461.             }
  462.         }
  464.         return $this;
  465.     }
  467.     /**
  468.      * @return Collection<int, Event>
  469.      */
  470.     public function getActiveEvents(): Collection
  471.     {
  472.         $activeEvents = new ArrayCollection();
  473.         foreach ($this->events as $key => $event) {
  474.             if ($event->getStatus() == Event::STATUS_VALID) {
  475.                 $activeEvents->add($event);
  476.             }
  477.         }
  478.         return $activeEvents;
  479.     }
  481.     public function getDepartment(): ?Department
  482.     {
  483.         return $this->department;
  484.     }
  486.     public function setDepartment(?Department $department): self
  487.     {
  488.         $this->department = $department;
  490.         return $this;
  491.     }
  492. }