ResourceController::updateAction() - Code Metrics - Inspection of "WIP - Add new resources CRUD see #2326" - chamilo/chamilo-lms - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 698027...ac354c )

by Julito

created 2018-08-24 13:25 UTC

ResourceController::updateAction() C

↳ Parent: ResourceController

Complexity

Conditions	14
Paths	12

Size

Total Lines	89
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	14
eloc	50
nc	12
nop	1
dl	0
loc	89
rs	6.2666
c	0
b	0
f	0

How to fix Long Method Complexity

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

namespace Chamilo\CoreBundle\Controller;

use APY\DataGridBundle\Grid\Export\CSVExport;
use APY\DataGridBundle\Grid\Export\ExcelExport;
use APY\DataGridBundle\Grid\Grid;
use Chamilo\CoreBundle\Repository\ResourceRepository;
use Chamilo\CoreBundle\Entity\Resource\ResourceRights;
use Chamilo\CourseBundle\Controller\CourseControllerTrait;
use Chamilo\CourseBundle\Controller\CourseControllerInterface;
use Chamilo\CourseBundle\Entity\CDocument;
use Chamilo\CourseBundle\Repository\CDocumentRepository;
use APY\DataGridBundle\Grid\Action\MassAction;
use APY\DataGridBundle\Grid\Action\RowAction;
use Sylius\Bundle\ResourceBundle\Event\ResourceControllerEvent;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Sylius\Bundle\ResourceBundle\Controller\ResourceController as BaseResourceController;
use APY\DataGridBundle\Grid\Source\Entity;
use FOS\RestBundle\View\View;
use Sylius\Component\Resource\ResourceActions;
use Chamilo\CoreBundle\Security\Authorization\Voter\ResourceNodeVoter;
use Symfony\Component\HttpKernel\Exception\HttpException;
use Sylius\Component\Resource\Exception\UpdateHandlingException;

/**
 * Class ResourceController.
 *
 * @author Julio Montoya <[email protected]>.
 *
 * @package Chamilo\CoreBundle\Controller
 */
class ResourceController extends BaseResourceController implements CourseControllerInterface
{
    use CourseControllerTrait;

    /**
     * @param Request $request
     *
     * @return Response
     */
    public function indexAction(Request $request): Response
    {
        $source = new Entity('ChamiloCourseBundle:CDocument');

        /* @var Grid $grid */
        $grid = $this->get('grid');

        /*$tableAlias = $source->getTableAlias();
        $source->manipulateQuery(function (QueryBuilder $query) use ($tableAlias, $course) {
                $query->andWhere($tableAlias . '.cId = '.$course->getId());
                //$query->resetDQLPart('orderBy');
            }
        );*/

        /** @var CDocumentRepository $repository */
        $repository = $this->repository;
        $course = $this->getCourse();
        $tool = $repository->getTool('document');

        $parentId = $request->get('parent');
        $parent = null;
        if (!empty($parentId)) {
            $parent = $this->repository->find($parentId);
        }
        $resources = $repository->getResourceByCourse($course, $tool, $parent);

        $source->setData($resources);
        $grid->setSource($source);

        //$grid->hideFilters();
        $grid->setLimits(20);
        //$grid->isReadyForRedirect();
        //$grid->setMaxResults(1);
        //$grid->setLimits(2);
        /*$grid->getColumn('id')->manipulateRenderCell(
            function ($value, $row, $router) use ($course) {
                //$router = $this->get('router');
                return $router->generate(
                    'chamilo_notebook_show',
                    array('id' => $row->getField('id'), 'course' => $course)
                );
            }
        );*/

        $courseIdentifier = $course->getCode();

        if ($this->isGranted(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER)) {
            $deleteMassAction = new MassAction(
                'Delete',
                'chamilo.controller.notebook:deleteMassAction',
                true,
                ['course' => $courseIdentifier]
            );
            $grid->addMassAction($deleteMassAction);
        }

        $translation = $this->container->get('translator');

        $myRowAction = new RowAction(
            $translation->trans('View'),
            'app_document_show',
            false,
            '_self',
            ['class' => 'btn btn-secondary']
        );
        $myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
        $grid->addRowAction($myRowAction);

        if ($this->isGranted(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER)) {
            $myRowAction = new RowAction(
                $translation->trans('Edit'),
                'app_document_update',
                false,
                '_self',
                ['class' => 'btn btn-secondary']
            );
            $myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
            $grid->addRowAction($myRowAction);

            $myRowAction = new RowAction(
                $translation->trans('Delete'),
                'app_document_delete',
                false,
                '_self',
                ['class' => 'btn btn-danger', 'form_delete' => true]
            );
            $myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
            $grid->addRowAction($myRowAction);
        }

        $grid->addExport(new CSVExport($translation->trans('CSV Export'), 'export', ['course' => $courseIdentifier]));

        $grid->addExport(
            new ExcelExport(
                $translation->trans('Excel Export'),
                'export',
                ['course' => $courseIdentifier]
            )
        );

        return $grid->getGridResponse('ChamiloCoreBundle:Document:index.html.twig', ['parent_id' => $parentId]);
    }

