CourseVoter::voteOnAttribute() - Code Metrics - Inspection of "Fix course listener, check roles when user connect..." - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 3be753...7af7b8 )

by Julito

created 2018-09-12 10:12 UTC

CourseVoter::voteOnAttribute() C

↳ Parent: CourseVoter

Complexity

Conditions	13
Paths	14

Size

Total Lines	76
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	13
eloc	33
nc	14
nop	3
dl	0
loc	76
rs	6.6166
c	0
b	0
f	0

How to fix Long Method Complexity

<?php
/* For licensing terms, see /license.txt */

namespace Chamilo\CoreBundle\Security\Authorization\Voter;

use Chamilo\CoreBundle\Entity\Course;
use Chamilo\CoreBundle\Entity\Manager\CourseManager;
use Chamilo\UserBundle\Entity\User;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
use Symfony\Component\Security\Core\Authorization\Voter\Voter;
use Symfony\Component\Security\Core\User\UserInterface;

/**
 * Class CourseVoter.
 *
 * @package Chamilo\CoreBundle\Security\Authorization\Voter
 */
class CourseVoter extends Voter
{
    public const VIEW = 'VIEW';
    public const EDIT = 'EDIT';
    public const DELETE = 'DELETE';

    private $entityManager;
    private $courseManager;
    private $authorizationChecker;
    private $container;

    /**
     * @param EntityManagerInterface        $entityManager
     * @param CourseManager                 $courseManager
     * @param AuthorizationCheckerInterface $authorizationChecker
     * @param ContainerInterface            $container
     */
    public function __construct(
        EntityManagerInterface $entityManager,
        CourseManager $courseManager,
        AuthorizationCheckerInterface $authorizationChecker,
        ContainerInterface $container
    ) {
        $this->entityManager = $entityManager;
        $this->courseManager = $courseManager;
        $this->authorizationChecker = $authorizationChecker;
        $this->container = $container;
    }

    /**
     * @return AuthorizationCheckerInterface
     */
    public function getAuthorizationChecker()
    {
        return $this->authorizationChecker;
    }

    /**
     * @return EntityManager
     */
    public function getEntityManager()
    {
        return $this->entityManager;
    }

    /**
     * @return CourseManager
     */
    public function getCourseManager()
    {
        return $this->courseManager;
    }

    /**
     * {@inheritdoc}
     */
    protected function supports($attribute, $subject): bool
    {
        $options = [
            self::VIEW,
            self::EDIT,
            self::DELETE,
        ];

        // if the attribute isn't one we support, return false
        if (!in_array($attribute, $options)) {
            return false;
        }

        // only vote on Post objects inside this voter
        if (!$subject instanceof Course) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    protected function voteOnAttribute($attribute, $course, TokenInterface $token): bool
    {
        /** @var User $user */
        $user = $token->getUser();
        // Anons can enter a course depending of the course visibility
        /*if (!$user instanceof UserInterface) {
            return false;
        }*/

        $authChecker = $this->getAuthorizationChecker();

        // Admins have access to everything
        if ($authChecker->isGranted('ROLE_ADMIN')) {
            return true;
        }

        // Course is active?
        /** @var Course $course */
        switch ($attribute) {
            case self::VIEW:
                // Course is hidden then is not visible for nobody expect admins.
                if ($course->getVisibility() == Course::HIDDEN) {
                    return false;
                }

                // "Open to the world" no need to check if user is registered or if user exists.
                // Course::OPEN_WORLD
                if ($course->isPublic()) {
                    return true;
                }

                // User should be instance of UserInterface.
                if (!$user instanceof UserInterface) {
                    return false;
                }

                // If user is logged in and is open platform, allow access.
                if ($course->getVisibility() == Course::OPEN_PLATFORM) {
                    $user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT);

                    if ($course->hasTeacher($user)) {
                        $user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
                    }

                    $token->setUser($user);

                    return true;
                }

                // Course::REGISTERED
                // User must be subscribed in the course no matter if is teacher/student
                if ($course->hasUser($user)) {
                    $user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT);

                    if ($course->hasTeacher($user)) {
                        $user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
                    }

                    $token->setUser($user);

                    return true;
                }
                break;
            case self::EDIT:
            case self::DELETE:
                // Only teacher can edit/delete stuff
                if ($course->hasTeacher($user)) {
                    $user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
                    $token->setUser($user);

                    return true;
                }
                break;
        }

        return false;
    }
}


