RoleAction::update() - Code Metrics - platine-php/starter - Measure and Improve Code Quality continuously with Scrutinizer

RoleAction::update() B
last analyzed 2025-09-18 05:47 UTC

↳ Parent: RoleAction

Complexity

Conditions	9
Paths	20

Size

Total Lines	99
Code Lines	60

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	9
eloc	60
c	1
b	0
f	0
nc	20
nop	1
dl	0
loc	99
rs	7.3171

How to fix Long Method

<?php

declare(strict_types=1);

namespace Platine\App\Http\Action\Role;

use Exception;
use Platine\App\Helper\StatusList;
use Platine\App\Param\RoleParam;
use Platine\App\Validator\RoleValidator;
use Platine\Framework\Auth\Entity\Role;
use Platine\Framework\Auth\Repository\PermissionRepository;
use Platine\Framework\Auth\Repository\RoleRepository;
use Platine\Framework\Helper\Flash;
use Platine\Framework\Http\RequestData;
use Platine\Framework\Http\Response\RedirectResponse;
use Platine\Framework\Http\Response\TemplateResponse;
use Platine\Framework\Http\RouteHelper;
use Platine\Http\ResponseInterface;
use Platine\Http\ServerRequestInterface;
use Platine\Lang\Lang;
use Platine\Logger\LoggerInterface;
use Platine\Pagination\Pagination;
use Platine\Stdlib\Helper\Arr;
use Platine\Template\Template;

/**
* @class RoleAction
* @package Platine\App\Http\Action\Role
*/
class RoleAction
{
    /**
    * Create new instance
    * @param Lang $lang
    * @param Pagination $pagination
    * @param Template $template
    * @param Flash $flash
    * @param RouteHelper $routeHelper
    * @param LoggerInterface $logger
    * @param PermissionRepository $permissionRepository
    * @param RoleRepository $roleRepository
    * @param StatusList $statusList
    */
    public function __construct(
        protected Lang $lang,
        protected Pagination $pagination,
        protected Template $template,
        protected Flash $flash,
        protected RouteHelper $routeHelper,
        protected LoggerInterface $logger,
        protected PermissionRepository $permissionRepository,
        protected RoleRepository $roleRepository,
        protected StatusList $statusList
    ) {
    }

    /**
    * List all entities
    * @param ServerRequestInterface $request
    * @return ResponseInterface
    */
    public function index(ServerRequestInterface $request): ResponseInterface
    {
        $context = [];
        $param = new RequestData($request);
        $totalItems = $this->roleRepository->query()
                                               ->count('id');

        $currentPage = (int) $param->get('page', 1);

        $this->pagination->setTotalItems($totalItems)
                        ->setCurrentPage($currentPage);

        $limit = $this->pagination->getItemsPerPage();
        $offset = $this->pagination->getOffset();

        $results = $this->roleRepository->query()
                                            ->offset($offset)
                                            ->limit($limit)
                                            ->orderBy('name', 'ASC')
                                            ->all();

        $context['list'] = $results;
        $context['pagination'] = $this->pagination->render();


        return new TemplateResponse(
            $this->template,
            'role/list',
            $context
        );
    }