    /**
     * @param Request $request
     * @param string  $fileType
     *
     * @return null|\Symfony\Component\HttpFoundation\RedirectResponse|Response
     */
    public function createResource(Request $request, $fileType = 'file')
    {
        $configuration = $this->requestConfigurationFactory->create($this->metadata, $request);

        $this->isGrantedOr403($configuration, ResourceActions::CREATE);
        /** @var CDocument $newResource */
        $newResource = $this->newResourceFactory->create($configuration, $this->factory);
        $form = $this->resourceFormFactory->create($configuration, $newResource);

        $course = $this->getCourse();
        $session = $this->getSession();
        $newResource->setCourse($course);
        $newResource->c_id = $course->getId();
        $newResource->setFiletype($fileType);
        $form->setData($newResource);

        $parentId = $request->get('parent');
        $parent = null;
        if (!empty($parentId)) {
            /** @var CDocument $parent */
            $parent = $this->repository->find($parentId);
        }

        if ($request->isMethod('POST') && $form->handleRequest($request)->isValid()) {
            /** @var CDocument $newResource */
            $newResource = $form->getData();
            $event = $this->eventDispatcher->dispatchPreEvent(ResourceActions::CREATE, $configuration, $newResource);

            if ($event->isStopped() && !$configuration->isHtmlRequest()) {
                throw new HttpException($event->getErrorCode(), $event->getMessage());
            }
            if ($event->isStopped()) {
                $this->flashHelper->addFlashFromEvent($configuration, $event);

                if ($event->hasResponse()) {
                    return $event->getResponse();
                }

                return $this->redirectHandler->redirectToIndex($configuration, $newResource);
            }

            if ($configuration->hasStateMachine()) {
                $this->stateMachine->apply($configuration, $newResource);
            }

            //$sharedType = $form->get('shared')->getData();
            $shareList = [];
            $sharedType = 'this_course';

            switch ($sharedType) {
                case 'this_course':
                    if (empty($course)) {
                        break;
                    }
                    // Default Chamilo behaviour:
                    // Teachers can edit and students can see
                    $shareList = [
                        [
                            'sharing' => 'course',
                            'mask' => ResourceNodeVoter::getReaderMask(),
                            'role' => ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT,
                            'search' => $course->getId(),
                        ],
                        [
                            'sharing' => 'course',
                            'mask' => ResourceNodeVoter::getEditorMask(),
                            'role' => ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER,
                            'search' => $course->getId(),
                        ],
                    ];
                    break;
                case 'shared':
                    $shareList = $form->get('rights')->getData();
                    break;
                case 'only_me':
                    $shareList = [
                        [
                            'sharing' => 'user',
                            'only_me' => true,
                        ],
                    ];
                    break;
            }

            /** @var ResourceRepository $repository */
            $repository = $this->repository;
            $resourceNode = $repository->addResourceNode($newResource, $this->getUser(), $parent);

            // Loops all sharing options
            foreach ($shareList as $share) {
                $idList = array();
                if (isset($share['search'])) {
                    $idList = explode(',', $share['search']);
                }

                $resourceRight = null;
                if (isset($share['mask'])) {
                    $resourceRight = new ResourceRights();
                    $resourceRight
                        ->setMask($share['mask'])
                        ->setRole($share['role'])
                    ;
                }

                // Build links
                switch ($share['sharing']) {
                    case 'everyone':
                        $repository->addResourceToEveryone(
                            $resourceNode,
                            $resourceRight
                        );
                        break;
                    case 'course':
                        $repository->addResourceToCourse(
                            $resourceNode,
                            $course,
                            $resourceRight
                        );
                        break;
                    case 'session':
                        $repository->addResourceToSession(
                            $resourceNode,
                            $course,
                            $session,
                            $resourceRight
                        );
                        break;
                    case 'user':
                        // Only for me
                        if (isset($share['only_me'])) {
                            error_log('only_me');
                            $repository->addResourceOnlyToMe($resourceNode);
                        } else {
                            error_log('others');
                            // To other users
                            $repository->addResourceToUserList($resourceNode, $idList);
                        }
                        break;
                    case 'group':
                        // @todo
                        break;
                }
            }

            $newResource
                ->setCourse($course)
                ->setFiletype($fileType)
                ->setSession($session)
                //->setTitle($title)
                //->setComment($comment)
                ->setReadonly(false)
                ->setResourceNode($resourceNode)
            ;

            $path = \URLify::filter($newResource->getTitle());

            switch ($fileType) {
                case 'folder':
                    $newResource
                        ->setPath($path)
                        ->setSize(0)
                    ;
                    break;
                case 'file':
                    $newResource
                        ->setPath($path)
                        ->setSize(0)
                    ;
                    break;
            }

            $this->repository->add($newResource);
            $postEvent = $this->eventDispatcher->dispatchPostEvent(ResourceActions::CREATE, $configuration, $newResource);

            $newResource->setId($newResource->getIid());
            $this->getDoctrine()->getManager()->persist($newResource);
            $this->getDoctrine()->getManager()->flush();

            if (!$configuration->isHtmlRequest()) {
                return $this->viewHandler->handle($configuration, View::create($newResource, Response::HTTP_CREATED));
            }

            $this->addFlash('success', 'saved');

            //$this->flashHelper->addSuccessFlash($configuration, ResourceActions::CREATE, $newResource);
            if ($postEvent->hasResponse()) {
                return $postEvent->getResponse();
            }

            return $this->redirectToRoute(
                'app_document_show',
                [
                    'id' => $newResource->getIid(),
                    'course' => $course->getCode(),
                    'parent_id' => $parentId,
                ]
            );
            //return $this->redirectHandler->redirectToResource($configuration, $newResource);
        }

        if (!$configuration->isHtmlRequest()) {
            return $this->viewHandler->handle($configuration, View::create($form, Response::HTTP_BAD_REQUEST));
        }

        $initializeEvent = $this->eventDispatcher->dispatchInitializeEvent(ResourceActions::CREATE, $configuration, $newResource);
        if ($initializeEvent->hasResponse()) {
            return $initializeEvent->getResponse();
        }

        $view = View::create()
            ->setData([
                'configuration' => $configuration,
                'metadata' => $this->metadata,
                'resource' => $newResource,
                $this->metadata->getName() => $newResource,
                'form' => $form->createView(),
                'parent_id' => $parentId,
                'file_type' => $fileType
            ])
            ->setTemplate($configuration->getTemplate(ResourceActions::CREATE . '.html'))
        ;

        return $this->viewHandler->handle($configuration, $view);
    }

