EventsController::deleteEventUserAction() - Code Metrics - KIClubinfo/upont - Measure and Improve Code Quality continuously with Scrutinizer

EventsController::deleteEventUserAction() A
last analyzed 2018-09-27 16:55 UTC

↳ Parent: EventsController

Complexity

Conditions	3
Paths	3

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	32
rs	9.408
c	0
b	0
f	0
cc	3
nc	3
nop	1

<?php

namespace KI\PublicationBundle\Controller;

use KI\CoreBundle\Controller\ResourceController;
use KI\PublicationBundle\Entity\Event;
use KI\PublicationBundle\Entity\EventUser;
use KI\UserBundle\Entity\Achievement;
use KI\UserBundle\Event\AchievementCheckEvent;
use Nelmio\ApiDocBundle\Annotation\ApiDoc;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;

class EventsController extends ResourceController
{
    public function setContainer(ContainerInterface $container = null)
    {
        parent::setContainer($container);
        $this->initialize('Event', 'Publication');
    }

    /**
     * @ApiDoc(
     *  resource=true,
     *  description="Liste les événements",
     *  output="KI\PublicationBundle\Entity\Event",
     *  statusCodes={
     *   200="Requête traitée avec succès",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events")
     * @Method("GET")
     */
    public function getEventsAction()
    {
        return $this->getAll();
    }

    /**
     * @ApiDoc(
     *  description="Retourne un événement",
     *  output="KI\PublicationBundle\Entity\Event",
     *  statusCodes={
     *   200="Requête traitée avec succès",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}")
     * @Method("GET")
     */
    public function getEventAction($slug)
    {
        $event = $this->getOne($slug);

        return $this->json($event);
    }

    /**
     * @ApiDoc(
     *  description="Crée un événement",
     *  input="KI\PublicationBundle\Form\EventType",
     *  output="KI\PublicationBundle\Entity\Event",
     *  statusCodes={
     *   201="Requête traitée avec succès avec création d’un document",
     *   400="La syntaxe de la requête est erronée",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events")
     * @Method("POST")
     */
    public function postEventAction()
    {
        $data = $this->post($this->isClubMember());

        if ($data['code'] == 201) {
            $this->get('ki_publication.listener.event')->postPersist($data['item']);
        }

        return $this->formJson($data);
    }

    /**
     * @ApiDoc(
     *  description="Modifie un événement",
     *  input="KI\PublicationBundle\Form\EventType",
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   400="La syntaxe de la requête est erronée",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}")
     * @Method("PATCH")
     */
    public function patchEventAction($slug)
    {
        $item = $this->findBySlug($slug);
        $oldItem = clone $item;

        $club = $item->getAuthorClub();
        $club = $club ? $club->getSlug() : $club;
        $data = $this->patch($slug, $this->isClubMember($club));
        $this->get('ki_publication.listener.event')->postUpdate($item, $oldItem);

        return $this->formJson($data);
    }

    /**
     * @ApiDoc(
     *  description="Supprime un événement",
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}")
     * @Method("DELETE")
     */
    public function deleteEventAction($slug)
    {
        $club = $this->findBySlug($slug)->getAuthorClub();
        $club = $club ? $club->getSlug() : $club;
        $event = $this->findBySlug($slug);

        // On n'oublie pas de supprimer tous les shotguns éventuellement associés
        $repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
        $userEvent = $repo->findByEvent($event);

        foreach ($userEvent as $item) {
            $this->manager->remove($item);
        }

        $this->delete($slug, $this->isClubMember($club));

        return $this->json(null, 204);
    }

