DefaultController::adminAction() - Code Metrics - the-badger/badger - Measure and Improve Code Quality continuously with Scrutinizer

DefaultController::adminAction() A
last analyzed 2018-05-30 09:39 UTC

↳ Parent: DefaultController

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0

<?php

namespace Badger\Bundle\GameBundle\Controller;

use Badger\Bundle\GameBundle\Event\BadgeUnlockEvent;
use Badger\Bundle\GameBundle\GameEvents;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;
use Symfony\Component\HttpFoundation\JsonResponse;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

/**
 * @license http://opensource.org/licenses/MIT The MIT License (MIT)
 */
class DefaultController extends Controller
{
    /**
     * @Route("/", name="homepage")
     */
    public function indexAction()
    {
        $mostUnlockedBadges = [];
        $badgeChampions = [];
        $userBadgeCompletions = [];
        $userTags = $this->getUser()->getTags()->toArray();
        $date = new \DateTime();

        // Put default tag first
        usort($userTags, function ($a, $b) {
            if ($a->isDefault()) {
                return -1;
            } elseif ($b->isDefault()) {
                return 1;
            }

            return 0;
        });

        // Get most unlocked badges & champions per tag
        foreach ($userTags as $tag) {
            $currentUserIsChampion = false;

            $mostUnlockedBadges[$tag->getCode()] = $this->get('badger.game.repository.badge_completion')
                ->getMostUnlockedBadgesForDate($date, $tag, 5);

            $maxBadgeCompletions = $this->get('badger.game.repository.badge_completion')
                ->getTopNumberOfUnlocksForDate($date, $tag);

            $champions = $this->get('badger.user.repository.user')
                ->getMonthlyBadgeChampions($date, $tag, $maxBadgeCompletions);

            foreach ($champions as $champion) {
                if ($champion['user']->getId() === $this->getUser()->getId()) {
                    $currentUserIsChampion = true;
                }

                $badgeChampions[$tag->getCode()][$champion['badgeCompletions']][] = $champion['user'];
            }

            if (!$currentUserIsChampion) {
                $userCompletions = $this->get('badger.game.repository.badge_completion')
                    ->getTopNumberOfUnlocksForDate($date, $tag, $this->getUser());

                if (!empty($userCompletions)) {
                    $userBadgeCompletions[$tag->getCode()] = current($userCompletions)['nbCompletions'];
                }
            }
        }

        $newMembers = $this->get('badger.user.repository.user')->getNewUsersForMonth($date);

        return $this->render('@Game/home.html.twig', [
            'newMembers'           => $newMembers,
            'mostUnlockedBadges'   => $mostUnlockedBadges,
            'userTags'             => $userTags,
            'badgeChampions'       => $badgeChampions,
            'userBadgeCompletions' => $userBadgeCompletions
        ]);
    }

    /**
     * @Route("/users", name="users")
     */
    public function usersAction()
    {
        $users = $this->getDoctrine()->getRepository('UserBundle:User')->findAll();

        return $this->render('@Game/users.html.twig', [
            'users' => $users
        ]);
    }

    /**
     * @Route("/admin", name="admin")
     */
    public function adminAction()
    {
        return $this->render('@Game/base-admin.html.twig');
    }

    /**
     * @Route("/user/{username}", name="userprofile")
     * @param string $username
     *
     * @return Response
     */
    public function userProfileAction($username)
    {
        $user = $this->getDoctrine()->getRepository('UserBundle:User')->findOneBy([
            'username' => $username
        ]);

        $badgeCompletions = [];

        if ($user) {
            $badgeCompletions = $this->get('badger.game.repository.badge_completion')->findBy([
                'user' => $user, 'pending' => '0'
            ]);

            foreach ($badgeCompletions as $key => $badgeCompletion) {
                if (!$this->get('security.authorization_checker')->isGranted('view', $badgeCompletion->getBadge())) {
                    unset($badgeCompletions[$key]);
                }
            }
        }

        $displayedTags = $user->getTags();

        foreach ($displayedTags as $key => $userTag) {
            if (!$this->get('security.authorization_checker')->isGranted('view', $userTag)) {
                unset($displayedTags[$key]);
            }
        }

        return $this->render('@Game/user-profile.html.twig', [
            'user'             => $user,
            'badgeCompletions' => $badgeCompletions
        ]);
    }