    /**
     * @param Request $request
     *
     * @return Response
     */
    public function createAction(Request $request): Response
    {
        return $this->createResource($request, 'folder');

    }

    /**
     * @param Request $request
     *
     * @return Response
     */
    public function createDocumentAction(Request $request): Response
    {
        return $this->createResource($request, 'file');

    }

    /**
     * @param Request $request
     *
     * @return Response
     */
    public function showAction(Request $request): Response
    {
        $configuration = $this->requestConfigurationFactory->create($this->metadata, $request);
        $this->isGrantedOr403($configuration, ResourceActions::SHOW);

        /** @var CDocument $resource */
        $resource = $this->findOr404($configuration);
        $resourceNode = $resource->getResourceNode();

        $this->eventDispatcher->dispatch(ResourceActions::SHOW, $configuration, $resource);

        $this->denyAccessUnlessGranted(
            ResourceNodeVoter::VIEW,
            $resourceNode,
            'Unauthorised access to resource'
        );

        $view = View::create($resource);

        if ($configuration->isHtmlRequest()) {
            $view
                ->setTemplate($configuration->getTemplate(ResourceActions::SHOW . '.html'))
                ->setTemplateVar($this->metadata->getName())
                ->setData([
                    'configuration' => $configuration,
                    'metadata' => $this->metadata,
                    'resource' => $resource,
                    $this->metadata->getName() => $resource,
                ])
            ;
        }

        return $this->viewHandler->handle($configuration, $view);
    }