    /**
     * @ApiDoc(
     *  description="Shotgunne un événement",
     *  requirements={
     *   {
     *    "name"="motivation",
     *    "dataType"="string",
     *    "description"="Un texte de motivation"
     *   }
     *  },
     *  output="KI\PublicationBundle\Entity\EventUser",
     *  statusCodes={
     *   201="Requête traitée avec succès avec création d’un document",
     *   400="La syntaxe de la requête est erronée",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/shotgun")
     * @Method("POST")
     */
    public function postEventUserAction(Request $request, $slug)
    {
        $event = $this->findBySlug($slug);

        if ($event->getEntryMethod() != Event::TYPE_SHOTGUN)
            throw new BadRequestHttpException('Ce n\'est pas un événement à shotgun !');

        if (!$request->request->has('motivation'))
            throw new BadRequestHttpException('Texte de motivation manquant');

        $repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
        $user = $this->user;
        $userEvent = $repo->findBy(['event' => $event, 'user' => $user]);

        // On vérifie que l'utilisateur n'a pas déjà shotguné
        if (count($userEvent) != 0)
            throw new BadRequestHttpException('Tu es déjà inscrit !');

        //S'il est l'heure, on accepte le shotgun
        if (time() >= $event->getShotgunDate()) {
            $userEvent = new EventUser();
            $userEvent->setEvent($event);
            $userEvent->setUser($user);
            $userEvent->setDate(time());
            $userEvent->setMotivation($request->request->get('motivation'));

            $this->manager->persist($userEvent);
            $this->manager->flush();
        }

        return $this->json(null, 204);
    }

    /**
     * @ApiDoc(
     *  description="Modifie un shotgun",
     *  requirements={
     *   {
     *    "name"="motivation",
     *    "dataType"="string",
     *    "description"="Un texte de motivation"
     *   }
     *  },
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   400="La syntaxe de la requête est erronée",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/shotgun")
     * @Method("PATCH")
     */
    public function patchEventUserAction(Request $request, $slug)
    {
        $event = $this->findBySlug($slug);
        if ($event->getEntryMethod() != Event::TYPE_SHOTGUN)
            throw new BadRequestHttpException('Ce n\'est pas un événement à shotgun !');

        if (!$request->request->has('motivation'))
            throw new BadRequestHttpException('Texte de motivation manquant');

        $repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
        $user = $this->user;
        $userEvent = $repo->findBy(['event' => $event, 'user' => $user]);

        if (count($userEvent) == 1) {
            $userEvent[0]->setMotivation($request->request->get('motivation'));
            $this->manager->flush();
        } else {
            throw new NotFoundHttpException('Participation au shotgun non trouvée');
        }

        return $this->json(null, 204);
    }

    /**
     * @ApiDoc(
     *  description="Enlève un utilisateur du shotgun",
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/shotgun")
     * @Method("DELETE")
     */
    public function deleteEventUserAction($slug)
    {
        $event = $this->findBySlug($slug);

        $repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
        $user = $this->user;
        $userEvent = $repo->findBy(['event' => $event, 'user' => $user]);

        if (count($userEvent) == 1) {
            $event = $userEvent[0]->getEvent();

            // On regarde si une place s'est libérée pour quelqu'un, au cas où
            // on le prévient
            $userEvents = $repo->findBy(['event' => $event], ['date' => 'ASC']);

            if (isset($userEvents[$event->getShotgunLimit()])) {
                $this->get('ki_user.service.notify')->notify(
                    'notif_shotgun_freed',
                    $event->getName(),
                    'Des places de shotgun se sont libérées, tu as maintenant accès à l\'événément !',
                    'to',
                    $userEvents[$event->getShotgunLimit()]->getUser()
                );
            }

            $this->manager->remove($userEvent[0]);
            $this->manager->flush();
        } else {
            throw new NotFoundHttpException('Participation au shotgun non trouvée');
        }
        return $this->json(null, 204);
    }