    /**
     * @Route("/badge/{id}", name="viewbadge")
     * @param $id
     *
     * @return Response
     */
    public function badgeViewAction($id)
    {
        $badge = $this->get('badger.game.repository.badge')->findOneBy([
            'id' => $id
        ]);

        if (null === $badge || !$this->get('security.authorization_checker')->isGranted('view', $badge)) {
            throw $this->createNotFoundException();
        }

        $badgeCompletions = $this->get('badger.game.repository.badge_completion')->findBy([
            'badge' => $badge,
            'pending' => '0'
        ]);

        $isUnlocked = false;
        $isClaimed = false;

        $userCompletion = $this->get('badger.game.repository.badge_completion')->findOneBy([
            'user' => $this->getUser(),
            'badge' => $badge
        ]);

        if (null !== $userCompletion) {
            $isClaimed = $userCompletion->isPending();
            $isUnlocked = !$userCompletion->isPending();
        }

        return $this->render('@Game/view-badge.html.twig', [
            'badge'            => $badge,
            'badgeCompletions' => $badgeCompletions,
            'isUnlocked'       => $isUnlocked,
            'isClaimed'        => $isClaimed
        ]);
    }

    /**
     * @Route("/claim/badge/{id}", name="claimbadge")
     * @param int $id
     *
     * @return JsonResponse
     */
    public function claimBadgeAction($id)
    {
        $user = $this->getUser();
        $badge = $this->get('badger.game.repository.badge')->find($id);

        if (null === $badge) {
            return new JsonResponse('No badge with this id.', 400);
        }

        if (!$this->get('security.authorization_checker')->isGranted('view', $badge)) {
            return new JsonResponse('No badge with this id.', 400);
        }

        $claimedBadge = $this->get('badger.game.repository.badge_completion')->findOneBy([
            'user' => $user,
            'badge' => $badge
        ]);

        if (null !== $claimedBadge) {
            return new JsonResponse('This badge is already claimed.', 400);
        }

        $badgeCompletionFactory = $this->get('badger.game.badge_completion.factory');
        $badgeCompletion = $badgeCompletionFactory->create($user, $badge);

        $this->get('badger.game.saver.badge_completion')->save($badgeCompletion);

        $event = new BadgeUnlockEvent($badgeCompletion);
        $this->get('event_dispatcher')->dispatch(GameEvents::BADGE_HAS_BEEN_CLAIMED, $event);

        return new JsonResponse();
    }

    /**
     * @Route("/claim/step/{id}", name="claimstep")
     * @param int $id
     *
     * @return JsonResponse
     */
    public function claimStepAction($id)

    {
        $user = $this->getUser();
        $step = $this->get('badger.game.repository.adventure_step')->find($id);

        if (null === $step) {
            return new JsonResponse('No step with this id.', 404);
        }

        if (!$this->get('security.authorization_checker')->isGranted('view', $step->getAdventure())) {
            return new JsonResponse('No step with this id.', 404);
        }

        $stepCompletion = $this->get('badger.game.repository.adventure_step_completion')->findOneBy([
            'user' => $user,
            'step' => $step
        ]);

        if (null !== $stepCompletion) {
            return new JsonResponse('This step is already claimed.', 400);
        }

        $stepCompletionFactory = $this->get('badger.game.adventure_step_completion.factory');
        $stepCompletion = $stepCompletionFactory->create($user, $step);

        $this->get('badger.game.saver.adventure_step_completion')->save($stepCompletion);

        return new JsonResponse();
    }

    /**
     * @Route("/claim/quest/{id}", name="claimquest")
     * @param int $id
     *
     * @return JsonResponse
     */
    public function claimQuestAction($id)

    {
        $user = $this->getUser();
        $quest = $this->get('badger.game.repository.quest')->find($id);

        if (null === $quest) {
            return new JsonResponse('No quest with this id.', 400);
        }

        if (!$this->get('security.authorization_checker')->isGranted('view', $quest)) {
            return new JsonResponse('No quest with this id.', 400);
        }

        $questCompletion = $this->get('badger.game.repository.quest_completion')->findOneBy([
            'user' => $user,
            'quest' => $quest
        ]);

        if (null !== $questCompletion) {
            return new JsonResponse('This quest is already claimed.', 400);
        }

        $questCompletionFactory = $this->get('badger.game.quest_completion.factory');
        $questCompletion = $questCompletionFactory->create($user, $quest);

        $this->get('badger.game.saver.quest_completion')->save($questCompletion);

        return new JsonResponse();
    }