    /**
    * List entity detail
    * @param ServerRequestInterface $request
    * @return ResponseInterface
    */
    public function detail(ServerRequestInterface $request): ResponseInterface
    {
        $context = [];
        $id = (int) $request->getAttribute('id');

        /** @var Role|null $role */
        $role = $this->roleRepository->find($id);

        if ($role === null) {
            $this->flash->setError($this->lang->tr('This record doesn\'t exist'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        }
        $context['role'] = $role;
        $context['user_status'] = $this->statusList->getUserStatus();

        return new TemplateResponse(
            $this->template,
            'role/detail',
            $context
        );
    }

    /**
    * Create new entity
    * @param ServerRequestInterface $request
    * @return ResponseInterface
    */
    public function create(ServerRequestInterface $request): ResponseInterface
    {
        $context = [];
        $param = new RequestData($request);

        $formParam = new RoleParam($param->posts());
        $context['param'] = $formParam;

        $permissions = $this->permissionRepository->orderBy('code')
                                                  ->all();

        $context['permissions'] = $permissions;

        if ($request->getMethod() === 'GET') {
            return new TemplateResponse(
                $this->template,
                'role/create',
                $context
            );
        }

        $validator = new RoleValidator($formParam, $this->lang);
        if ($validator->validate() === false) {
            $context['errors'] = $validator->getErrors();

            return new TemplateResponse(
                $this->template,
                'role/create',
                $context
            );
        }

        $entityExist = $this->roleRepository->findBy([
                                               'name' => $formParam->getName(),
                                           ]);

        if ($entityExist !== null) {
            $this->flash->setError($this->lang->tr('This record already exist'));

            return new TemplateResponse(
                $this->template,
                'role/create',
                $context
            );
        }

        /** @var Role $role */
        $role = $this->roleRepository->create([
           'name' => $formParam->getName(),
        'description' => $formParam->getDescription(),
        ]);

        $permissionsId = $formParam->getPermissions();
        if (count($permissionsId) > 0) {
            $selectedPermissions = $this->permissionRepository->findAll(...$permissionsId);
            $role->setPermissions($selectedPermissions);
        }

        try {
            $this->roleRepository->save($role);

            $this->flash->setSuccess($this->lang->tr('Data successfully created'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        } catch (Exception $ex) {
            $this->logger->error('Error when saved the data {error}', ['error' => $ex->getMessage()]);

            $this->flash->setError($this->lang->tr('Data processing error'));

            return new TemplateResponse(
                $this->template,
                'role/create',
                $context
            );
        }
    }

    /**
    * Update existing entity
    * @param ServerRequestInterface $request
    * @return ResponseInterface
    */
    public function update(ServerRequestInterface $request): ResponseInterface
    {
        $context = [];
        $param = new RequestData($request);

        $id = (int) $request->getAttribute('id');

        /** @var Role|null $role */
        $role = $this->roleRepository->find($id);

        if ($role === null) {
            $this->flash->setError($this->lang->tr('This record doesn\'t exist'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        }
        $context['role'] = $role;
        $context['param'] = (new RoleParam())->fromEntity($role);

        $currentPermissionsId = Arr::getColumn($role->permissions, 'id');
        $context['param']->setPermissions($currentPermissionsId);

        $permissions = $this->permissionRepository->orderBy('code')
                                                  ->all();

        $context['permissions'] = $permissions;

        if ($request->getMethod() === 'GET') {
            return new TemplateResponse(
                $this->template,
                'role/update',
                $context
            );
        }
        $formParam = new RoleParam($param->posts());
        $context['param'] = $formParam;

        $validator = new RoleValidator($formParam, $this->lang);
        if ($validator->validate() === false) {
            $context['errors'] = $validator->getErrors();

            return new TemplateResponse(
                $this->template,
                'role/update',
                $context
            );
        }

        $entityExist = $this->roleRepository->findBy([
                                               'name' => $formParam->getName(),
                                           ]);

        if ($entityExist !== null && $entityExist->id !== $id) {
            $this->flash->setError($this->lang->tr('This record already exist'));

            return new TemplateResponse(
                $this->template,
                'role/update',
                $context
            );
        }

        $role->name = $formParam->getName();
        $role->description = $formParam->getDescription();

        $permissionsId = $formParam->getPermissions();

        //Delete Handle
        $permissionsIdToDelete = array_diff($currentPermissionsId, $permissionsId);
        if (count($permissionsIdToDelete) > 0) {
            $deletedPermissions = $this->permissionRepository->findAll(...$permissionsIdToDelete);
            $role->removePermissions($deletedPermissions);
        }

        //New Handle
        $permissionsIdToAdd = array_diff($permissionsId, $currentPermissionsId);
        if (count($permissionsIdToAdd) > 0) {
            $addedPermissions = $this->permissionRepository->findAll(...$permissionsIdToAdd);
            $role->setPermissions($addedPermissions);
        }

        try {
            $this->roleRepository->save($role);

            $this->flash->setSuccess($this->lang->tr('Data successfully updated'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_detail', ['id' => $id])
            );
        } catch (Exception $ex) {
            $this->logger->error('Error when saved the data {error}', ['error' => $ex->getMessage()]);

            $this->flash->setError($this->lang->tr('Data processing error'));

            return new TemplateResponse(
                $this->template,
                'role/update',
                $context
            );
        }
    }

    /**
    * Delete the entity
    * @param ServerRequestInterface $request
    * @return ResponseInterface
    */
    public function delete(ServerRequestInterface $request): ResponseInterface
    {
        $id = (int) $request->getAttribute('id');

        /** @var Role|null $role */
        $role = $this->roleRepository->find($id);

        if ($role === null) {
            $this->flash->setError($this->lang->tr('This record doesn\'t exist'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        }

        try {
            $this->roleRepository->delete($role);

            $this->flash->setSuccess($this->lang->tr('Data successfully deleted'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        } catch (Exception $ex) {
            $this->logger->error('Error when delete the data {error}', ['error' => $ex->getMessage()]);

            $this->flash->setError($this->lang->tr('Data processing error'));

            return new RedirectResponse(
                $this->routeHelper->generateUrl('role_list')
            );
        }
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Platine\App\Http\Action\Role;
6
7			use Exception;
8			use Platine\App\Helper\StatusList;
9			use Platine\App\Param\RoleParam;
10			use Platine\App\Validator\RoleValidator;
11			use Platine\Framework\Auth\Entity\Role;
12			use Platine\Framework\Auth\Repository\PermissionRepository;
13			use Platine\Framework\Auth\Repository\RoleRepository;
14			use Platine\Framework\Helper\Flash;
15			use Platine\Framework\Http\RequestData;
16			use Platine\Framework\Http\Response\RedirectResponse;
17			use Platine\Framework\Http\Response\TemplateResponse;
18			use Platine\Framework\Http\RouteHelper;
19			use Platine\Http\ResponseInterface;
20			use Platine\Http\ServerRequestInterface;
21			use Platine\Lang\Lang;
22			use Platine\Logger\LoggerInterface;
23			use Platine\Pagination\Pagination;
24			use Platine\Stdlib\Helper\Arr;
25			use Platine\Template\Template;
26
27			/**
28			* @class RoleAction
29			* @package Platine\App\Http\Action\Role
30			*/
31			class RoleAction
32			{
33			/**
34			* Create new instance
35			* @param Lang $lang
36			* @param Pagination $pagination
37			* @param Template $template
38			* @param Flash $flash
39			* @param RouteHelper $routeHelper
40			* @param LoggerInterface $logger
41			* @param PermissionRepository $permissionRepository
42			* @param RoleRepository $roleRepository
43			* @param StatusList $statusList
44			*/
45			public function __construct(
46			protected Lang $lang,
47			protected Pagination $pagination,
48			protected Template $template,
49			protected Flash $flash,
50			protected RouteHelper $routeHelper,
51			protected LoggerInterface $logger,
52			protected PermissionRepository $permissionRepository,
53			protected RoleRepository $roleRepository,
54			protected StatusList $statusList
55			) {
56			}
57
58			/**
59			* List all entities
60			* @param ServerRequestInterface $request
61			* @return ResponseInterface
62			*/
63			public function index(ServerRequestInterface $request): ResponseInterface
64			{
65			$context = [];
66			$param = new RequestData($request);
67			$totalItems = $this->roleRepository->query()
68			->count('id');
69
70			$currentPage = (int) $param->get('page', 1);
71
72			$this->pagination->setTotalItems($totalItems)
73			->setCurrentPage($currentPage);
74
75			$limit = $this->pagination->getItemsPerPage();
76			$offset = $this->pagination->getOffset();
77
78			$results = $this->roleRepository->query()
79			->offset($offset)
80			->limit($limit)
81			->orderBy('name', 'ASC')
82			->all();
83
84			$context['list'] = $results;
85			$context['pagination'] = $this->pagination->render();
86
87
88			return new TemplateResponse(
89			$this->template,
90			'role/list',
91			$context
92			);
93			}
94
95			/**
96			* List entity detail
97			* @param ServerRequestInterface $request
98			* @return ResponseInterface
99			*/
100			public function detail(ServerRequestInterface $request): ResponseInterface
101			{
102			$context = [];
103			$id = (int) $request->getAttribute('id');
104
105			/** @var Role\|null $role */
106			$role = $this->roleRepository->find($id);
107
108			if ($role === null) {
109			$this->flash->setError($this->lang->tr('This record doesn\'t exist'));
110
111			return new RedirectResponse(
112			$this->routeHelper->generateUrl('role_list')
113			);
114			}
115			$context['role'] = $role;
116			$context['user_status'] = $this->statusList->getUserStatus();
117
118			return new TemplateResponse(
119			$this->template,
120			'role/detail',
121			$context
122			);
123			}
124
125			/**
126			* Create new entity
127			* @param ServerRequestInterface $request
128			* @return ResponseInterface
129			*/
130			public function create(ServerRequestInterface $request): ResponseInterface
131			{
132			$context = [];
133			$param = new RequestData($request);
134
135			$formParam = new RoleParam($param->posts());
136			$context['param'] = $formParam;
137
138			$permissions = $this->permissionRepository->orderBy('code')
139			->all();
140
141			$context['permissions'] = $permissions;
142
143			if ($request->getMethod() === 'GET') {
144			return new TemplateResponse(
145			$this->template,
146			'role/create',
147			$context
148			);
149			}
150
151			$validator = new RoleValidator($formParam, $this->lang);
152			if ($validator->validate() === false) {
153			$context['errors'] = $validator->getErrors();
154
155			return new TemplateResponse(
156			$this->template,
157			'role/create',
158			$context
159			);
160			}
161
162			$entityExist = $this->roleRepository->findBy([
163			'name' => $formParam->getName(),
164			]);
165
166			if ($entityExist !== null) {
167			$this->flash->setError($this->lang->tr('This record already exist'));
168
169			return new TemplateResponse(
170			$this->template,
171			'role/create',
172			$context
173			);
174			}
175
176			/** @var Role $role */
177			$role = $this->roleRepository->create([
178			'name' => $formParam->getName(),
179			'description' => $formParam->getDescription(),
180			]);
181
182			$permissionsId = $formParam->getPermissions();
183			if (count($permissionsId) > 0) {
184			$selectedPermissions = $this->permissionRepository->findAll(...$permissionsId);
185			$role->setPermissions($selectedPermissions);
186			}
187
188			try {
189			$this->roleRepository->save($role);
190
191			$this->flash->setSuccess($this->lang->tr('Data successfully created'));
192
193			return new RedirectResponse(
194			$this->routeHelper->generateUrl('role_list')
195			);
196			} catch (Exception $ex) {
197			$this->logger->error('Error when saved the data {error}', ['error' => $ex->getMessage()]);
198
199			$this->flash->setError($this->lang->tr('Data processing error'));
200
201			return new TemplateResponse(
202			$this->template,
203			'role/create',
204			$context
205			);
206			}
207			}
208
209			/**
210			* Update existing entity
211			* @param ServerRequestInterface $request
212			* @return ResponseInterface
213			*/
214			public function update(ServerRequestInterface $request): ResponseInterface
215			{
216			$context = [];
217			$param = new RequestData($request);
218
219			$id = (int) $request->getAttribute('id');
220
221			/** @var Role\|null $role */
222			$role = $this->roleRepository->find($id);
223
224			if ($role === null) {
225			$this->flash->setError($this->lang->tr('This record doesn\'t exist'));
226
227			return new RedirectResponse(
228			$this->routeHelper->generateUrl('role_list')
229			);
230			}
231			$context['role'] = $role;
232			$context['param'] = (new RoleParam())->fromEntity($role);
233
234			$currentPermissionsId = Arr::getColumn($role->permissions, 'id');
235			$context['param']->setPermissions($currentPermissionsId);
236
237			$permissions = $this->permissionRepository->orderBy('code')
238			->all();
239
240			$context['permissions'] = $permissions;
241
242			if ($request->getMethod() === 'GET') {
243			return new TemplateResponse(
244			$this->template,
245			'role/update',
246			$context
247			);
248			}
249			$formParam = new RoleParam($param->posts());
250			$context['param'] = $formParam;
251
252			$validator = new RoleValidator($formParam, $this->lang);
253			if ($validator->validate() === false) {
254			$context['errors'] = $validator->getErrors();
255
256			return new TemplateResponse(
257			$this->template,
258			'role/update',
259			$context
260			);
261			}
262
263			$entityExist = $this->roleRepository->findBy([
264			'name' => $formParam->getName(),
265			]);
266
267			if ($entityExist !== null && $entityExist->id !== $id) {
268			$this->flash->setError($this->lang->tr('This record already exist'));
269
270			return new TemplateResponse(
271			$this->template,
272			'role/update',
273			$context
274			);
275			}
276
277			$role->name = $formParam->getName();
278			$role->description = $formParam->getDescription();
279
280			$permissionsId = $formParam->getPermissions();
281
282			//Delete Handle
283			$permissionsIdToDelete = array_diff($currentPermissionsId, $permissionsId);
284			if (count($permissionsIdToDelete) > 0) {
285			$deletedPermissions = $this->permissionRepository->findAll(...$permissionsIdToDelete);
286			$role->removePermissions($deletedPermissions);
287			}
288
289			//New Handle
290			$permissionsIdToAdd = array_diff($permissionsId, $currentPermissionsId);
291			if (count($permissionsIdToAdd) > 0) {
292			$addedPermissions = $this->permissionRepository->findAll(...$permissionsIdToAdd);
293			$role->setPermissions($addedPermissions);
294			}
295
296			try {
297			$this->roleRepository->save($role);
298
299			$this->flash->setSuccess($this->lang->tr('Data successfully updated'));
300
301			return new RedirectResponse(
302			$this->routeHelper->generateUrl('role_detail', ['id' => $id])
303			);
304			} catch (Exception $ex) {
305			$this->logger->error('Error when saved the data {error}', ['error' => $ex->getMessage()]);
306
307			$this->flash->setError($this->lang->tr('Data processing error'));
308
309			return new TemplateResponse(
310			$this->template,
311			'role/update',
312			$context
313			);
314			}
315			}
316
317			/**
318			* Delete the entity
319			* @param ServerRequestInterface $request
320			* @return ResponseInterface
321			*/
322			public function delete(ServerRequestInterface $request): ResponseInterface
323			{
324			$id = (int) $request->getAttribute('id');
325
326			/** @var Role\|null $role */
327			$role = $this->roleRepository->find($id);
328
329			if ($role === null) {
330			$this->flash->setError($this->lang->tr('This record doesn\'t exist'));
331
332			return new RedirectResponse(
333			$this->routeHelper->generateUrl('role_list')
334			);
335			}
336
337			try {
338			$this->roleRepository->delete($role);
339
340			$this->flash->setSuccess($this->lang->tr('Data successfully deleted'));
341
342			return new RedirectResponse(
343			$this->routeHelper->generateUrl('role_list')
344			);
345			} catch (Exception $ex) {
346			$this->logger->error('Error when delete the data {error}', ['error' => $ex->getMessage()]);
347
348			$this->flash->setError($this->lang->tr('Data processing error'));
349
350			return new RedirectResponse(
351			$this->routeHelper->generateUrl('role_list')
352			);
353			}
354			}
355			}
356

platine-php / starter

RoleAction::update() B last analyzed 2025-09-18 05:47 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

RoleAction::update() B
last analyzed 2025-09-18 05:47 UTC