    /**
     * @ApiDoc(
     *  description="Retourne le tableau des utilisateurs ayant réussi le shotgun ainsi que la liste d'attente classée par date de shotgun et le nombre limite de personnes pouvant shotgunner.",
     *  statusCodes={
     *   200="Requête traitée avec succès",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/shotgun")
     * @Method("GET")
     */
    public function getEventUserAction($slug)
    {
        $event = $this->findBySlug($slug);

        $repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
        $user = $this->user;
        $userEvent = $repo->findBy(['event' => $event], ['date' => 'ASC']);

        $position = 0;
        $limit = $event->getShotgunLimit();

        $fail = $success = $shotgun = [];
        $count = min(count($userEvent), $limit);

        for ($i = 0; $i < $count; $i++) {
            if ($user == $userEvent[$i]->getUser())
                $position = $i + 1;

            $shotgun['user'] = $userEvent[$i]->getUser();
            $shotgun['date'] = $userEvent[$i]->getDate();

            if ($user == $event->getAuthorUser()) {
                $shotgun['motivation'] = $userEvent[$i]->getMotivation();
            }
            $success[] = $shotgun;
        }

        $count = count($userEvent);
        for ($i = $limit; $i < $count; $i++) {
            if ($user == $userEvent[$i]->getUser())
                $position = $i + 1;

            $shotgun['user'] = $userEvent[$i]->getUser();
            $shotgun['date'] = $userEvent[$i]->getDate();

            if ($user == $event->getAuthorUser()) {
                $shotgun['motivation'] = $userEvent[$i]->getMotivation();
            }

            $fail[] = $shotgun;
        }

        $result = [
            'status' => $position <= $limit && $position > 0,
            'limit' => $limit,
            'date' => $event->getShotgunDate()
        ];

        // Si on est l'auteur du shotgun, on peut récupérer la liste d'attente
        if ($event->getAuthorUser() == $user) {
            // It's a trap
            if (time() >= $event->getShotgunDate()){
                $result['success'] = $success;
                $result['fail'] = $fail;
            } else {
                $result['success'] = [];
                $result['fail'] = [];
            }
        }

        if ($this->is('ADMIN')){
            $result['success'] = $success;
            $result['fail'] = $fail;
        }

        if ($position != 0) {
            $result['position'] = $position;
        }
        if ($position <= $limit && $position > 0) {
            $result['shotgunText'] = $event->getShotgunText();
        } else if ($position > $limit) {
            // La liste d'attente commence à 0.
            $result['waitingList'] = $position - $limit;
        }

        return $this->json($result);
    }

    /**
     * @ApiDoc(
     *  description="Ajoute un utilisateur à l'event",
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/attend")
     * @Method("POST")
     */
    public function attendAction($slug)
    {
        $user = $this->user;
        $event = $this->findBySlug($slug);

        if ($event->getAttendees()->contains($user)) {
            throw new BadRequestHttpException('Vous participez déjà à cet évènement');
        } else {
            // On enlève éventuellement l'utilisateur des pookies
            if ($event->getPookies()->contains($user))
                $event->removePookie($user);

            $event->addAttendee($user);
            $this->manager->flush();

            $dispatcher = $this->container->get('event_dispatcher');
            $achievementCheck = new AchievementCheckEvent(Achievement::EVENT_ATTEND);
            $dispatcher->dispatch('upont.achievement', $achievementCheck);

            return $this->json(null, 204);
        }
    }

    /**
     * @ApiDoc(
     *  description="Retire la demande d'inscription",
     *  statusCodes={
     *   204="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/attend")
     * @Method("DELETE")
     */
    public function noAttendAction($slug)
    {
        $user = $this->user;
        $event = $this->findBySlug($slug);

        if (!$event->getAttendees()->contains($user)) {
            throw new BadRequestHttpException('Vous ne participez pas à cet évènement');
        } else {
            $event->removeAttendee($user);
            $this->manager->flush();

            return $this->json(null, 204);
        }
    }

    /**
     * @ApiDoc(
     *  description="Ajoute un utilisateur qui ne vient pas à l'event",
     *  statusCodes={
     *   200="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/decline")
     * @Method("POST")
     */
    public function addPookieAction($slug)
    {
        $user = $this->user;
        $event = $this->findBySlug($slug);

        if ($event->getPookies()->contains($user)) {
            throw new BadRequestHttpException('Vous ne participez déjà pas à cet évènement');
        } else {
            // On ne fait plus participer l'utilisateur s'il participait auparavent
            if ($event->getAttendees()->contains($user))
                $event->removeAttendee($user);

            $event->addPookie($user);
            $this->manager->flush();

            return $this->json(null, 204);
        }
    }

    /**
     * @ApiDoc(
     *  description="Retire la demande de désinscription",
     *  statusCodes={
     *   200="Requête traitée avec succès mais pas d’information à renvoyer",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/decline")
     * @Method("DELETE")
     */
    public function removePookieAction($slug)
    {
        $user = $this->user;
        $event = $this->findBySlug($slug);

        if (!$event->getPookies()->contains($user)) {
            throw new BadRequestHttpException('Vous ne vous êtes pas désinscrit de cet évènement');
        } else {
            $event->removePookie($user);
            $this->manager->flush();

            return $this->json(null, 204);
        }
    }