    /**
     * @Route("/badges", name="badges")
     *
     * @return Response
     */
    public function badgeListAction()
    {
        $user = $this->getUser();
        $userTags = $user->getTags();

        $unlockedBadgeIds = $this->get('badger.game.repository.badge_completion')
            ->getCompletionBadgesByUser($user, false);

        $claimedBadgeIds = $this->get('badger.game.repository.badge_completion')
            ->getCompletionBadgesByUser($user, true);

        return $this->render('@Game/badges.html.twig', [
            'tags' => $userTags,
            'unlockedBadgesIds' => $unlockedBadgeIds,
            'claimedBadgeIds' => $claimedBadgeIds
        ]);
    }

    /**
     * @Route("/quests", name="quests")
     * @param Request $request
     *
     * @return Response
     */
    public function questListAction(Request $request)
    {
        $user = $this->getUser();
        $status = $request->get('status', 'available');

        $questRepository = $this->get('badger.game.repository.quest');
        $completionRepository = $this->get('badger.game.repository.quest_completion');

        $availableQuests = $questRepository->getAvailableQuestsForUser($user);
        $questCompletions = $completionRepository->findBy(['user' => $user, 'pending' => 0]);
        $claimedQuestIds = $this->get('badger.game.repository.quest_completion')
            ->getQuestIdsClaimedByUser($user);

        return $this->render('@Game/quests.html.twig', [
            'availableQuests'      => $availableQuests,
            'questCompletions'     => $questCompletions,
            'countAvailableQuests' => count($availableQuests),
            'countCompletedQuests' => count($questCompletions),
            'claimedQuestIds'      => $claimedQuestIds,
            'status'               => $status
        ]);
    }

    /**
     * @Route("/adventures", name="adventures")
     *
     * @return Response
     */
    public function adventureListAction()
    {
        $user = $this->getUser();

        $availableAdventures = $this->get('badger.game.repository.adventure')
            ->getAvailableAdventuresForUser($user);

        $completedAdventures = $this->get('badger.game.repository.adventure')
            ->getCompletedAdventuresForUser($user);

        $completedStepsByAdventure = $this->get('badger.game.repository.adventure_step_completion')
            ->userCompletedSteps($user);

        foreach ($availableAdventures as $adventure) {
            $adventure->completed = '0';

            foreach ($completedStepsByAdventure as $data) {
                if ($adventure->getId() === $data['adventure']->getId()) {
                    $adventure->completed = $data['completions'];
                }
            }
        }

        return $this->render('@Game/adventures.html.twig', [
            'availableAdventures' => $availableAdventures,
            'completedAdventures' => $completedAdventures
        ]);
    }

    /**
     * @Route("/adventures/{id}", name="viewadventure")
     *
     * @param int $id
     *
     * @return Response
     */
    public function adventureViewAction($id)
    {
        $user = $this->getUser();
        $adventure = $this->get('badger.game.repository.adventure')
            ->find($id);

        $completedSteps = $this->get('badger.game.repository.adventure_step_completion')
            ->userAdventureCompletedSteps($user, $adventure);

        $claimedSteps = $this->get('badger.game.repository.adventure_step_completion')
            ->userAdventureClaimedSteps($user, $adventure);

        $progression = count($completedSteps) * 100 / count($adventure->getSteps());

        $totalStep = count($adventure->getSteps());
        $isAdventureComplete = count($completedSteps) === $totalStep;

        return $this->render('@Game/view-adventure.html.twig', [
            'adventure' => $adventure,
            'completedSteps' => $completedSteps,
            'claimedSteps' => $claimedSteps,
            'progression' => $progression,
            'isAdventureComplete' => $isAdventureComplete
        ]);
    }

