ResourceControllerTrait::denyAccessUnlessValidResource() - Code Metrics - Inspection of "Update composer.json" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( b3073b...104510 )

by Julito
created 2021-02-24 09:59 UTC
denyAccessUnlessValidResource() A

↳ Parent: ResourceControllerTrait
Complexity

Conditions	3
Paths	3
Size

Total Lines	10
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	5
nc	3
nop	1
dl	0
loc	10
rs	10
c	0
b	0
f	0
<?php

/* For licensing terms, see /license.txt */

namespace Chamilo\CoreBundle\Traits;

use Chamilo\CoreBundle\Entity\AbstractResource;
use Chamilo\CoreBundle\Entity\ResourceInterface;
use Chamilo\CoreBundle\Entity\ResourceNode;
use Chamilo\CoreBundle\Entity\User;
use Chamilo\CoreBundle\Repository\ResourceFactory;
use Chamilo\CoreBundle\Repository\ResourceNodeRepository;
use Chamilo\CoreBundle\Repository\ResourceRepository;
use Doctrine\ORM\EntityNotFoundException;
use Psr\Container\ContainerInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Security\Core\Exception\AccessDeniedException;
use Symfony\Component\Security\Core\User\UserInterface;

trait ResourceControllerTrait
{
    /** @var ContainerInterface */
    protected $container;

    public function getRepositoryFromRequest(Request $request): ResourceRepository
    {
        $tool = $request->get('tool');
        $type = $request->get('type');

        return $this->getRepository($tool, $type);
    }

    public function getResourceNodeRepository(): ResourceNodeRepository
    {
        return $this->container->get(ResourceNodeRepository::class);
    }

    public function getResourceRepositoryFactory(): ResourceFactory
    {
        return $this->container->get(ResourceFactory::class);
    }

    public function getRepository($tool, $type): ResourceRepository
    {
        $name = $this->getResourceRepositoryFactory()->getRepositoryService($tool, $type);

        return $this->container->get($name);
    }

    public function denyAccessUnlessValidResource(AbstractResource $resource = null)
    {
        if (null === $resource) {
            throw new EntityNotFoundException($this->trans('Resource doesn\'t exists.'));
            throw new EntityNotFoundException($this->/** @scrutinizer ignore-call */ trans('Resource doesn\'t exists.'));
        }

        $resourceNode = $resource->getResourceNode();

        if (null === $resourceNode) {
            throw new EntityNotFoundException($this->trans('Resource doesn\'t have a node.'));
        }
    }

    public function getResourceParams(Request $request): array
    {
        $tool = $request->get('tool');
        $type = $request->get('type');
        $id = (int) $request->get('id');

        $courseId = null;
        $sessionId = null;

        if ($this->hasCourse()) {
        if ($this->/** @scrutinizer ignore-call */ hasCourse()) {
            $courseId = $this->getCourse()->getId();
            $courseId = $this->/** @scrutinizer ignore-call */ getCourse()->getId();
            $session = $this->getCourseSession();
            $session = $this->getCourseSession();
            $sessionId = $session ? $session->getId() : 0;
        }

        return [
            'id' => $id,
            'tool' => $tool,
            'type' => $type,
            'cid' => $courseId,
            'sid' => $sessionId,
        ];
    }

    protected function getParentResourceNode(Request $request): ResourceNode
    {
        $parentNodeId = $request->get('id');

        $parentResourceNode = null;
        if (empty($parentNodeId)) {
            if ($this->hasCourse()) {
                $parentResourceNode = $this->getCourse()->getResourceNode();
            } else {
                if ($this->container->get('security.authorization_checker')->isGranted('IS_AUTHENTICATED_REMEMBERED')) {
                    /** @var User $user */
                    $user = $this->getUser();
                    if ($user) {

                        $parentResourceNode = $user->getResourceNode();
                    }
                }
            }
        } else {
            $repo = $this->container->get('doctrine')->getRepository(ResourceNode::class);
            $parentResourceNode = $repo->find($parentNodeId);
        }

        if (null === $parentResourceNode) {
            throw new AccessDeniedException();
        }

        return $parentResourceNode;
    }

    protected function getUser(): ?UserInterface
    {
        /*if (!$this->container->has('security.token_storage')) {
            throw new \LogicException('The SecurityBundle is not registered in your application. Try running "composer require symfony/security-bundle".');
        }*/

        if (null === $token = $this->container->get('security.token_storage')->getToken()) {
            return null;
        }

        if (!\is_object($user = $token->getUser())) {
            // e.g. anonymous authentication
            return null;
        }

        return $user;
    }

    private function setBreadCrumb(Request $request, ResourceNode $resourceNode)
    {
        return false;
        /*$tool = $request->get('tool');
        $resourceNodeId = $request->get('id');
        $routeParams = $this->getResourceParams($request);
        $baseNodeId = $this->getCourse()->getResourceNode()->getId();

        if (!empty($resourceNodeId)) {
            $breadcrumb = $this->getBreadCrumb();
            $toolParams = $routeParams;
            $toolParams['id'] = null;

            // Root tool link
            $breadcrumb->addChild(
                $this->trans($tool),
                [
                    'uri' => $this->generateUrl('chamilo_core_resource_index', $toolParams),
                ]
            );

            $repo = $this->getRepositoryFromRequest($request);
            $settings = $repo->getResourceSettings();

            //$originalResource = $repo->findOneBy(['resourceNode' => $resourceNodeId]);
            if (null === $resourceNode) {
                return;
            }
            $parentList = $resourceNode->getPathForDisplayToArray($baseNodeId);*/
//            var_dump($originalParent->getPath(), $originalParent->getPathForDisplay());
//            $parentList = [];
            /*          while (null !== $parent) {
                          if ($type !== $parent->getResourceType()->getName()) {
                              break;
                          }
                          $parent = $parent->getParent();
                          if ($parent) {
                              $resource = $repo->findOneBy(['resourceNode' => $parent->getId()]);
                              if ($resource) {
                                  $parentList[] = $resource;
                              }
                          }
                      }
                      $parentList = array_reverse($parentList);
                      foreach ($parentList as $item) {
                          $params = $routeParams;
                          $params['id'] = $item->getResourceNode()->getId();
                          $breadcrumb->addChild(
                              $item->getResourceName(),
                              [
                                  'uri' => $this->generateUrl('chamilo_core_resource_list', $params),
                              ]
                          );
                      }*/

            /*foreach ($parentList as $id => $title) {
                $params = $routeParams;
                $params['id'] = $id;
                $breadcrumb->addChild(
                    $title,
                    [
                        'uri' => $this->generateUrl('chamilo_core_resource_list', $params),
                    ]
                );
            }

            $params = $routeParams;
            $params['id'] = $resourceNode->getId();
            if (false === $settings->isAllowNodeCreation() || $resourceNode->hasResourceFile()) {
                $breadcrumb->addChild($resourceNode->getTitle());
            } else {
                $breadcrumb->addChild(
                    $resourceNode->getTitle(),
                    [
                        'uri' => $this->generateUrl('chamilo_core_resource_list', $params),
                    ]
                );
            }
        }*/
    }
}

chamilo / chamilo-lms

Push — master ( b3073b...104510 )

denyAccessUnlessValidResource() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