    /**
     * @param Request $request
     *
     * @return Response
     */
    public function updateAction(Request $request): Response
    {
        $configuration = $this->requestConfigurationFactory->create($this->metadata, $request);

        $this->isGrantedOr403($configuration, ResourceActions::UPDATE);
        /** @var CDocument $resource */
        $resource = $this->findOr404($configuration);
        $resourceNode = $resource->getResourceNode();

        $this->denyAccessUnlessGranted(
            ResourceNodeVoter::EDIT,
            $resourceNode,
            'Unauthorised access to resource'
        );

        $form = $this->resourceFormFactory->create($configuration, $resource);

        if (in_array($request->getMethod(), ['POST', 'PUT', 'PATCH'], true) && $form->handleRequest($request)->isValid()) {
            $resource = $form->getData();

            /** @var ResourceControllerEvent $event */
            $event = $this->eventDispatcher->dispatchPreEvent(ResourceActions::UPDATE, $configuration, $resource);

            if ($event->isStopped() && !$configuration->isHtmlRequest()) {
                throw new HttpException($event->getErrorCode(), $event->getMessage());
            }
            if ($event->isStopped()) {
                $this->flashHelper->addFlashFromEvent($configuration, $event);

                if ($event->hasResponse()) {
                    return $event->getResponse();
                }

                return $this->redirectHandler->redirectToResource($configuration, $resource);
            }

            try {
                $this->resourceUpdateHandler->handle($resource, $configuration, $this->manager);
            } catch (UpdateHandlingException $exception) {
                if (!$configuration->isHtmlRequest()) {
                    return $this->viewHandler->handle(
                        $configuration,
                        View::create($form, $exception->getApiResponseCode())
                    );
                }

                $this->flashHelper->addErrorFlash($configuration, $exception->getFlash());

                return $this->redirectHandler->redirectToReferer($configuration);
            }

            $postEvent = $this->eventDispatcher->dispatchPostEvent(ResourceActions::UPDATE, $configuration, $resource);

            if (!$configuration->isHtmlRequest()) {
                $view = $configuration->getParameters()->get('return_content', false) ? View::create($resource, Response::HTTP_OK) : View::create(null, Response::HTTP_NO_CONTENT);

                return $this->viewHandler->handle($configuration, $view);
            }

            $this->flashHelper->addSuccessFlash($configuration, ResourceActions::UPDATE, $resource);

            if ($postEvent->hasResponse()) {
                return $postEvent->getResponse();
            }

            return $this->redirectHandler->redirectToResource($configuration, $resource);
        }

        if (!$configuration->isHtmlRequest()) {
            return $this->viewHandler->handle($configuration, View::create($form, Response::HTTP_BAD_REQUEST));
        }

        $initializeEvent = $this->eventDispatcher->dispatchInitializeEvent(ResourceActions::UPDATE, $configuration, $resource);
        if ($initializeEvent->hasResponse()) {
            return $initializeEvent->getResponse();
        }

        $view = View::create()
            ->setData([
                'configuration' => $configuration,
                'metadata' => $this->metadata,
                'resource' => $resource,
                $this->metadata->getName() => $resource,
                'form' => $form->createView(),
            ])
            ->setTemplate($configuration->getTemplate(ResourceActions::UPDATE . '.html'))
        ;

        return $this->viewHandler->handle($configuration, $view);
    }
}