    /**
     * @Route("/leaderboard", name="leaderboard")
     *
     * @return Response
     */
    public function leaderboardAction()
    {
        $user = $this->getUser();
        $tags = $user->getTags();
        $championsPerTag = [];

        foreach ($tags as $tag) {
            $championsPerTag[$tag->getCode()] = [];
            $topNumbers = $this->get('badger.game.repository.badge_completion')->getTopNumberOfUnlocks($tag);
            $champions = $this->get('badger.user.repository.user')->getBadgeChampions($tag, $topNumbers);

            foreach ($champions as $champion) {
                $championsPerTag[$tag->getCode()][$champion['badgeCompletions']][] = $champion['user'];
            }
        }

        return $this->render('@Game/leaderboard.html.twig', [
            'tags' => $tags,
            'championsPerTag' => $championsPerTag,
        ]);
    }

    /**
     * @Route("/search/users", name="search_users")
     * @param Request $request
     *
     * @return JsonResponse
     */
    public function searchUsersAction(Request $request)
    {
        $token = $request->get('token');

        if ('' === trim($token)) {
            $users = $this->get('badger.user.repository.user')->findAll();
            $results = [];

            foreach ($users as $user) {
                $results[] = [
                    'username' => $user->getUsername(),
                    'profilePicture' => $user->getProfilePicture()
                ];
            }

            return new JsonResponse($results);
        }

        $results = $this->get('badger.user.repository.elastic.user')->findUser($token);

        return new JsonResponse($results);
    }
}