    /**
     * @ApiDoc(
     *  description="Retourne la liste des participants à l'événement",
     *  statusCodes={
     *   200="Requête traitée avec succès",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/attendees")
     * @Method("GET")
     */
    public function getAttendeesAction($slug)
    {
        return $this->json($this->findBySlug($slug)->getAttendees());
    }

    /**
     * @ApiDoc(
     *  description="Retourne la liste des non-participants à l'événement",
     *  statusCodes={
     *   200="Requête traitée avec succès",
     *   401="Une authentification est nécessaire pour effectuer cette action",
     *   403="Pas les droits suffisants pour effectuer cette action",
     *   404="Ressource non trouvée",
     *   503="Service temporairement indisponible ou en maintenance",
     *  },
     *  section="Publications"
     * )
     * @Route("/events/{slug}/pookies")
     * @Method("GET")
     */
    public function getPookiesAction($slug)
    {
        return $this->json($this->findBySlug($slug)->getPookies());
    }
}


1		<?php
2
3		namespace KI\PublicationBundle\Controller;
4
5		use KI\CoreBundle\Controller\ResourceController;
6		use KI\PublicationBundle\Entity\Event;
7		use KI\PublicationBundle\Entity\EventUser;
8		use KI\UserBundle\Entity\Achievement;
9		use KI\UserBundle\Event\AchievementCheckEvent;
10		use Nelmio\ApiDocBundle\Annotation\ApiDoc;
11		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Method;
12		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
13		use Symfony\Component\DependencyInjection\ContainerInterface;
14		use Symfony\Component\HttpFoundation\Request;
15		use Symfony\Component\HttpKernel\Exception\BadRequestHttpException;
16		use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
17
18		class EventsController extends ResourceController
19		{
20		public function setContainer(ContainerInterface $container = null)
21		{
22		parent::setContainer($container);
23		$this->initialize('Event', 'Publication');
24		}
25
26		/**
27		* @ApiDoc(
28		* resource=true,
29		* description="Liste les événements",
30		* output="KI\PublicationBundle\Entity\Event",
31		* statusCodes={
32		* 200="Requête traitée avec succès",
33		* 401="Une authentification est nécessaire pour effectuer cette action",
34		* 403="Pas les droits suffisants pour effectuer cette action",
35		* 503="Service temporairement indisponible ou en maintenance",
36		* },
37		* section="Publications"
38		* )
39		* @Route("/events")
40		* @Method("GET")
41		*/
42		public function getEventsAction()
43		{
44		return $this->getAll();
45		}
46
47		/**
48		* @ApiDoc(
49		* description="Retourne un événement",
50		* output="KI\PublicationBundle\Entity\Event",
51		* statusCodes={
52		* 200="Requête traitée avec succès",
53		* 401="Une authentification est nécessaire pour effectuer cette action",
54		* 403="Pas les droits suffisants pour effectuer cette action",
55		* 404="Ressource non trouvée",
56		* 503="Service temporairement indisponible ou en maintenance",
57		* },
58		* section="Publications"
59		* )
60		* @Route("/events/{slug}")
61		* @Method("GET")
62		*/
63		public function getEventAction($slug)
64		{
65		$event = $this->getOne($slug);
66
67		return $this->json($event);
68		}
69
70		/**
71		* @ApiDoc(
72		* description="Crée un événement",
73		* input="KI\PublicationBundle\Form\EventType",
74		* output="KI\PublicationBundle\Entity\Event",
75		* statusCodes={
76		* 201="Requête traitée avec succès avec création d’un document",
77		* 400="La syntaxe de la requête est erronée",
78		* 401="Une authentification est nécessaire pour effectuer cette action",
79		* 403="Pas les droits suffisants pour effectuer cette action",
80		* 503="Service temporairement indisponible ou en maintenance",
81		* },
82		* section="Publications"
83		* )
84		* @Route("/events")
85		* @Method("POST")
86		*/
87	View Code Duplication	public function postEventAction()
88		{
89		$data = $this->post($this->isClubMember());
90
91		if ($data['code'] == 201) {
92		$this->get('ki_publication.listener.event')->postPersist($data['item']);
93		}
94
95		return $this->formJson($data);
96		}
97
98		/**
99		* @ApiDoc(
100		* description="Modifie un événement",
101		* input="KI\PublicationBundle\Form\EventType",
102		* statusCodes={
103		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
104		* 400="La syntaxe de la requête est erronée",
105		* 401="Une authentification est nécessaire pour effectuer cette action",
106		* 403="Pas les droits suffisants pour effectuer cette action",
107		* 404="Ressource non trouvée",
108		* 503="Service temporairement indisponible ou en maintenance",
109		* },
110		* section="Publications"
111		* )
112		* @Route("/events/{slug}")
113		* @Method("PATCH")
114		*/
115		public function patchEventAction($slug)
116		{
117		$item = $this->findBySlug($slug);
118		$oldItem = clone $item;
119
120		$club = $item->getAuthorClub();
121		$club = $club ? $club->getSlug() : $club;
122		$data = $this->patch($slug, $this->isClubMember($club));
123		$this->get('ki_publication.listener.event')->postUpdate($item, $oldItem);
124
125		return $this->formJson($data);
126		}
127
128		/**
129		* @ApiDoc(
130		* description="Supprime un événement",
131		* statusCodes={
132		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
133		* 401="Une authentification est nécessaire pour effectuer cette action",
134		* 403="Pas les droits suffisants pour effectuer cette action",
135		* 404="Ressource non trouvée",
136		* 503="Service temporairement indisponible ou en maintenance",
137		* },
138		* section="Publications"
139		* )
140		* @Route("/events/{slug}")
141		* @Method("DELETE")
142		*/
143		public function deleteEventAction($slug)
144		{
145		$club = $this->findBySlug($slug)->getAuthorClub();
146		$club = $club ? $club->getSlug() : $club;
147		$event = $this->findBySlug($slug);
148
149		// On n'oublie pas de supprimer tous les shotguns éventuellement associés
150		$repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
151		$userEvent = $repo->findByEvent($event);
152
153		foreach ($userEvent as $item) {
154		$this->manager->remove($item);
155		}
156
157		$this->delete($slug, $this->isClubMember($club));
158
159		return $this->json(null, 204);
160		}
161
162		/**
163		* @ApiDoc(
164		* description="Shotgunne un événement",
165		* requirements={
166		* {
167		* "name"="motivation",
168		* "dataType"="string",
169		* "description"="Un texte de motivation"
170		* }
171		* },
172		* output="KI\PublicationBundle\Entity\EventUser",
173		* statusCodes={
174		* 201="Requête traitée avec succès avec création d’un document",
175		* 400="La syntaxe de la requête est erronée",
176		* 401="Une authentification est nécessaire pour effectuer cette action",
177		* 403="Pas les droits suffisants pour effectuer cette action",
178		* 503="Service temporairement indisponible ou en maintenance",
179		* },
180		* section="Publications"
181		* )
182		* @Route("/events/{slug}/shotgun")
183		* @Method("POST")
184		*/
185		public function postEventUserAction(Request $request, $slug)
186		{
187		$event = $this->findBySlug($slug);
188
189		if ($event->getEntryMethod() != Event::TYPE_SHOTGUN)
190		throw new BadRequestHttpException('Ce n\'est pas un événement à shotgun !');
191
192		if (!$request->request->has('motivation'))
193		throw new BadRequestHttpException('Texte de motivation manquant');
194
195		$repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
196		$user = $this->user;
197		$userEvent = $repo->findBy(['event' => $event, 'user' => $user]);
198
199		// On vérifie que l'utilisateur n'a pas déjà shotguné
200		if (count($userEvent) != 0)
201		throw new BadRequestHttpException('Tu es déjà inscrit !');
202
203		//S'il est l'heure, on accepte le shotgun
204		if (time() >= $event->getShotgunDate()) {
205		$userEvent = new EventUser();
206		$userEvent->setEvent($event);
207		$userEvent->setUser($user);
208		$userEvent->setDate(time());
209		$userEvent->setMotivation($request->request->get('motivation'));
210
211		$this->manager->persist($userEvent);
212		$this->manager->flush();
213		}
214
215		return $this->json(null, 204);
216		}
217
218		/**
219		* @ApiDoc(
220		* description="Modifie un shotgun",
221		* requirements={
222		* {
223		* "name"="motivation",
224		* "dataType"="string",
225		* "description"="Un texte de motivation"
226		* }
227		* },
228		* statusCodes={
229		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
230		* 400="La syntaxe de la requête est erronée",
231		* 401="Une authentification est nécessaire pour effectuer cette action",
232		* 403="Pas les droits suffisants pour effectuer cette action",
233		* 404="Ressource non trouvée",
234		* 503="Service temporairement indisponible ou en maintenance",
235		* },
236		* section="Publications"
237		* )
238		* @Route("/events/{slug}/shotgun")
239		* @Method("PATCH")
240		*/
241		public function patchEventUserAction(Request $request, $slug)
242		{
243		$event = $this->findBySlug($slug);
244		if ($event->getEntryMethod() != Event::TYPE_SHOTGUN)
245		throw new BadRequestHttpException('Ce n\'est pas un événement à shotgun !');
246
247		if (!$request->request->has('motivation'))
248		throw new BadRequestHttpException('Texte de motivation manquant');
249
250		$repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
251		$user = $this->user;
252		$userEvent = $repo->findBy(['event' => $event, 'user' => $user]);
253
254		if (count($userEvent) == 1) {
255		$userEvent[0]->setMotivation($request->request->get('motivation'));
256		$this->manager->flush();
257		} else {
258		throw new NotFoundHttpException('Participation au shotgun non trouvée');
259		}
260
261		return $this->json(null, 204);
262		}
263
264		/**
265		* @ApiDoc(
266		* description="Enlève un utilisateur du shotgun",
267		* statusCodes={
268		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
269		* 401="Une authentification est nécessaire pour effectuer cette action",
270		* 403="Pas les droits suffisants pour effectuer cette action",
271		* 404="Ressource non trouvée",
272		* 503="Service temporairement indisponible ou en maintenance",
273		* },
274		* section="Publications"
275		* )
276		* @Route("/events/{slug}/shotgun")
277		* @Method("DELETE")
278		*/
279		public function deleteEventUserAction($slug)
280		{
281		$event = $this->findBySlug($slug);
282
283		$repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
284		$user = $this->user;
285		$userEvent = $repo->findBy(['event' => $event, 'user' => $user]);
286
287		if (count($userEvent) == 1) {
288		$event = $userEvent[0]->getEvent();
289
290		// On regarde si une place s'est libérée pour quelqu'un, au cas où
291		// on le prévient
292		$userEvents = $repo->findBy(['event' => $event], ['date' => 'ASC']);
293
294		if (isset($userEvents[$event->getShotgunLimit()])) {
295		$this->get('ki_user.service.notify')->notify(
296		'notif_shotgun_freed',
297		$event->getName(),
298		'Des places de shotgun se sont libérées, tu as maintenant accès à l\'événément !',
299		'to',
300		$userEvents[$event->getShotgunLimit()]->getUser()
301		);
302		}
303
304		$this->manager->remove($userEvent[0]);
305		$this->manager->flush();
306		} else {
307		throw new NotFoundHttpException('Participation au shotgun non trouvée');
308		}
309		return $this->json(null, 204);
310		}
311
312		/**
313		* @ApiDoc(
314		* description="Retourne le tableau des utilisateurs ayant réussi le shotgun ainsi que la liste d'attente classée par date de shotgun et le nombre limite de personnes pouvant shotgunner.",
315		* statusCodes={
316		* 200="Requête traitée avec succès",
317		* 401="Une authentification est nécessaire pour effectuer cette action",
318		* 403="Pas les droits suffisants pour effectuer cette action",
319		* 404="Ressource non trouvée",
320		* 503="Service temporairement indisponible ou en maintenance",
321		* },
322		* section="Publications"
323		* )
324		* @Route("/events/{slug}/shotgun")
325		* @Method("GET")
326		*/
327		public function getEventUserAction($slug)
328		{
329		$event = $this->findBySlug($slug);
330
331		$repo = $this->manager->getRepository('KIPublicationBundle:EventUser');
332		$user = $this->user;
333		$userEvent = $repo->findBy(['event' => $event], ['date' => 'ASC']);
334
335		$position = 0;
336		$limit = $event->getShotgunLimit();
337
338		$fail = $success = $shotgun = [];
339		$count = min(count($userEvent), $limit);
340
341	View Code Duplication	for ($i = 0; $i < $count; $i++) {
342		if ($user == $userEvent[$i]->getUser())
343		$position = $i + 1;
344
345		$shotgun['user'] = $userEvent[$i]->getUser();
346		$shotgun['date'] = $userEvent[$i]->getDate();
347
348		if ($user == $event->getAuthorUser()) {
349		$shotgun['motivation'] = $userEvent[$i]->getMotivation();
350		}
351		$success[] = $shotgun;
352		}
353
354		$count = count($userEvent);
355	View Code Duplication	for ($i = $limit; $i < $count; $i++) {
356		if ($user == $userEvent[$i]->getUser())
357		$position = $i + 1;
358
359		$shotgun['user'] = $userEvent[$i]->getUser();
360		$shotgun['date'] = $userEvent[$i]->getDate();
361
362		if ($user == $event->getAuthorUser()) {
363		$shotgun['motivation'] = $userEvent[$i]->getMotivation();
364		}
365
366		$fail[] = $shotgun;
367		}
368
369		$result = [
370		'status' => $position <= $limit && $position > 0,
371		'limit' => $limit,
372		'date' => $event->getShotgunDate()
373		];
374
375		// Si on est l'auteur du shotgun, on peut récupérer la liste d'attente
376		if ($event->getAuthorUser() == $user) {
377		// It's a trap
378		if (time() >= $event->getShotgunDate()){
379		$result['success'] = $success;
380		$result['fail'] = $fail;
381		} else {
382		$result['success'] = [];
383		$result['fail'] = [];
384		}
385		}
386
387		if ($this->is('ADMIN')){
388		$result['success'] = $success;
389		$result['fail'] = $fail;
390		}
391
392		if ($position != 0) {
393		$result['position'] = $position;
394		}
395		if ($position <= $limit && $position > 0) {
396		$result['shotgunText'] = $event->getShotgunText();
397		} else if ($position > $limit) {
398		// La liste d'attente commence à 0.
399		$result['waitingList'] = $position - $limit;
400		}
401
402		return $this->json($result);
403		}
404
405		/**
406		* @ApiDoc(
407		* description="Ajoute un utilisateur à l'event",
408		* statusCodes={
409		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
410		* 401="Une authentification est nécessaire pour effectuer cette action",
411		* 403="Pas les droits suffisants pour effectuer cette action",
412		* 404="Ressource non trouvée",
413		* 503="Service temporairement indisponible ou en maintenance",
414		* },
415		* section="Publications"
416		* )
417		* @Route("/events/{slug}/attend")
418		* @Method("POST")
419		*/
420		public function attendAction($slug)
421		{
422		$user = $this->user;
423		$event = $this->findBySlug($slug);
424
425		if ($event->getAttendees()->contains($user)) {
426		throw new BadRequestHttpException('Vous participez déjà à cet évènement');
427		} else {
428		// On enlève éventuellement l'utilisateur des pookies
429		if ($event->getPookies()->contains($user))
430		$event->removePookie($user);
431
432		$event->addAttendee($user);
433		$this->manager->flush();
434
435		$dispatcher = $this->container->get('event_dispatcher');
436		$achievementCheck = new AchievementCheckEvent(Achievement::EVENT_ATTEND);
437		$dispatcher->dispatch('upont.achievement', $achievementCheck);
438
439		return $this->json(null, 204);
440		}
441		}
442
443		/**
444		* @ApiDoc(
445		* description="Retire la demande d'inscription",
446		* statusCodes={
447		* 204="Requête traitée avec succès mais pas d’information à renvoyer",
448		* 401="Une authentification est nécessaire pour effectuer cette action",
449		* 403="Pas les droits suffisants pour effectuer cette action",
450		* 404="Ressource non trouvée",
451		* 503="Service temporairement indisponible ou en maintenance",
452		* },
453		* section="Publications"
454		* )
455		* @Route("/events/{slug}/attend")
456		* @Method("DELETE")
457		*/
458	View Code Duplication	public function noAttendAction($slug)
459		{
460		$user = $this->user;
461		$event = $this->findBySlug($slug);
462
463		if (!$event->getAttendees()->contains($user)) {
464		throw new BadRequestHttpException('Vous ne participez pas à cet évènement');
465		} else {
466		$event->removeAttendee($user);
467		$this->manager->flush();
468
469		return $this->json(null, 204);
470		}
471		}
472
473		/**
474		* @ApiDoc(
475		* description="Ajoute un utilisateur qui ne vient pas à l'event",
476		* statusCodes={
477		* 200="Requête traitée avec succès mais pas d’information à renvoyer",
478		* 401="Une authentification est nécessaire pour effectuer cette action",
479		* 403="Pas les droits suffisants pour effectuer cette action",
480		* 404="Ressource non trouvée",
481		* 503="Service temporairement indisponible ou en maintenance",
482		* },
483		* section="Publications"
484		* )
485		* @Route("/events/{slug}/decline")
486		* @Method("POST")
487		*/
488		public function addPookieAction($slug)
489		{
490		$user = $this->user;
491		$event = $this->findBySlug($slug);
492
493		if ($event->getPookies()->contains($user)) {
494		throw new BadRequestHttpException('Vous ne participez déjà pas à cet évènement');
495		} else {
496		// On ne fait plus participer l'utilisateur s'il participait auparavent
497		if ($event->getAttendees()->contains($user))
498		$event->removeAttendee($user);
499
500		$event->addPookie($user);
501		$this->manager->flush();
502
503		return $this->json(null, 204);
504		}
505		}
506
507		/**
508		* @ApiDoc(
509		* description="Retire la demande de désinscription",
510		* statusCodes={
511		* 200="Requête traitée avec succès mais pas d’information à renvoyer",
512		* 401="Une authentification est nécessaire pour effectuer cette action",
513		* 403="Pas les droits suffisants pour effectuer cette action",
514		* 404="Ressource non trouvée",
515		* 503="Service temporairement indisponible ou en maintenance",
516		* },
517		* section="Publications"
518		* )
519		* @Route("/events/{slug}/decline")
520		* @Method("DELETE")
521		*/
522	View Code Duplication	public function removePookieAction($slug)
523		{
524		$user = $this->user;
525		$event = $this->findBySlug($slug);
526
527		if (!$event->getPookies()->contains($user)) {
528		throw new BadRequestHttpException('Vous ne vous êtes pas désinscrit de cet évènement');
529		} else {
530		$event->removePookie($user);
531		$this->manager->flush();
532
533		return $this->json(null, 204);
534		}
535		}
536
537		/**
538		* @ApiDoc(
539		* description="Retourne la liste des participants à l'événement",
540		* statusCodes={
541		* 200="Requête traitée avec succès",
542		* 401="Une authentification est nécessaire pour effectuer cette action",
543		* 403="Pas les droits suffisants pour effectuer cette action",
544		* 404="Ressource non trouvée",
545		* 503="Service temporairement indisponible ou en maintenance",
546		* },
547		* section="Publications"
548		* )
549		* @Route("/events/{slug}/attendees")
550		* @Method("GET")
551		*/
552		public function getAttendeesAction($slug)
553		{
554		return $this->json($this->findBySlug($slug)->getAttendees());
555		}
556
557		/**
558		* @ApiDoc(
559		* description="Retourne la liste des non-participants à l'événement",
560		* statusCodes={
561		* 200="Requête traitée avec succès",
562		* 401="Une authentification est nécessaire pour effectuer cette action",
563		* 403="Pas les droits suffisants pour effectuer cette action",
564		* 404="Ressource non trouvée",
565		* 503="Service temporairement indisponible ou en maintenance",
566		* },
567		* section="Publications"
568		* )
569		* @Route("/events/{slug}/pookies")
570		* @Method("GET")
571		*/
572		public function getPookiesAction($slug)
573		{
574		return $this->json($this->findBySlug($slug)->getPookies());
575		}
576		}
577

KIClubinfo / upont

EventsController::deleteEventUserAction() A last analyzed 2018-09-27 16:55 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

EventsController::deleteEventUserAction() A
last analyzed 2018-09-27 16:55 UTC