src/Entity/Team.php line 85

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\Annotation\ApiSubresource;
  8. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\OrderFilter;
  9. use ApiPlatform\Core\Bridge\Doctrine\Orm\Filter\SearchFilter;
  10. use ApiPlatform\Core\Serializer\Filter\GroupFilter;
  11. use ApiPlatform\Core\Serializer\Filter\PropertyFilter;
  12. use App\Repository\TeamRepository;
  13. use Doctrine\Common\Collections\ArrayCollection;
  14. use Doctrine\Common\Collections\Collection;
  15. use Doctrine\ORM\Mapping as ORM;
  16. use Gedmo\Mapping\Annotation as Gedmo;
  17. use Symfony\Component\HttpFoundation\File\UploadedFile;
  18. use Symfony\Component\Serializer\Annotation\Groups;
  19. use Symfony\Component\Validator\Constraints as Assert;
  21. /**
  22.  * @ApiResource(
  23.  *      normalizationContext={
  24.  *          "groups"={"team:read"}
  25.  *      },
  26.  *      denormalizationContext={
  27.  *          "groups"={"team:write"}
  28.  *      },
  29.  *      itemOperations={
  30.  *          "get"={
  31.  *              "security"="is_granted('ROLE_USER')"
  32.  *          }, 
  33.  *          "patch"={
  34.  *              "security"="is_granted('ROLE_USER')"
  35.  *          }, 
  36.  *          "delete"={
  37.  *              "security"="is_granted('ROLE_USER')"
  38.  *          }
  39.  *      },
  40.  *      collectionOperations={
  41.  *          "get"={
  42.  *              "security"="is_granted('ROLE_USER')"
  43.  *          }, 
  44.  *          "post"={
  45.  *              "security"="is_granted('ROLE_USER')"
  46.  *          },
  47.  *          "post_update"={
  48.  *              "security"="is_granted('ROLE_USER')",
  49.  *              "path"="/teams/{id}",
  50.  *              "description"="Update a Team with method POST (using content-type: 'multipart')",
  51.  *              "method"="POST",
  52.  *              "controller"="App\Controller\Api\TeamController::update"
  53.  *          },
  54.  *          "get_team_by_user_teamplay"={
  55.  *              "method"="GET",
  56.  *              "security"="is_granted('ROLE_USER')",
  57.  *              "path"="/users/{id}/teamplays/{teamplay}/team",
  58.  *              "controller"="App\Controller\Api\TeamController::getTeamplayTeamByUser",
  59.  *              "read"=false,
  60.  *              "pagination_enabled"=false,
  61.  *              "fetchEager"=true,
  62.  *              "defaults"={"_api_receive"=false}
  63.  *          }
  64.  *      }
  65.  * )
  66.  * @ORM\Entity(repositoryClass=TeamRepository::class)
  67.  * @ApiFilter(SearchFilter::class, properties={
  68.  *      "teamplay.id", "type", "active", "company.id",
  69.  *      "name": "partial"
  70.  * })
  71.  * @ApiFilter(OrderFilter::class)
  72.  * @ApiFilter(GroupFilter::class, 
  73.  *      arguments={
  74.  *          "parameterName": "groups", 
  75.  *          "overrideDefaultGroups": true
  76.  *      }
  77.  * )
  78.  *  @ApiFilter(PropertyFilter::class, 
  79.  *      arguments={
  80.  *          "parameterName"="fields", 
  81.  *          "overrideDefaultProperties"=true
  82.  *     }
  83.  * )
  84.  */
  85. class Team
  86. {
  87.     const TYPE_TEAMPLAY = "teamplay";
  89.     const TYPES = [
  90.         self::TYPE_TEAMPLAY
  91.     ];
  93.     /**
  94.      * @ORM\Id
  95.      * @ORM\GeneratedValue
  96.      * @ORM\Column(type="integer")
  97.      * @Groups({"team:read", "team:read:id", "team_user:read", "chat:read", "chat_message:read"})
  98.      */
  99.     private $id;
  101.     /**
  102.      * @ORM\Column(type="string", length=255, nullable=true)
  103.      * @Groups({"team:read", "team:write", "team:read:name", "team_user:read"})
  104.      */
  105.     private $name;
  107.     /**
  108.      * @ORM\Column(type="integer", nullable=true)
  109.      * @Groups({"team:read", "team:write", "team:read:maxCapacity", "team_user:read"})
  110.      */
  111.     private $maxCapacity;
  113.     /**
  114.      * @ORM\ManyToOne(targetEntity=MediaObject::class)
  115.      * @Groups({"team:read", "team:write", "team:read:picture", "team_user:read"})
  116.      */
  117.     private $picture;
  119.     /**
  120.      * @ORM\Column(type="string", length=255, nullable=true)
  121.      * @Assert\Choice(choices=self::TYPES)
  122.      * @Groups({"team:read", "team:write", "team:read:type"})
  123.      */
  124.     private $type = self::TYPE_TEAMPLAY;
  126.     /**
  127.      * @ORM\Column(type="boolean", nullable=true, options={"default": 1})
  128.      * @Groups({"team:read", "team:write", "team:read:active", "team_user:read"})
  129.      */
  130.     private $active = true;
  132.     /**
  133.      * @ORM\Column(type="datetime", nullable=true)
  134.      * @Gedmo\Timestampable(on="create")
  135.      * @Groups({"team:read", "team:read:createdAt"})
  136.      */
  137.     private $createdAt;
  139.     /**
  140.      * @ORM\Column(type="datetime", nullable=true)
  141.      * @Gedmo\Timestampable(on="update")
  142.      * @Groups({"team:read", "team:read:read"})
  143.      */
  144.     private $updatedAt;
  146.     /**
  147.      * @ORM\ManyToOne(targetEntity=TvCompany::class, inversedBy="teams")
  148.      */
  149.     private $tvCompany;
  151.     /**
  152.      * @ORM\ManyToOne(targetEntity=Company::class, inversedBy="teams")
  153.      * @Groups({"team:read", "team:write", "team:read:company"})
  154.      */
  155.     private $company;
  157.     /**
  158.      * @ORM\OneToMany(targetEntity=TeamUser::class, mappedBy="team", orphanRemoval=true)
  159.      * @Groups({"team:read", "team:write", "team:read:teamUsers"})
  160.      * @ApiSubresource(maxDepth=1)
  161.      */
  162.     private $teamUsers;
  164.     /**
  165.      * @ORM\ManyToOne(targetEntity=Teamplay::class, inversedBy="teams", cascade={"refresh"})
  166.      * @Groups({"team:read:teamplay", "team:read", "team:write"})
  167.      */
  168.     private $teamplay;
  170.     /**
  171.      * @ORM\Column(type="integer", nullable=true)
  172.      * @Groups({"team:read:points", "team:read"})
  173.      */
  174.     private $points;
  176.     /**
  177.      * @Groups({"team:read", "team:read:users"})
  178.      */
  179.     private $users;
  181.     /**
  182.      * @Groups({"team:read", "team:read:activeUsers"})
  183.      */
  184.     private $activeUsers = null;
  186.     /**
  187.      * @ORM\Column(name="`rank`", type="integer", nullable=true)
  188.      * @Groups({"team:read:rank", "team:read"})
  189.      */
  190.     private $rank = null;
  192.     /**
  193.      * Custom field
  194.      * @var ?int
  195.      * @Groups({"team:read:maxRank", "team:read"})
  196.      */
  197.     public $maxRank = null;
  199.     /**
  200.      * @var ?int
  201.      * @Groups({"team:read", "team:read:activeUsersCount"})
  202.      */
  203.     public $activeUsersCount = null;
  205.     /**
  206.      * @var ?int
  207.      * @Groups({"team:read", "team:read:usersCount"})
  208.      */
  209.     public $usersCount = null;
  211.     /**
  212.      * Cutsom field
  213.      * @var ?int
  214.      * @Groups({"team:read:", "team:read:remainingCapacity"})
  215.      */
  216.     private $remainingCapacity;
  218.     /**
  219.      * @Groups({"team:read", "team:read:chat"})
  220.      */
  221.     private $chat;
  223.     public function __construct()
  224.     {
  225.         $this->teamUsers = new ArrayCollection();
  226.         $this->users = new ArrayCollection();
  227.         $this->activeUsers = new ArrayCollection();
  228.     }
  230.     public function getId(): ?int
  231.     {
  232.         return $this->id;
  233.     }
  235.     public function getName(): ?string
  236.     {
  237.         return $this->name;
  238.     }
  240.     public function setName(?string $name): self
  241.     {
  242.         $this->name = $name;
  244.         return $this;
  245.     }
  247.     public function getMaxCapacity(): ?int
  248.     {
  249.         return $this->maxCapacity;
  250.     }
  252.     public function setMaxCapacity(?int $maxCapacity): self
  253.     {
  254.         $this->maxCapacity = $maxCapacity;
  256.         return $this;
  257.     }
  259.     public function getPicture(): ?MediaObject
  260.     {
  261.         return $this->picture;
  262.     }
  264.     public function setPicture(?MediaObject $picture): self
  265.     {
  266.         $this->picture = $picture;
  268.         return $this;
  269.     }
  271.     /**
  272.      * @Groups({"team:write"})
  273.      */
  274.     public function setPictureFile($file = null): self
  275.     {
  276.         if ($file instanceof UploadedFile) {
  277.             $picture = empty($this->picture) ? new MediaObject : $this->picture;
  278.             $picture->setFile($file);
  279.             $this->setPicture($picture);
  280.         }
  282.         return $this;
  283.     }
  285.     public function getType(): ?string
  286.     {
  287.         return $this->type;
  288.     }
  290.     public function setType(?string $type): self
  291.     {
  292.         $this->type = $type;
  294.         return $this;
  295.     }
  297.     public function getActive(): ?bool
  298.     {
  299.         return $this->active;
  300.     }
  302.     public function isActive(): ?bool
  303.     {
  304.         return $this->active;
  305.     }
  307.     public function setActive(?bool $active): self
  308.     {
  309.         $this->active = $active;
  311.         return $this;
  312.     }
  314.     public function getCreatedAt(): ?\DateTimeInterface
  315.     {
  316.         return $this->createdAt;
  317.     }
  319.     public function setCreatedAt(?\DateTimeInterface $createdAt): self
  320.     {
  321.         $this->createdAt = $createdAt;
  323.         return $this;
  324.     }
  326.     public function getUpdatedAt(): ?\DateTimeInterface
  327.     {
  328.         return $this->updatedAt;
  329.     }
  331.     public function setUpdatedAt(?\DateTimeInterface $updatedAt): self
  332.     {
  333.         $this->updatedAt = $updatedAt;
  335.         return $this;
  336.     }
  338.     public function getTvCompany(): ?TvCompany
  339.     {
  340.         return $this->tvCompany;
  341.     }
  343.     public function setTvCompany(?TvCompany $tvCompany): self
  344.     {
  345.         $this->tvCompany = $tvCompany;
  347.         return $this;
  348.     }
  350.     public function getCompany(): ?Company
  351.     {
  352.         return $this->company;
  353.     }
  355.     public function setCompany(?Company $company): self
  356.     {
  357.         $this->company = $company;
  359.         return $this;
  360.     }
  362.     /**
  363.      * Permet de savoir si l'équipe est de type "Teamplay"
  364.      * @return bool
  365.      */
  366.     public function isTeamplay(): bool
  367.     {
  368.         if ($this->type === self::TYPE_TEAMPLAY) return true;
  370.         return false;
  371.     }
  373.     /**
  374.      * @return Collection|TeamUser[]
  375.      */
  376.     public function getTeamUsers(): Collection
  377.     {
  378.         return $this->teamUsers;
  379.     }
  381.     public function addTeamUser(TeamUser $teamUser): self
  382.     {
  383.         if (!empty($teamUser->getId()) && !$this->teamUsers->contains($teamUser)) {
  384.             $this->teamUsers[] = $teamUser;
  385.             $teamUser->setTeam($this);
  386.         } else {
  387.             $isContains = false;
  388.             // Vérifie si l'utilisateur est deja dans l'équipe
  389.             foreach ($this->teamUsers->toArray() as $value) {
  390.                 if ($value->getTvUser()->getId() === $teamUser->getTvUser()->getId()) {
  391.                     $isContains = true;
  392.                 }
  393.             }
  394.             if (!$isContains) {
  395.                 $this->teamUsers[] = $teamUser;
  396.                 $teamUser->setTeam($this);
  397.             }
  398.         }
  400.         return $this;
  401.     }
  403.     public function removeTeamUser(TeamUser $teamUser): self
  404.     {
  405.         if ($this->teamUsers->removeElement($teamUser)) {
  406.             // set the owning side to null (unless already changed)
  407.             if ($teamUser->getTeam() === $this) {
  408.                 $teamUser->setTeam(null);
  409.             }
  410.         }
  412.         return $this;
  413.     }
  415.     /**
  416.      * @return ArrayCollection|User[]
  417.      */
  418.     public function getUsers(): ?ArrayCollection
  419.     {
  420.         $this->users = new ArrayCollection;
  421.         if (!empty($this->teamUsers->toArray())) {
  422.             foreach ($this->teamUsers->toArray() as $teamUser) {
  423.                 $this->users->add($teamUser->getUser());
  424.             }
  425.         }
  427.         return $this->users;
  428.     }
  430.     public function getTeamplay(): ?Teamplay
  431.     {
  432.         return $this->teamplay;
  433.     }
  435.     public function setTeamplay(?Teamplay $teamplay): self
  436.     {
  437.         $this->teamplay = $teamplay;
  439.         return $this;
  440.     }
  442.     public function getRank(): ?int
  443.     {
  444.         return $this->rank;
  445.     }
  447.     public function setRank(?int $rank): self
  448.     {
  449.         $this->rank = $rank;
  451.         return $this;
  452.     }
  454.     public function getPoints(): ?int
  455.     {
  456.         return $this->points;
  457.     }
  459.     public function setPoints(?int $points): self
  460.     {
  461.         $this->points = $points;
  463.         return $this;
  464.     }
  466.     /**
  467.      * @return Collection|TeamUser[]
  468.      * /**
  469.      * Renvoie le nombre d'User
  470.      * @Groups({"team:read:members"})
  471.      */
  472.     public function getMembers(): Collection
  473.     {
  474.         return $this->getTeamUsers();
  475.     }
  477.     /**
  478.      * Renvoie le nombre d'User
  479.      * @Groups({"team:read:membersCount"})
  480.      */
  481.     public function getMembersCount(): ?int
  482.     {
  483.         return $this->teamUsers->count();
  484.     }
  486.     public function getActiveUsers(): Collection
  487.     {
  488.         $this->activeUsers = new ArrayCollection();
  490.         if ($this->getUsers()->count() > 0) {
  491.             foreach ($this->getTeamUsers() as $teamUser) {
  492.                 if ($teamUser->getUser()->isActive()) {
  493.                     $this->activeUsers->add($teamUser->getUser());
  494.                 }
  495.             }
  496.         }
  498.         return $this->activeUsers;
  499.     }
  501.     public function getActiveUsersCount(): ?int
  502.     {
  503.         if ($this->getUsers()->count() > 0) {
  504.             foreach ($this->users as $user) {
  505.                 if ($user->isActive()) {
  506.                     $this->activeUsersCount++;
  507.                 }
  508.             }
  509.         }
  510.         return $this->activeUsersCount;
  511.     }
  513.     public function setActiveUsersCount(?int $activeUsersCount): self
  514.     {
  515.         $this->activeUsersCount = $activeUsersCount;
  517.         return $this;
  518.     }
  520.     public function getUsersCount(): ?int
  521.     {
  522.         $this->usersCount = $this->users->count();
  524.         return $this->usersCount;
  525.     }
  527.     public function setUsersCount(?int $usersCount): self
  528.     {
  529.         $this->usersCount = $usersCount;
  531.         return $this;
  532.     }
  534.     public function getRemainingCapacity(): ?int
  535.     {
  536.         $this->remainingCapacity = $this->getMaxCapacity() - $this->getActiveUsersCount();
  538.         return $this->remainingCapacity;
  539.     }
  541.     public function setRemainingCapacity(?int $remainingCapacity): self
  542.     {
  543.         $this->remainingCapacity = $remainingCapacity;
  545.         return $this;
  546.     }
  548.     public function getChat(): ?Chat
  549.     {
  550.         return $this->chat;
  551.     }
  553.     public function setChat(?Chat $chat): self
  554.     {
  555.         $this->chat = $chat;
  557.         return $this;
  558.     }
  559. }