1		<?php
2
3		namespace Badger\Bundle\GameBundle\Controller;
4
5		use Badger\Bundle\GameBundle\Event\BadgeUnlockEvent;
6		use Badger\Bundle\GameBundle\GameEvents;
7		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
8		use Symfony\Bundle\FrameworkBundle\Controller\Controller;
9		use Symfony\Component\HttpFoundation\JsonResponse;
10		use Symfony\Component\HttpFoundation\Request;
11		use Symfony\Component\HttpFoundation\Response;
12
13		/**
14		* @license http://opensource.org/licenses/MIT The MIT License (MIT)
15		*/
16		class DefaultController extends Controller
17		{
18		/**
19		* @Route("/", name="homepage")
20		*/
21		public function indexAction()
22		{
23		$mostUnlockedBadges = [];
24		$badgeChampions = [];
25		$userBadgeCompletions = [];
26		$userTags = $this->getUser()->getTags()->toArray();
27		$date = new \DateTime();
28
29		// Put default tag first
30		usort($userTags, function ($a, $b) {
31		if ($a->isDefault()) {
32		return -1;
33		} elseif ($b->isDefault()) {
34		return 1;
35		}
36
37		return 0;
38		});
39
40		// Get most unlocked badges & champions per tag
41		foreach ($userTags as $tag) {
42		$currentUserIsChampion = false;
43
44		$mostUnlockedBadges[$tag->getCode()] = $this->get('badger.game.repository.badge_completion')
45		->getMostUnlockedBadgesForDate($date, $tag, 5);
46
47		$maxBadgeCompletions = $this->get('badger.game.repository.badge_completion')
48		->getTopNumberOfUnlocksForDate($date, $tag);
49
50		$champions = $this->get('badger.user.repository.user')
51		->getMonthlyBadgeChampions($date, $tag, $maxBadgeCompletions);
52
53		foreach ($champions as $champion) {
54		if ($champion['user']->getId() === $this->getUser()->getId()) {
55		$currentUserIsChampion = true;
56		}
57
58		$badgeChampions[$tag->getCode()][$champion['badgeCompletions']][] = $champion['user'];
59		}
60
61		if (!$currentUserIsChampion) {
62		$userCompletions = $this->get('badger.game.repository.badge_completion')
63		->getTopNumberOfUnlocksForDate($date, $tag, $this->getUser());
64
65		if (!empty($userCompletions)) {
66		$userBadgeCompletions[$tag->getCode()] = current($userCompletions)['nbCompletions'];
67		}
68		}
69		}
70
71		$newMembers = $this->get('badger.user.repository.user')->getNewUsersForMonth($date);
72
73		return $this->render('@Game/home.html.twig', [
74		'newMembers' => $newMembers,
75		'mostUnlockedBadges' => $mostUnlockedBadges,
76		'userTags' => $userTags,
77		'badgeChampions' => $badgeChampions,
78		'userBadgeCompletions' => $userBadgeCompletions
79		]);
80		}
81
82		/**
83		* @Route("/users", name="users")
84		*/
85		public function usersAction()
86		{
87		$users = $this->getDoctrine()->getRepository('UserBundle:User')->findAll();
88
89		return $this->render('@Game/users.html.twig', [
90		'users' => $users
91		]);
92		}
93
94		/**
95		* @Route("/admin", name="admin")
96		*/
97		public function adminAction()
98		{
99		return $this->render('@Game/base-admin.html.twig');
100		}
101
102		/**
103		* @Route("/user/{username}", name="userprofile")
104		* @param string $username
105		*
106		* @return Response
107		*/
108		public function userProfileAction($username)
109		{
110		$user = $this->getDoctrine()->getRepository('UserBundle:User')->findOneBy([
111		'username' => $username
112		]);
113
114		$badgeCompletions = [];
115
116		if ($user) {
117		$badgeCompletions = $this->get('badger.game.repository.badge_completion')->findBy([
118		'user' => $user, 'pending' => '0'
119		]);
120
121		foreach ($badgeCompletions as $key => $badgeCompletion) {
122		if (!$this->get('security.authorization_checker')->isGranted('view', $badgeCompletion->getBadge())) {
123		unset($badgeCompletions[$key]);
124		}
125		}
126		}
127
128		$displayedTags = $user->getTags();
129
130		foreach ($displayedTags as $key => $userTag) {
131		if (!$this->get('security.authorization_checker')->isGranted('view', $userTag)) {
132		unset($displayedTags[$key]);
133		}
134		}
135
136		return $this->render('@Game/user-profile.html.twig', [
137		'user' => $user,
138		'badgeCompletions' => $badgeCompletions
139		]);
140		}
141
142		/**
143		* @Route("/badge/{id}", name="viewbadge")
144		* @param $id
145		*
146		* @return Response
147		*/
148		public function badgeViewAction($id)
149		{
150		$badge = $this->get('badger.game.repository.badge')->findOneBy([
151		'id' => $id
152		]);
153
154		if (null === $badge \|\| !$this->get('security.authorization_checker')->isGranted('view', $badge)) {
155		throw $this->createNotFoundException();
156		}
157
158		$badgeCompletions = $this->get('badger.game.repository.badge_completion')->findBy([
159		'badge' => $badge,
160		'pending' => '0'
161		]);
162
163		$isUnlocked = false;
164		$isClaimed = false;
165
166		$userCompletion = $this->get('badger.game.repository.badge_completion')->findOneBy([
167		'user' => $this->getUser(),
168		'badge' => $badge
169		]);
170
171		if (null !== $userCompletion) {
172		$isClaimed = $userCompletion->isPending();
173		$isUnlocked = !$userCompletion->isPending();
174		}
175
176		return $this->render('@Game/view-badge.html.twig', [
177		'badge' => $badge,
178		'badgeCompletions' => $badgeCompletions,
179		'isUnlocked' => $isUnlocked,
180		'isClaimed' => $isClaimed
181		]);
182		}
183
184		/**
185		* @Route("/claim/badge/{id}", name="claimbadge")
186		* @param int $id
187		*
188		* @return JsonResponse
189		*/
190		public function claimBadgeAction($id)
191		{
192		$user = $this->getUser();
193		$badge = $this->get('badger.game.repository.badge')->find($id);
194
195		if (null === $badge) {
196		return new JsonResponse('No badge with this id.', 400);
197		}
198
199		if (!$this->get('security.authorization_checker')->isGranted('view', $badge)) {
200		return new JsonResponse('No badge with this id.', 400);
201		}
202
203		$claimedBadge = $this->get('badger.game.repository.badge_completion')->findOneBy([
204		'user' => $user,
205		'badge' => $badge
206		]);
207
208		if (null !== $claimedBadge) {
209		return new JsonResponse('This badge is already claimed.', 400);
210		}
211
212		$badgeCompletionFactory = $this->get('badger.game.badge_completion.factory');
213		$badgeCompletion = $badgeCompletionFactory->create($user, $badge);
214
215		$this->get('badger.game.saver.badge_completion')->save($badgeCompletion);
216
217		$event = new BadgeUnlockEvent($badgeCompletion);
218		$this->get('event_dispatcher')->dispatch(GameEvents::BADGE_HAS_BEEN_CLAIMED, $event);
219
220		return new JsonResponse();
221		}
222
223		/**
224		* @Route("/claim/step/{id}", name="claimstep")
225		* @param int $id
226		*
227		* @return JsonResponse
228		*/
229	View Code Duplication	public function claimStepAction($id)
		0 ignored issues – show Duplication introduced 2017-11-09 17:01 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
230		{
231		$user = $this->getUser();
232		$step = $this->get('badger.game.repository.adventure_step')->find($id);
233
234		if (null === $step) {
235		return new JsonResponse('No step with this id.', 404);
236		}
237
238		if (!$this->get('security.authorization_checker')->isGranted('view', $step->getAdventure())) {
239		return new JsonResponse('No step with this id.', 404);
240		}
241
242		$stepCompletion = $this->get('badger.game.repository.adventure_step_completion')->findOneBy([
243		'user' => $user,
244		'step' => $step
245		]);
246
247		if (null !== $stepCompletion) {
248		return new JsonResponse('This step is already claimed.', 400);
249		}
250
251		$stepCompletionFactory = $this->get('badger.game.adventure_step_completion.factory');
252		$stepCompletion = $stepCompletionFactory->create($user, $step);
253
254		$this->get('badger.game.saver.adventure_step_completion')->save($stepCompletion);
255
256		return new JsonResponse();
257		}
258
259		/**
260		* @Route("/claim/quest/{id}", name="claimquest")
261		* @param int $id
262		*
263		* @return JsonResponse
264		*/
265	View Code Duplication	public function claimQuestAction($id)
		0 ignored issues – show Duplication introduced 2017-11-09 17:01 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
266		{
267		$user = $this->getUser();
268		$quest = $this->get('badger.game.repository.quest')->find($id);
269
270		if (null === $quest) {
271		return new JsonResponse('No quest with this id.', 400);
272		}
273
274		if (!$this->get('security.authorization_checker')->isGranted('view', $quest)) {
275		return new JsonResponse('No quest with this id.', 400);
276		}
277
278		$questCompletion = $this->get('badger.game.repository.quest_completion')->findOneBy([
279		'user' => $user,
280		'quest' => $quest
281		]);
282
283		if (null !== $questCompletion) {
284		return new JsonResponse('This quest is already claimed.', 400);
285		}
286
287		$questCompletionFactory = $this->get('badger.game.quest_completion.factory');
288		$questCompletion = $questCompletionFactory->create($user, $quest);
289
290		$this->get('badger.game.saver.quest_completion')->save($questCompletion);
291
292		return new JsonResponse();
293		}
294
295		/**
296		* @Route("/badges", name="badges")
297		*
298		* @return Response
299		*/
300		public function badgeListAction()
301		{
302		$user = $this->getUser();
303		$userTags = $user->getTags();
304
305		$unlockedBadgeIds = $this->get('badger.game.repository.badge_completion')
306		->getCompletionBadgesByUser($user, false);
307
308		$claimedBadgeIds = $this->get('badger.game.repository.badge_completion')
309		->getCompletionBadgesByUser($user, true);
310
311		return $this->render('@Game/badges.html.twig', [
312		'tags' => $userTags,
313		'unlockedBadgesIds' => $unlockedBadgeIds,
314		'claimedBadgeIds' => $claimedBadgeIds
315		]);
316		}
317
318		/**
319		* @Route("/quests", name="quests")
320		* @param Request $request
321		*
322		* @return Response
323		*/
324		public function questListAction(Request $request)
325		{
326		$user = $this->getUser();
327		$status = $request->get('status', 'available');
328
329		$questRepository = $this->get('badger.game.repository.quest');
330		$completionRepository = $this->get('badger.game.repository.quest_completion');
331
332		$availableQuests = $questRepository->getAvailableQuestsForUser($user);
333		$questCompletions = $completionRepository->findBy(['user' => $user, 'pending' => 0]);
334		$claimedQuestIds = $this->get('badger.game.repository.quest_completion')
335		->getQuestIdsClaimedByUser($user);
336
337		return $this->render('@Game/quests.html.twig', [
338		'availableQuests' => $availableQuests,
339		'questCompletions' => $questCompletions,
340		'countAvailableQuests' => count($availableQuests),
341		'countCompletedQuests' => count($questCompletions),
342		'claimedQuestIds' => $claimedQuestIds,
343		'status' => $status
344		]);
345		}
346
347		/**
348		* @Route("/adventures", name="adventures")
349		*
350		* @return Response
351		*/
352		public function adventureListAction()
353		{
354		$user = $this->getUser();
355
356		$availableAdventures = $this->get('badger.game.repository.adventure')
357		->getAvailableAdventuresForUser($user);
358
359		$completedAdventures = $this->get('badger.game.repository.adventure')
360		->getCompletedAdventuresForUser($user);
361
362		$completedStepsByAdventure = $this->get('badger.game.repository.adventure_step_completion')
363		->userCompletedSteps($user);
364
365		foreach ($availableAdventures as $adventure) {
366		$adventure->completed = '0';
367
368		foreach ($completedStepsByAdventure as $data) {
369		if ($adventure->getId() === $data['adventure']->getId()) {
370		$adventure->completed = $data['completions'];
371		}
372		}
373		}
374
375		return $this->render('@Game/adventures.html.twig', [
376		'availableAdventures' => $availableAdventures,
377		'completedAdventures' => $completedAdventures
378		]);
379		}
380
381		/**
382		* @Route("/adventures/{id}", name="viewadventure")
383		*
384		* @param int $id
385		*
386		* @return Response
387		*/
388		public function adventureViewAction($id)
389		{
390		$user = $this->getUser();
391		$adventure = $this->get('badger.game.repository.adventure')
392		->find($id);
393
394		$completedSteps = $this->get('badger.game.repository.adventure_step_completion')
395		->userAdventureCompletedSteps($user, $adventure);
396
397		$claimedSteps = $this->get('badger.game.repository.adventure_step_completion')
398		->userAdventureClaimedSteps($user, $adventure);
399
400		$progression = count($completedSteps) * 100 / count($adventure->getSteps());
401
402		$totalStep = count($adventure->getSteps());
403		$isAdventureComplete = count($completedSteps) === $totalStep;
404
405		return $this->render('@Game/view-adventure.html.twig', [
406		'adventure' => $adventure,
407		'completedSteps' => $completedSteps,
408		'claimedSteps' => $claimedSteps,
409		'progression' => $progression,
410		'isAdventureComplete' => $isAdventureComplete
411		]);
412		}
413
414		/**
415		* @Route("/leaderboard", name="leaderboard")
416		*
417		* @return Response
418		*/
419		public function leaderboardAction()
420		{
421		$user = $this->getUser();
422		$tags = $user->getTags();
423		$championsPerTag = [];
424
425		foreach ($tags as $tag) {
426		$championsPerTag[$tag->getCode()] = [];
427		$topNumbers = $this->get('badger.game.repository.badge_completion')->getTopNumberOfUnlocks($tag);
428		$champions = $this->get('badger.user.repository.user')->getBadgeChampions($tag, $topNumbers);
429
430		foreach ($champions as $champion) {
431		$championsPerTag[$tag->getCode()][$champion['badgeCompletions']][] = $champion['user'];
432		}
433		}
434
435		return $this->render('@Game/leaderboard.html.twig', [
436		'tags' => $tags,
437		'championsPerTag' => $championsPerTag,
438		]);
439		}
440
441		/**
442		* @Route("/search/users", name="search_users")
443		* @param Request $request
444		*
445		* @return JsonResponse
446		*/
447		public function searchUsersAction(Request $request)
448		{
449		$token = $request->get('token');
450
451		if ('' === trim($token)) {
452		$users = $this->get('badger.user.repository.user')->findAll();
453		$results = [];
454
455		foreach ($users as $user) {
456		$results[] = [
457		'username' => $user->getUsername(),
458		'profilePicture' => $user->getProfilePicture()
459		];
460		}
461
462		return new JsonResponse($results);
463		}
464
465		$results = $this->get('badger.user.repository.elastic.user')->findUser($token);
466
467		return new JsonResponse($results);
468		}
469		}
470

the-badger / badger

DefaultController::adminAction() A last analyzed 2018-05-30 09:39 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DefaultController::adminAction() A
last analyzed 2018-05-30 09:39 UTC