DefaultController::claimQuestAction() - Code Metrics - Inspection of "Merge pull request #152 from the-badger/cleanup-bu..." - the-badger/badger - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 32c2ac...90b7d3 )

by olivier

created 2017-03-19 15:02 UTC

DefaultController::claimQuestAction() B

↳ Parent: DefaultController

Complexity

Conditions	4
Paths	4

Size

Total Lines	29
Code Lines	16

Duplication

Lines	29
Ratio	100 %

Importance

Changes

Metric	Value
dl	29
loc	29
rs	8.5806
c	0
b	0
f	0
cc	4
eloc	16
nc	4
nop	1

<?php

namespace Badger\Bundle\GameBundle\Controller;

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()
    {
        $lastUnlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findByTags(
            $this->getUser()->getTags()->toArray()
        );

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

    /**
     * @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
        ]);

        $unlockedBadges = [];

        if ($user) {
            $unlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findBy([
                'user' => $user
            ]);

            foreach ($unlockedBadges as $key => $unlockedBadge) {
                if (!$this->get('security.authorization_checker')->isGranted('view', $unlockedBadge->getBadge())) {
                    unset($unlockedBadges[$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,
            'unlockedBadges' => $unlockedBadges
        ]);
    }

    /**
     * @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) {
            throw $this->createNotFoundException();
        }

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

        $user = $this->getUser();
        $usersCount = $this->getDoctrine()->getRepository('UserBundle:User')->countAll();
        $percentUnlock = 0;

        $unlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findBy([
            'badge' => $badge
        ]);

        $isUnlocked = array_filter($unlockedBadges, function ($unlock) use ($user) {
            return $unlock->getUser()->getId() === $user->getId();
        });

        $isClaimed = null !== $this->get('badger.game.repository.claimed_badge')->findOneBy([
            'badge' => $badge,
            'user' => $user
        ]);

        if ($unlockedBadges) {
            $percentUnlock = ceil(100 * count($unlockedBadges) / $usersCount);
        }

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

    /**
     * @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.claimed_badge')->findOneBy([
            'user' => $user,
            'badge' => $badge
        ]);

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

        $claimedBadgeFactory = $this->get('badger.game.claimed_badge.factory');
        $claimedBadge = $claimedBadgeFactory->create($user, $badge);

        $em = $this->getDoctrine()->getManager();
        $em->persist($claimedBadge);
        $em->flush();

        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.unlocked_badge')
            ->getUnlockedBadgeIdsByUser($user);

        $claimedBadgeIds = $this->get('badger.game.repository.claimed_badge')
            ->getBadgeIdsClaimedByUser($user);

        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()
    {
        $users = $this->getDoctrine()->getRepository('UserBundle:User')->getSortedUserByUnlockedBadges();

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

    /**
     * @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 Sensio\Bundle\FrameworkExtraBundle\Configuration\Route;
6		use Symfony\Bundle\FrameworkBundle\Controller\Controller;
7		use Symfony\Component\HttpFoundation\JsonResponse;
8		use Symfony\Component\HttpFoundation\Request;
9		use Symfony\Component\HttpFoundation\Response;
10
11		/**
12		* @license http://opensource.org/licenses/MIT The MIT License (MIT)
13		*/
14		class DefaultController extends Controller
15		{
16		/**
17		* @Route("/", name="homepage")
18		*/
19		public function indexAction()
20		{
21		$lastUnlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findByTags(
22		$this->getUser()->getTags()->toArray()
23		);
24
25		return $this->render('@Game/home.html.twig', [
26		'unlockedBadges' => $lastUnlockedBadges
27		]);
28		}
29
30		/**
31		* @Route("/users", name="users")
32		*/
33		public function usersAction()
34		{
35		$users = $this->getDoctrine()->getRepository('UserBundle:User')->findAll();
36
37		return $this->render('@Game/users.html.twig', [
38		'users' => $users
39		]);
40		}
41
42		/**
43		* @Route("/admin", name="admin")
44		*/
45		public function adminAction()
46		{
47		return $this->render('@Game/base-admin.html.twig');
48		}
49
50		/**
51		* @Route("/user/{username}", name="userprofile")
52		* @param string $username
53		*
54		* @return Response
55		*/
56		public function userProfileAction($username)
57		{
58		$user = $this->getDoctrine()->getRepository('UserBundle:User')->findOneBy([
59		'username' => $username
60		]);
61
62		$unlockedBadges = [];
63
64		if ($user) {
65		$unlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findBy([
66		'user' => $user
67		]);
68
69		foreach ($unlockedBadges as $key => $unlockedBadge) {
70		if (!$this->get('security.authorization_checker')->isGranted('view', $unlockedBadge->getBadge())) {
71		unset($unlockedBadges[$key]);
72		}
73		}
74		}
75
76		$displayedTags = $user->getTags();
77
78		foreach ($displayedTags as $key => $userTag) {
79		if (!$this->get('security.authorization_checker')->isGranted('view', $userTag)) {
80		unset($displayedTags[$key]);
81		}
82		}
83
84		return $this->render('@Game/user-profile.html.twig', [
85		'user' => $user,
86		'unlockedBadges' => $unlockedBadges
87		]);
88		}
89
90		/**
91		* @Route("/badge/{id}", name="viewbadge")
92		* @param $id
93		*
94		* @return Response
95		*/
96		public function badgeViewAction($id)
97		{
98		$badge = $this->get('badger.game.repository.badge')->findOneBy([
99		'id' => $id
100		]);
101
102		if (null === $badge) {
103		throw $this->createNotFoundException();
104		}
105
106		if (!$this->get('security.authorization_checker')->isGranted('view', $badge)) {
107		throw $this->createNotFoundException();
108		}
109
110		$user = $this->getUser();
111		$usersCount = $this->getDoctrine()->getRepository('UserBundle:User')->countAll();
112		$percentUnlock = 0;
113
114		$unlockedBadges = $this->get('badger.game.repository.unlocked_badge')->findBy([
115		'badge' => $badge
116		]);
117
118		$isUnlocked = array_filter($unlockedBadges, function ($unlock) use ($user) {
119		return $unlock->getUser()->getId() === $user->getId();
120		});
121
122		$isClaimed = null !== $this->get('badger.game.repository.claimed_badge')->findOneBy([
123		'badge' => $badge,
124		'user' => $user
125		]);
126
127		if ($unlockedBadges) {
128		$percentUnlock = ceil(100 * count($unlockedBadges) / $usersCount);
129		}
130
131		return $this->render('@Game/view-badge.html.twig', [
132		'badge' => $badge,
133		'unlockedBadges' => $unlockedBadges,
134		'isUnlocked' => $isUnlocked,
135		'isClaimed' => $isClaimed,
136		'percentUnlock' => $percentUnlock
137		]);
138		}
139
140		/**
141		* @Route("/claim/badge/{id}", name="claimbadge")
142		* @param int $id
143		*
144		* @return JsonResponse
145		*/
146		public function claimBadgeAction($id)
147		{
148		$user = $this->getUser();
149		$badge = $this->get('badger.game.repository.badge')->find($id);
150
151		if (null === $badge) {
152		return new JsonResponse('No badge with this id.', 400);
153		}
154
155		if (!$this->get('security.authorization_checker')->isGranted('view', $badge)) {
156		return new JsonResponse('No badge with this id.', 400);
157		}
158
159		$claimedBadge = $this->get('badger.game.repository.claimed_badge')->findOneBy([
160		'user' => $user,
161		'badge' => $badge
162		]);
163
164		if (null !== $claimedBadge) {
165		return new JsonResponse('This badge is already claimed.', 400);
166		}
167
168		$claimedBadgeFactory = $this->get('badger.game.claimed_badge.factory');
169		$claimedBadge = $claimedBadgeFactory->create($user, $badge);
170
171		$em = $this->getDoctrine()->getManager();
172		$em->persist($claimedBadge);
173		$em->flush();
174
175		return new JsonResponse();
176		}
177
178		/**
179		* @Route("/claim/step/{id}", name="claimstep")
180		* @param int $id
181		*
182		* @return JsonResponse
183		*/
184	View Code Duplication	public function claimStepAction($id)
		0 ignored issues – show Duplication introduced 2017-03-18 23:46 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...
185		{
186		$user = $this->getUser();
187		$step = $this->get('badger.game.repository.adventure_step')->find($id);
188
189		if (null === $step) {
190		return new JsonResponse('No step with this id.', 404);
191		}
192
193		if (!$this->get('security.authorization_checker')->isGranted('view', $step->getAdventure())) {
194		return new JsonResponse('No step with this id.', 404);
195		}
196
197		$stepCompletion = $this->get('badger.game.repository.adventure_step_completion')->findOneBy([
198		'user' => $user,
199		'step' => $step
200		]);
201
202		if (null !== $stepCompletion) {
203		return new JsonResponse('This step is already claimed.', 400);
204		}
205
206		$stepCompletionFactory = $this->get('badger.game.adventure_step_completion.factory');
207		$stepCompletion = $stepCompletionFactory->create($user, $step);
208
209		$this->get('badger.game.saver.adventure_step_completion')->save($stepCompletion);
210
211		return new JsonResponse();
212		}
213
214		/**
215		* @Route("/claim/quest/{id}", name="claimquest")
216		* @param int $id
217		*
218		* @return JsonResponse
219		*/
220	View Code Duplication	public function claimQuestAction($id)
		0 ignored issues – show Duplication introduced 2017-03-18 23:46 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...
221		{
222		$user = $this->getUser();
223		$quest = $this->get('badger.game.repository.quest')->find($id);
224
225		if (null === $quest) {
226		return new JsonResponse('No quest with this id.', 400);
227		}
228
229		if (!$this->get('security.authorization_checker')->isGranted('view', $quest)) {
230		return new JsonResponse('No quest with this id.', 400);
231		}
232
233		$questCompletion = $this->get('badger.game.repository.quest_completion')->findOneBy([
234		'user' => $user,
235		'quest' => $quest
236		]);
237
238		if (null !== $questCompletion) {
239		return new JsonResponse('This quest is already claimed.', 400);
240		}
241
242		$questCompletionFactory = $this->get('badger.game.quest_completion.factory');
243		$questCompletion = $questCompletionFactory->create($user, $quest);
244
245		$this->get('badger.game.saver.quest_completion')->save($questCompletion);
246
247		return new JsonResponse();
248		}
249
250		/**
251		* @Route("/badges", name="badges")
252		*
253		* @return Response
254		*/
255		public function badgeListAction()
256		{
257		$user = $this->getUser();
258		$userTags = $user->getTags();
259
260		$unlockedBadgeIds = $this->get('badger.game.repository.unlocked_badge')
261		->getUnlockedBadgeIdsByUser($user);
262
263		$claimedBadgeIds = $this->get('badger.game.repository.claimed_badge')
264		->getBadgeIdsClaimedByUser($user);
265
266		return $this->render('@Game/badges.html.twig', [
267		'tags' => $userTags,
268		'unlockedBadgesIds' => $unlockedBadgeIds,
269		'claimedBadgeIds' => $claimedBadgeIds
270		]);
271		}
272
273		/**
274		* @Route("/quests", name="quests")
275		* @param Request $request
276		*
277		* @return Response
278		*/
279		public function questListAction(Request $request)
280		{
281		$user = $this->getUser();
282		$status = $request->get('status', 'available');
283
284		$questRepository = $this->get('badger.game.repository.quest');
285		$completionRepository = $this->get('badger.game.repository.quest_completion');
286
287		$availableQuests = $questRepository->getAvailableQuestsForUser($user);
288		$questCompletions = $completionRepository->findBy(['user' => $user, 'pending' => 0]);
289		$claimedQuestIds = $this->get('badger.game.repository.quest_completion')
290		->getQuestIdsClaimedByUser($user);
291
292		return $this->render('@Game/quests.html.twig', [
293		'availableQuests' => $availableQuests,
294		'questCompletions' => $questCompletions,
295		'countAvailableQuests' => count($availableQuests),
296		'countCompletedQuests' => count($questCompletions),
297		'claimedQuestIds' => $claimedQuestIds,
298		'status' => $status
299		]);
300		}
301
302		/**
303		* @Route("/adventures", name="adventures")
304		*
305		* @return Response
306		*/
307		public function adventureListAction()
308		{
309		$user = $this->getUser();
310
311		$availableAdventures = $this->get('badger.game.repository.adventure')
312		->getAvailableAdventuresForUser($user);
313
314		$completedAdventures = $this->get('badger.game.repository.adventure')
315		->getCompletedAdventuresForUser($user);
316
317		$completedStepsByAdventure = $this->get('badger.game.repository.adventure_step_completion')
318		->userCompletedSteps($user);
319
320		foreach ($availableAdventures as $adventure) {
321		$adventure->completed = '0';
322
323		foreach ($completedStepsByAdventure as $data) {
324		if ($adventure->getId() === $data['adventure']->getId()) {
325		$adventure->completed = $data['completions'];
326		}
327		}
328		}
329
330		return $this->render('@Game/adventures.html.twig', [
331		'availableAdventures' => $availableAdventures,
332		'completedAdventures' => $completedAdventures
333		]);
334		}
335
336		/**
337		* @Route("/adventures/{id}", name="viewadventure")
338		*
339		* @param int $id
340		*
341		* @return Response
342		*/
343		public function adventureViewAction($id)
344		{
345		$user = $this->getUser();
346		$adventure = $this->get('badger.game.repository.adventure')
347		->find($id);
348
349		$completedSteps = $this->get('badger.game.repository.adventure_step_completion')
350		->userAdventureCompletedSteps($user, $adventure);
351
352		$claimedSteps = $this->get('badger.game.repository.adventure_step_completion')
353		->userAdventureClaimedSteps($user, $adventure);
354
355		$progression = count($completedSteps) * 100 / count($adventure->getSteps());
356
357		$totalStep = count($adventure->getSteps());
358		$isAdventureComplete = count($completedSteps) === $totalStep;
359
360		return $this->render('@Game/view-adventure.html.twig', [
361		'adventure' => $adventure,
362		'completedSteps' => $completedSteps,
363		'claimedSteps' => $claimedSteps,
364		'progression' => $progression,
365		'isAdventureComplete' => $isAdventureComplete
366		]);
367		}
368
369		/**
370		* @Route("/leaderboard", name="leaderboard")
371		*
372		* @return Response
373		*/
374		public function leaderboardAction()
375		{
376		$users = $this->getDoctrine()->getRepository('UserBundle:User')->getSortedUserByUnlockedBadges();
377
378		return $this->render('@Game/leaderboard.html.twig', [
379		'users' => $users
380		]);
381		}
382
383		/**
384		* @Route("/search/users", name="search_users")
385		* @param Request $request
386		*
387		* @return JsonResponse
388		*/
389		public function searchUsersAction(Request $request)
390		{
391		$token = $request->get('token');
392
393		if ('' === trim($token)) {
394		$users = $this->get('badger.user.repository.user')->findAll();
395		$results = [];
396
397		foreach ($users as $user) {
398		$results[] = [
399		'username' => $user->getUsername(),
400		'profilePicture' => $user->getProfilePicture()
401		];
402		}
403
404		return new JsonResponse($results);
405		}
406
407		$results = $this->get('badger.user.repository.elastic.user')->findUser($token);
408
409		return new JsonResponse($results);
410		}
411		}
412

the-badger / badger

Push — master ( 32c2ac...90b7d3 )

DefaultController::claimQuestAction() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like