1			<?php
2			/* For licensing terms, see /license.txt */
3
4			namespace Chamilo\CoreBundle\Controller;
5
6			use APY\DataGridBundle\Grid\Export\CSVExport;
7			use APY\DataGridBundle\Grid\Export\ExcelExport;
8			use APY\DataGridBundle\Grid\Grid;
9			use Chamilo\CoreBundle\Repository\ResourceRepository;
10			use Chamilo\CoreBundle\Entity\Resource\ResourceRights;
11			use Chamilo\CourseBundle\Controller\CourseControllerTrait;
12			use Chamilo\CourseBundle\Controller\CourseControllerInterface;
13			use Chamilo\CourseBundle\Entity\CDocument;
14			use Chamilo\CourseBundle\Repository\CDocumentRepository;
15			use APY\DataGridBundle\Grid\Action\MassAction;
16			use APY\DataGridBundle\Grid\Action\RowAction;
17			use Sylius\Bundle\ResourceBundle\Event\ResourceControllerEvent;
18			use Symfony\Component\HttpFoundation\Request;
19			use Symfony\Component\HttpFoundation\Response;
20			use Sylius\Bundle\ResourceBundle\Controller\ResourceController as BaseResourceController;
21			use APY\DataGridBundle\Grid\Source\Entity;
22			use FOS\RestBundle\View\View;
23			use Sylius\Component\Resource\ResourceActions;
24			use Chamilo\CoreBundle\Security\Authorization\Voter\ResourceNodeVoter;
25			use Symfony\Component\HttpKernel\Exception\HttpException;
26			use Sylius\Component\Resource\Exception\UpdateHandlingException;
27
28			/**
29			* Class ResourceController.
30			*
31			* @author Julio Montoya <[email protected]>.
32			*
33			* @package Chamilo\CoreBundle\Controller
34			*/
35			class ResourceController extends BaseResourceController implements CourseControllerInterface
36			{
37			use CourseControllerTrait;
38
39			/**
40			* @param Request $request
41			*
42			* @return Response
43			*/
44			public function indexAction(Request $request): Response
45			{
46			$source = new Entity('ChamiloCourseBundle:CDocument');
47
48			/* @var Grid $grid */
49			$grid = $this->get('grid');
50
51			/*$tableAlias = $source->getTableAlias();
52			$source->manipulateQuery(function (QueryBuilder $query) use ($tableAlias, $course) {
53			$query->andWhere($tableAlias . '.cId = '.$course->getId());
54			//$query->resetDQLPart('orderBy');
55			}
56			);*/
57
58			/** @var CDocumentRepository $repository */
59			$repository = $this->repository;
60			$course = $this->getCourse();
61			$tool = $repository->getTool('document');
62
63			$parentId = $request->get('parent');
64			$parent = null;
65			if (!empty($parentId)) {
66			$parent = $this->repository->find($parentId);
67			}
68			$resources = $repository->getResourceByCourse($course, $tool, $parent);
69
70			$source->setData($resources);
71			$grid->setSource($source);
72
73			//$grid->hideFilters();
74			$grid->setLimits(20);
75			//$grid->isReadyForRedirect();
76			//$grid->setMaxResults(1);
77			//$grid->setLimits(2);
78			/*$grid->getColumn('id')->manipulateRenderCell(
79			function ($value, $row, $router) use ($course) {
80			//$router = $this->get('router');
81			return $router->generate(
82			'chamilo_notebook_show',
83			array('id' => $row->getField('id'), 'course' => $course)
84			);
85			}
86			);*/
87
88			$courseIdentifier = $course->getCode();
89
90			if ($this->isGranted(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER)) {
91			$deleteMassAction = new MassAction(
92			'Delete',
93			'chamilo.controller.notebook:deleteMassAction',
94			true,
95			['course' => $courseIdentifier]
96			);
97			$grid->addMassAction($deleteMassAction);
98			}
99
100			$translation = $this->container->get('translator');
101
102			$myRowAction = new RowAction(
103			$translation->trans('View'),
104			'app_document_show',
105			false,
106			'_self',
107			['class' => 'btn btn-secondary']
108			);
109			$myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
110			$grid->addRowAction($myRowAction);
111
112			if ($this->isGranted(ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER)) {
113			$myRowAction = new RowAction(
114			$translation->trans('Edit'),
115			'app_document_update',
116			false,
117			'_self',
118			['class' => 'btn btn-secondary']
119			);
120			$myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
121			$grid->addRowAction($myRowAction);
122
123			$myRowAction = new RowAction(
124			$translation->trans('Delete'),
125			'app_document_delete',
126			false,
127			'_self',
128			['class' => 'btn btn-danger', 'form_delete' => true]
129			);
130			$myRowAction->setRouteParameters(['course' => $courseIdentifier, 'id']);
131			$grid->addRowAction($myRowAction);
132			}
133
134			$grid->addExport(new CSVExport($translation->trans('CSV Export'), 'export', ['course' => $courseIdentifier]));
135
136			$grid->addExport(
137			new ExcelExport(
138			$translation->trans('Excel Export'),
139			'export',
140			['course' => $courseIdentifier]
141			)
142			);
143
144			return $grid->getGridResponse('ChamiloCoreBundle:Document:index.html.twig', ['parent_id' => $parentId]);
145			}
146
147			/**
148			* @param Request $request
149			* @param string $fileType
150			*
151			* @return null\|\Symfony\Component\HttpFoundation\RedirectResponse\|Response
152			*/
153			public function createResource(Request $request, $fileType = 'file')
154			{
155			$configuration = $this->requestConfigurationFactory->create($this->metadata, $request);
156
157			$this->isGrantedOr403($configuration, ResourceActions::CREATE);
158			/** @var CDocument $newResource */
159			$newResource = $this->newResourceFactory->create($configuration, $this->factory);
160			$form = $this->resourceFormFactory->create($configuration, $newResource);
161
162			$course = $this->getCourse();
163			$session = $this->getSession();
164			$newResource->setCourse($course);
165			$newResource->c_id = $course->getId();
166			$newResource->setFiletype($fileType);
167			$form->setData($newResource);
168
169			$parentId = $request->get('parent');
170			$parent = null;
171			if (!empty($parentId)) {
172			/** @var CDocument $parent */
173			$parent = $this->repository->find($parentId);
174			}
175
176			if ($request->isMethod('POST') && $form->handleRequest($request)->isValid()) {
177			/** @var CDocument $newResource */
178			$newResource = $form->getData();
179			$event = $this->eventDispatcher->dispatchPreEvent(ResourceActions::CREATE, $configuration, $newResource);
180
181			if ($event->isStopped() && !$configuration->isHtmlRequest()) {
182			throw new HttpException($event->getErrorCode(), $event->getMessage());
183			}
184			if ($event->isStopped()) {
185			$this->flashHelper->addFlashFromEvent($configuration, $event);
186
187			if ($event->hasResponse()) {
188			return $event->getResponse();
189			}
190
191			return $this->redirectHandler->redirectToIndex($configuration, $newResource);
192			}
193
194			if ($configuration->hasStateMachine()) {
195			$this->stateMachine->apply($configuration, $newResource);
196			}
197
198			//$sharedType = $form->get('shared')->getData();
199			$shareList = [];
200			$sharedType = 'this_course';
201
202			switch ($sharedType) {
203			case 'this_course':
204			if (empty($course)) {
205			break;
206			}
207			// Default Chamilo behaviour:
208			// Teachers can edit and students can see
209			$shareList = [
210			[
211			'sharing' => 'course',
212			'mask' => ResourceNodeVoter::getReaderMask(),
213			'role' => ResourceNodeVoter::ROLE_CURRENT_COURSE_STUDENT,
214			'search' => $course->getId(),
215			],
216			[
217			'sharing' => 'course',
218			'mask' => ResourceNodeVoter::getEditorMask(),
219			'role' => ResourceNodeVoter::ROLE_CURRENT_COURSE_TEACHER,
220			'search' => $course->getId(),
221			],
222			];
223			break;
224			case 'shared':
225			$shareList = $form->get('rights')->getData();
226			break;
227			case 'only_me':
228			$shareList = [
229			[
230			'sharing' => 'user',
231			'only_me' => true,
232			],
233			];
234			break;
235			}
236
237			/** @var ResourceRepository $repository */
238			$repository = $this->repository;
239			$resourceNode = $repository->addResourceNode($newResource, $this->getUser(), $parent);
240
241			// Loops all sharing options
242			foreach ($shareList as $share) {
243			$idList = array();
244			if (isset($share['search'])) {
245			$idList = explode(',', $share['search']);
246			}
247
248			$resourceRight = null;
249			if (isset($share['mask'])) {
250			$resourceRight = new ResourceRights();
251			$resourceRight
252			->setMask($share['mask'])
253			->setRole($share['role'])
254			;
255			}
256
257			// Build links
258			switch ($share['sharing']) {
259			case 'everyone':
260			$repository->addResourceToEveryone(
261			$resourceNode,
262			$resourceRight
263			);
264			break;
265			case 'course':
266			$repository->addResourceToCourse(
267			$resourceNode,
268			$course,
269			$resourceRight
270			);
271			break;
272			case 'session':
273			$repository->addResourceToSession(
274			$resourceNode,
275			$course,
276			$session,
277			$resourceRight
278			);
279			break;
280			case 'user':
281			// Only for me
282			if (isset($share['only_me'])) {
283			error_log('only_me');
284			$repository->addResourceOnlyToMe($resourceNode);
285			} else {
286			error_log('others');
287			// To other users
288			$repository->addResourceToUserList($resourceNode, $idList);
289			}
290			break;
291			case 'group':
292			// @todo
293			break;
294			}
295			}
296
297			$newResource
298			->setCourse($course)
299			->setFiletype($fileType)
300			->setSession($session)
301			//->setTitle($title)
302			//->setComment($comment)
303			->setReadonly(false)
304			->setResourceNode($resourceNode)
305			;
306
307			$path = \URLify::filter($newResource->getTitle());
308
309			switch ($fileType) {
310			case 'folder':
311			$newResource
312			->setPath($path)
313			->setSize(0)
314			;
315			break;
316			case 'file':
317			$newResource
318			->setPath($path)
319			->setSize(0)
320			;
321			break;
322			}
323
324			$this->repository->add($newResource);
325			$postEvent = $this->eventDispatcher->dispatchPostEvent(ResourceActions::CREATE, $configuration, $newResource);
326
327			$newResource->setId($newResource->getIid());
328			$this->getDoctrine()->getManager()->persist($newResource);
329			$this->getDoctrine()->getManager()->flush();
330
331			if (!$configuration->isHtmlRequest()) {
332			return $this->viewHandler->handle($configuration, View::create($newResource, Response::HTTP_CREATED));
333			}
334
335			$this->addFlash('success', 'saved');
336
337			//$this->flashHelper->addSuccessFlash($configuration, ResourceActions::CREATE, $newResource);
338			if ($postEvent->hasResponse()) {
339			return $postEvent->getResponse();
340			}
341
342			return $this->redirectToRoute(
343			'app_document_show',
344			[
345			'id' => $newResource->getIid(),
346			'course' => $course->getCode(),
347			'parent_id' => $parentId,
348			]
349			);
350			//return $this->redirectHandler->redirectToResource($configuration, $newResource);
351			}
352
353			if (!$configuration->isHtmlRequest()) {
354			return $this->viewHandler->handle($configuration, View::create($form, Response::HTTP_BAD_REQUEST));
355			}
356
357			$initializeEvent = $this->eventDispatcher->dispatchInitializeEvent(ResourceActions::CREATE, $configuration, $newResource);
358			if ($initializeEvent->hasResponse()) {
359			return $initializeEvent->getResponse();
360			}
361
362			$view = View::create()
363			->setData([
364			'configuration' => $configuration,
365			'metadata' => $this->metadata,
366			'resource' => $newResource,
367			$this->metadata->getName() => $newResource,
368			'form' => $form->createView(),
369			'parent_id' => $parentId,
370			'file_type' => $fileType
371			])
372			->setTemplate($configuration->getTemplate(ResourceActions::CREATE . '.html'))
373			;
374
375			return $this->viewHandler->handle($configuration, $view);
376			}
377
378			/**
379			* @param Request $request
380			*
381			* @return Response
382			*/
383			public function createAction(Request $request): Response
384			{
385			return $this->createResource($request, 'folder');
			0 ignored issues – show Bug Best Practice introduced 2018-08-24 13:37 UTC by Report Bug Copy Issue Report The expression `return $this->createResource($request, 'folder')` could return the type `null` which is incompatible with the type-hinted return `Symfony\Component\HttpFoundation\Response`. Consider adding an additional type-check to rule them out. Loading history...
386			}
387
388			/**
389			* @param Request $request
390			*
391			* @return Response
392			*/
393			public function createDocumentAction(Request $request): Response
394			{
395			return $this->createResource($request, 'file');
			0 ignored issues – show Bug Best Practice introduced 2018-08-24 13:37 UTC by Report Bug Copy Issue Report The expression `return $this->createResource($request, 'file')` could return the type `null` which is incompatible with the type-hinted return `Symfony\Component\HttpFoundation\Response`. Consider adding an additional type-check to rule them out. Loading history...
396			}
397
398			/**
399			* @param Request $request
400			*
401			* @return Response
402			*/
403			public function showAction(Request $request): Response
404			{
405			$configuration = $this->requestConfigurationFactory->create($this->metadata, $request);
406			$this->isGrantedOr403($configuration, ResourceActions::SHOW);
407
408			/** @var CDocument $resource */
409			$resource = $this->findOr404($configuration);
410			$resourceNode = $resource->getResourceNode();
411
412			$this->eventDispatcher->dispatch(ResourceActions::SHOW, $configuration, $resource);
413
414			$this->denyAccessUnlessGranted(
415			ResourceNodeVoter::VIEW,
416			$resourceNode,
417			'Unauthorised access to resource'
418			);
419
420			$view = View::create($resource);
421
422			if ($configuration->isHtmlRequest()) {
423			$view
424			->setTemplate($configuration->getTemplate(ResourceActions::SHOW . '.html'))
425			->setTemplateVar($this->metadata->getName())
426			->setData([
427			'configuration' => $configuration,
428			'metadata' => $this->metadata,
429			'resource' => $resource,
430			$this->metadata->getName() => $resource,
431			])
432			;
433			}
434
435			return $this->viewHandler->handle($configuration, $view);
436			}
437
438			/**
439			* @param Request $request
440			*
441			* @return Response
442			*/
443			public function updateAction(Request $request): Response
444			{
445			$configuration = $this->requestConfigurationFactory->create($this->metadata, $request);
446
447			$this->isGrantedOr403($configuration, ResourceActions::UPDATE);
448			/** @var CDocument $resource */
449			$resource = $this->findOr404($configuration);
450			$resourceNode = $resource->getResourceNode();
451
452			$this->denyAccessUnlessGranted(
453			ResourceNodeVoter::EDIT,
454			$resourceNode,
455			'Unauthorised access to resource'
456			);
457
458			$form = $this->resourceFormFactory->create($configuration, $resource);
459
460			if (in_array($request->getMethod(), ['POST', 'PUT', 'PATCH'], true) && $form->handleRequest($request)->isValid()) {
461			$resource = $form->getData();
462
463			/** @var ResourceControllerEvent $event */
464			$event = $this->eventDispatcher->dispatchPreEvent(ResourceActions::UPDATE, $configuration, $resource);
465
466			if ($event->isStopped() && !$configuration->isHtmlRequest()) {
467			throw new HttpException($event->getErrorCode(), $event->getMessage());
468			}
469			if ($event->isStopped()) {
470			$this->flashHelper->addFlashFromEvent($configuration, $event);
471
472			if ($event->hasResponse()) {
473			return $event->getResponse();
474			}
475
476			return $this->redirectHandler->redirectToResource($configuration, $resource);
477			}
478
479			try {
480			$this->resourceUpdateHandler->handle($resource, $configuration, $this->manager);
481			} catch (UpdateHandlingException $exception) {
482			if (!$configuration->isHtmlRequest()) {
483			return $this->viewHandler->handle(
484			$configuration,
485			View::create($form, $exception->getApiResponseCode())
486			);
487			}
488
489			$this->flashHelper->addErrorFlash($configuration, $exception->getFlash());
490
491			return $this->redirectHandler->redirectToReferer($configuration);
492			}
493
494			$postEvent = $this->eventDispatcher->dispatchPostEvent(ResourceActions::UPDATE, $configuration, $resource);
495
496			if (!$configuration->isHtmlRequest()) {
497			$view = $configuration->getParameters()->get('return_content', false) ? View::create($resource, Response::HTTP_OK) : View::create(null, Response::HTTP_NO_CONTENT);
498
499			return $this->viewHandler->handle($configuration, $view);
500			}
501
502			$this->flashHelper->addSuccessFlash($configuration, ResourceActions::UPDATE, $resource);
503
504			if ($postEvent->hasResponse()) {
505			return $postEvent->getResponse();
506			}
507
508			return $this->redirectHandler->redirectToResource($configuration, $resource);
509			}
510
511			if (!$configuration->isHtmlRequest()) {
512			return $this->viewHandler->handle($configuration, View::create($form, Response::HTTP_BAD_REQUEST));
513			}
514
515			$initializeEvent = $this->eventDispatcher->dispatchInitializeEvent(ResourceActions::UPDATE, $configuration, $resource);
516			if ($initializeEvent->hasResponse()) {
517			return $initializeEvent->getResponse();
518			}
519
520			$view = View::create()
521			->setData([
522			'configuration' => $configuration,
523			'metadata' => $this->metadata,
524			'resource' => $resource,
525			$this->metadata->getName() => $resource,
526			'form' => $form->createView(),
527			])
528			->setTemplate($configuration->getTemplate(ResourceActions::UPDATE . '.html'))
529			;
530
531			return $this->viewHandler->handle($configuration, $view);
532			}
533			}
534

chamilo / chamilo-lms

Push — master ( 698027...ac354c )

ResourceController::updateAction() C

Complexity

Size

Duplication

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like