DefaultController::badgeViewAction() - Code Metrics - Inspection of "Get rid of Tag and Gate bundle #151" - the-badger/badger - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#152)

by olivier

created 2017-03-18 23:44 UTC

DefaultController::badgeViewAction() B

↳ Parent: DefaultController

Complexity

Conditions	4
Paths	4

Size

Total Lines	43
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Badger\Bundle\GameBundle\Controller;

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('@Gate/home.html.twig', [
            'unlockedBadges' => $lastUnlockedBadges
        ]);
    }

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

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

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

the-badger / badger

Pull Request — master (#152)

DefaultController::badgeViewAction() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like