1			<?php
2			/* For licensing terms, see /license.txt */
3
4			namespace Chamilo\CoreBundle\Security\Authorization\Voter;
5
6			use Chamilo\CoreBundle\Entity\Course;
7			use Chamilo\CoreBundle\Entity\Manager\CourseManager;
8			use Chamilo\UserBundle\Entity\User;
9			use Doctrine\ORM\EntityManager;
10			use Doctrine\ORM\EntityManagerInterface;
11			use Symfony\Component\DependencyInjection\ContainerInterface;
12			use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
13			use Symfony\Component\Security\Core\Authorization\AuthorizationCheckerInterface;
14			use Symfony\Component\Security\Core\Authorization\Voter\Voter;
15			use Symfony\Component\Security\Core\User\UserInterface;
16
17			/**
18			* Class CourseVoter.
19			*
20			* @package Chamilo\CoreBundle\Security\Authorization\Voter
21			*/
22			class CourseVoter extends Voter
23			{
24			public const VIEW = 'VIEW';
25			public const EDIT = 'EDIT';
26			public const DELETE = 'DELETE';
27
28			private $entityManager;
29			private $courseManager;
30			private $authorizationChecker;
31			private $container;
32
33			/**
34			* @param EntityManagerInterface $entityManager
35			* @param CourseManager $courseManager
36			* @param AuthorizationCheckerInterface $authorizationChecker
37			* @param ContainerInterface $container
38			*/
39			public function __construct(
40			EntityManagerInterface $entityManager,
41			CourseManager $courseManager,
42			AuthorizationCheckerInterface $authorizationChecker,
43			ContainerInterface $container
44			) {
45			$this->entityManager = $entityManager;
46			$this->courseManager = $courseManager;
47			$this->authorizationChecker = $authorizationChecker;
48			$this->container = $container;
49			}
50
51			/**
52			* @return AuthorizationCheckerInterface
53			*/
54			public function getAuthorizationChecker()
55			{
56			return $this->authorizationChecker;
57			}
58
59			/**
60			* @return EntityManager
61			*/
62			public function getEntityManager()
63			{
64			return $this->entityManager;
65			}
66
67			/**
68			* @return CourseManager
69			*/
70			public function getCourseManager()
71			{
72			return $this->courseManager;
73			}
74
75			/**
76			* {@inheritdoc}
77			*/
78			protected function supports($attribute, $subject): bool
79			{
80			$options = [
81			self::VIEW,
82			self::EDIT,
83			self::DELETE,
84			];
85
86			// if the attribute isn't one we support, return false
87			if (!in_array($attribute, $options)) {
88			return false;
89			}
90
91			// only vote on Post objects inside this voter
92			if (!$subject instanceof Course) {
93			return false;
94			}
95
96			return true;
97			}
98
99			/**
100			* {@inheritdoc}
101			*/
102			protected function voteOnAttribute($attribute, $course, TokenInterface $token): bool
103			{
104			/** @var User $user */
105			$user = $token->getUser();
106			// Anons can enter a course depending of the course visibility
107			/*if (!$user instanceof UserInterface) {
108			return false;
109			}*/
110
111			$authChecker = $this->getAuthorizationChecker();
112
113			// Admins have access to everything
114			if ($authChecker->isGranted('ROLE_ADMIN')) {
115			return true;
116			}
117
118			// Course is active?
119			/** @var Course $course */
120			switch ($attribute) {
121			case self::VIEW:
122			// Course is hidden then is not visible for nobody expect admins.
123			if ($course->getVisibility() == Course::HIDDEN) {
124			return false;
125			}
126
127			// "Open to the world" no need to check if user is registered or if user exists.
128			// Course::OPEN_WORLD
129			if ($course->isPublic()) {
130			return true;
131			}
132
133			// User should be instance of UserInterface.
134			if (!$user instanceof UserInterface) {
135			return false;
136			}
137
138			// If user is logged in and is open platform, allow access.
139			if ($course->getVisibility() == Course::OPEN_PLATFORM) {
140			$user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT);
141
142			if ($course->hasTeacher($user)) {
143			$user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
144			}
145
146			$token->setUser($user);
147
148			return true;
149			}
150
151			// Course::REGISTERED
152			// User must be subscribed in the course no matter if is teacher/student
153			if ($course->hasUser($user)) {
154			$user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT);
155
156			if ($course->hasTeacher($user)) {
157			$user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
158			}
159
160			$token->setUser($user);
161
162			return true;
163			}
164			break;
165			case self::EDIT:
166			case self::DELETE:
167			// Only teacher can edit/delete stuff
168			if ($course->hasTeacher($user)) {
169			$user->addRole(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER);
170			$token->setUser($user);
171
172			return true;
173			}
174			break;
175			}
176
177			return false;
178			}
179			}
180

chamilo / chamilo-lms

Push — master ( 3be753...7af7b8 )

CourseVoter::voteOnAttribute() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like