UserController::trash() - Code Metrics - SchulIT/idp - Measure and Improve Code Quality continuously with Scrutinizer

UserController::trash() A
last analyzed 2023-04-26 09:21 UTC

↳ Parent: UserController

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
cc	1
eloc	3
c	0
b	0
f	0
nc	1
nop	3
dl	0
loc	4
ccs	0
cts	0
cp	0
crap	2
rs	10

<?php

namespace App\Controller;

use AdAuth\AdAuthInterface;
use AdAuth\Credentials;
use AdAuth\Response\PasswordFailedResponse;
use AdAuth\Response\PasswordSuccessResponse;
use AdAuth\SocketException;
use App\Entity\ActiveDirectoryUser;
use App\Entity\User;
use App\Form\AttributeDataTrait;
use App\Form\ResetPasswordType;
use App\Form\ResetPasswortActiveDirectoryType;
use App\Form\UserType;
use App\Entity\UserType as UserTypeEntity;
use App\Repository\UserRepositoryInterface;
use App\Repository\UserTypeRepositoryInterface;
use App\Saml\AttributeValueProvider;
use App\Security\ForgotPassword\ForgotPasswordManager;
use App\Security\Session\LogoutHelper;
use App\Service\AttributePersister;
use App\Service\AttributeResolver;
use App\Utils\ArrayUtils;
use App\View\Filter\UserRoleFilter;
use App\View\Filter\UserTypeFilter;
use SchulIT\CommonBundle\Form\ConfirmType;
use SchulIT\CommonBundle\Utils\RefererHelper;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Http\Attribute\IsGranted;
use Symfony\Contracts\Translation\TranslatorInterface;

class UserController extends AbstractController {

    use AttributeDataTrait;

    public const USERS_PER_PAGE = 25;

    public const CsrfTokenId = 'remove_user';
    public const CsrfTokenKey = '_csrf_token';

    public function __construct(private readonly UserRepositoryInterface $repository)
    {
    }

    private function internalDisplay(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter, bool $deleted): Response {
        $q = $request->query->get('q', null);
        $page = $request->query->getInt('page', 1);
        $grade = $request->query->get('grade', null);

        $grades = $this->repository->findGrades();

        if(!in_array($grade, $grades)) {
            $grade = null;
        }

        $typeFilterView = $typeFilter->handle($request->query->get('type'));
        $roleFilterView = $roleFilter->handle($request->query->get('role'));

        $withoutParents = $typeFilterView->getCurrentType() !== null && $typeFilterView->getCurrentType()->getAlias() === 'student' && $request->query->get('without_parents') === '✓';

        $paginator = $this->repository->getPaginatedUsers(static::USERS_PER_PAGE, $page, $typeFilterView->getCurrentType(), $roleFilterView->getCurrentRole(), $q, $grade, $deleted, $withoutParents);

        $pages = 1;

        if($paginator->count() > 0) {
            $pages = ceil((float)$paginator->count() / static::USERS_PER_PAGE);
        }

        $template = $deleted ? 'users/trash.html.twig' : 'users/index.html.twig';

        $statistics = [ ];

        if($deleted === false) {
            foreach ($typeFilterView->getTypes() as $type) {
                $statistics[] = [
                    'type' => $type,
                    'count' => $this->repository->countUsers($type)
                ];
            }
        }

        return $this->render($template, [
            'users' => $paginator->getIterator(),
            'page' => $page,
            'pages' => $pages,
            'grade' => $grade,
            'grades' => $grades,
            'q' => $q,
            'statistics' => $statistics,
            'count' => $this->repository->countUsers(),
            'roleFilter' => $roleFilterView,
            'typeFilter' => $typeFilterView,
            'withoutParents' => $withoutParents,
            'csrf_id' => static::CsrfTokenId,
            'csrf_key' => static::CsrfTokenKey
        ]);
    }

    #[Route(path: '/users', name: 'users')]
    #[Security("is_granted('ROLE_ADMIN') or is_granted('ROLE_PASSWORD_MANAGER')")]
    public function index(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter): Response {
        return $this->internalDisplay($request, $typeFilter, $roleFilter, false);
    }

    #[Route(path: '/users/trash', name: 'users_trash')]
    #[IsGranted('ROLE_ADMIN')]
    public function trash(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter): Response {
        return $this->internalDisplay($request, $typeFilter, $roleFilter, true);
    }

    #[Route(path: '/users/{uuid}/attributes', name: 'show_attributes')]
    #[IsGranted('ROLE_ADMIN')]
    public function showAttributes(User $user, AttributeResolver $resolver, AttributeValueProvider $provider): Response {
        $attributes = $resolver->getDetailedResultingAttributeValuesForUser($user);
        $defaultAttributes = $provider->getCommonAttributesForUser($user);

        return $this->render('users/attributes.html.twig', [
            'selectedUser' => $user,
            'attributes' => $attributes,
            'defaultAttributes' => $defaultAttributes
        ]);
    }

    #[Route(path: '/users/add', name: 'add_user')]
    #[IsGranted('ROLE_ADMIN')]
    public function add(Request $request, AttributePersister $attributePersister, UserPasswordHasherInterface $passwordHasher): Response {
        $user = new User();

        $form = $this->createForm(UserType::class, $user);
        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {
            $user->setPassword($passwordHasher->hashPassword($user, $form->get('group_password')->get('password')->getData()));

            $this->repository->persist($user);

            $attributeData = $this->getAttributeData($form);
            $attributePersister->persistUserAttributes($attributeData, $user);

            $this->addFlash('success', 'users.add.success');
            return $this->redirectToRoute('users');
        }

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

    #[Route(path: '/users/{uuid}/edit', name: 'edit_user')]
    #[IsGranted('ROLE_ADMIN')]
    public function edit(Request $request, User $user, AttributePersister $attributePersister, UserPasswordHasherInterface $passwordHasher): Response {
        if($user->isDeleted()) {
            throw new NotFoundHttpException();
        }

        $form = $this->createForm(UserType::class, $user);
        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {
            if($form->has('group_password')) {
                $password = $form->get('group_password')->get('password')->getData();

                if (!empty($password) && !$user instanceof ActiveDirectoryUser) {
                    $user->setPassword($passwordHasher->hashPassword($user, $password));
                }
            }

            $this->repository->persist($user);

            $attributeData = $this->getAttributeData($form);
            $attributePersister->persistUserAttributes($attributeData, $user);

            $this->addFlash('success', 'users.edit.success');
            return $this->redirectToRoute('users');
        }

        return $this->render('users/edit.html.twig', [
            'form' => $form->createView(),
            'requestedUser' => $user
        ]);
    }

    #[Route(path: '/users/{uuid}/remove', name: 'remove_user')]
    #[IsGranted('ROLE_ADMIN')]
    public function remove(User $user, Request $request, TranslatorInterface $translator): Response {
        if($this->getUser() instanceof User && $this->getUser()->getId() === $user->getId()) {
            $this->addFlash('error', 'users.remove.error.self');
            return $this->redirectToRoute('users');
        }

        if($user->isDeleted() === false) {
            if($request->isMethod('POST') && $this->isCsrfTokenValid(static::CsrfTokenId, $request->request->get(static::CsrfTokenKey))) {
                $this->addFlash('success', 'users.remove.trash.success');
                $this->repository->remove($user);
                return $this->redirectToRoute('users');
            } else {
                $this->addFlash('error', 'users.remove.trash.error');
                return $this->redirectToRoute('users');
            }
        }

        $form = $this->createForm(ConfirmType::class, [], [
            'message' => $translator->trans('users.remove.confirm', [
                '%username%' => $user->getUsername(),
                '%firstname%' => $user->getFirstname(),
                '%lastname%' => $user->getLastname()
            ]),
            'label' => 'users.remove.label'
        ]);
        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {
            $this->repository->remove($user);

            $this->addFlash('success', 'users.remove.success');
            return $this->redirectToRoute('users');
        }

        return $this->render('users/remove.html.twig', [
            'form' => $form->createView(),
            'requestedUser' => $user
        ]);
    }

    #[Route(path: '/users/{uuid}/restore', name: 'restore_user', methods: ['POST'])]
    #[IsGranted('ROLE_ADMIN')]
    public function restore(User $user, Request $request): Response {
        if($this->getUser() instanceof User && $this->getUser()->getId() === $user->getId()) {
            $this->addFlash('error', 'users.restore.error.self');
            return $this->redirectToRoute('users');
        }

        if($request->isMethod('POST') && $this->isCsrfTokenValid(static::CsrfTokenId, $request->request->get(static::CsrfTokenKey))) {
            $this->addFlash('success', 'users.trash.restore.success');
            $user->setDeletedAt(null);
            $this->repository->persist($user);
            return $this->redirectToRoute('users_trash');
        }

        $this->addFlash('error', 'users.trash.restore.error');
        return $this->redirectToRoute('users_trash');
    }

    #[Route(path: '/users/{uuid}/reset_password_ad', name: 'reset_password_ad')]
    #[IsGranted('ROLE_PASSWORD_MANAGER')]
    public function resetPasswordActiveDirectory(Request $request, User $user, AdAuthInterface $adAuth, TranslatorInterface $translator): Response {
        if(!$user instanceof ActiveDirectoryUser) {
            $this->addFlash('error', 'users.reset_pw_ad.cannot_change');
            return $this->redirectToRoute('users');
        }

        $form = $this->createForm(ResetPasswortActiveDirectoryType::class, [
            'username' => $user->getUserIdentifier()
        ]);
        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {
            $adminUsername = $form->get('admin_username')->getData();
            $adminPassword = $form->get('admin_password')->getData();
            $username = $user->getUserIdentifier();
            $password = $form->get('password')->getData();

            try {
                $response = $adAuth->resetPassword(
                    new Credentials($username, $password),
                    new Credentials($adminUsername, $adminPassword)
                );

                if($response instanceof PasswordSuccessResponse) {
                    $this->addFlash('success', 'users.reset_pw_ad.success');
                    return $this->redirectToRoute('users');
                } else if($response instanceof PasswordFailedResponse) {
                    $this->addFlash('error', $translator->trans('users.reset_pw_ad.failure', [
                        '%error%' => $response->getResult()
                    ]));
                }
            } catch (SocketException $e) {
                $this->addFlash('error', $translator->trans('users.reset_pw_ad.failure', [
                    '%error%' => $e->getMessage()
                ]));
            }
        }

        return $this->render('users/reset_pw_ad.html.twig', [
            'user' => $user,
            'form' => $form->createView()
        ]);
    }

    #[Route(path: '/users/{uuid}/reset_password', name: 'reset_password')]
    #[IsGranted('ROLE_PASSWORD_MANAGER')]
    public function resetPassword(Request $request, User $user, ForgotPasswordManager $manager): Response {
        if($manager->canResetPassword($user, '[email protected]') === false) {
            $this->addFlash('error', 'users.reset_pw.cannot_change');
            return $this->redirectToRoute('users');
        }

        $form = $this->createForm(ResetPasswordType::class, [
            'email' => $user->getEmail()
        ]);
        $form->handleRequest($request);

        if($form->isSubmitted() && $form->isValid()) {
            $email = $form->get('email')->getData();
            $manager->resetPassword($user, $email);
            $this->addFlash('success', 'forgot_pw.request.success');
            return $this->redirectToRoute('users');
        }

        return $this->render('users/reset_pw.html.twig', [
            'user' => $user,
            'form'=> $form->createView()
        ]);
    }

    #[Route('/users/{uuid}/logout', name: 'user_logout_everywhere')]
    #[IsGranted('ROLE_ADMIN')]
    public function logout(User $user, LogoutHelper $logoutHelper, RefererHelper $refererHelper): Response {
        $logoutHelper->logout($user);

        $this->addFlash('success', 'sessions.logout_everywhere.success');
        return $this->redirect(
            $refererHelper->getRefererPathFromRequest('users')
        );
    }
}

1			<?php
2
3			namespace App\Controller;
4
5			use AdAuth\AdAuthInterface;
6			use AdAuth\Credentials;
7			use AdAuth\Response\PasswordFailedResponse;
8			use AdAuth\Response\PasswordSuccessResponse;
9			use AdAuth\SocketException;
10			use App\Entity\ActiveDirectoryUser;
11			use App\Entity\User;
12			use App\Form\AttributeDataTrait;
13			use App\Form\ResetPasswordType;
14			use App\Form\ResetPasswortActiveDirectoryType;
15			use App\Form\UserType;
16			use App\Entity\UserType as UserTypeEntity;
17			use App\Repository\UserRepositoryInterface;
18			use App\Repository\UserTypeRepositoryInterface;
19			use App\Saml\AttributeValueProvider;
20			use App\Security\ForgotPassword\ForgotPasswordManager;
21			use App\Security\Session\LogoutHelper;
22			use App\Service\AttributePersister;
23			use App\Service\AttributeResolver;
24			use App\Utils\ArrayUtils;
25			use App\View\Filter\UserRoleFilter;
26			use App\View\Filter\UserTypeFilter;
27			use SchulIT\CommonBundle\Form\ConfirmType;
28			use SchulIT\CommonBundle\Utils\RefererHelper;
29			use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
30			use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
31			use Symfony\Component\HttpFoundation\Request;
32			use Symfony\Component\HttpFoundation\Response;
33			use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
34			use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
35			use Symfony\Component\Routing\Annotation\Route;
36			use Symfony\Component\Security\Http\Attribute\IsGranted;
37			use Symfony\Contracts\Translation\TranslatorInterface;
38
39			class UserController extends AbstractController {
40
41			use AttributeDataTrait;
42
43			public const USERS_PER_PAGE = 25;
44
45			public const CsrfTokenId = 'remove_user';
46			public const CsrfTokenKey = '_csrf_token';
47
48			public function __construct(private readonly UserRepositoryInterface $repository)
49			{
50			}
51
52			private function internalDisplay(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter, bool $deleted): Response {
53			$q = $request->query->get('q', null);
54			$page = $request->query->getInt('page', 1);
55			$grade = $request->query->get('grade', null);
56
57			$grades = $this->repository->findGrades();
58
59			if(!in_array($grade, $grades)) {
60			$grade = null;
61			}
62
63			$typeFilterView = $typeFilter->handle($request->query->get('type'));
64			$roleFilterView = $roleFilter->handle($request->query->get('role'));
65
66			$withoutParents = $typeFilterView->getCurrentType() !== null && $typeFilterView->getCurrentType()->getAlias() === 'student' && $request->query->get('without_parents') === '✓';
67
68			$paginator = $this->repository->getPaginatedUsers(static::USERS_PER_PAGE, $page, $typeFilterView->getCurrentType(), $roleFilterView->getCurrentRole(), $q, $grade, $deleted, $withoutParents);
69
70			$pages = 1;
71
72			if($paginator->count() > 0) {
73			$pages = ceil((float)$paginator->count() / static::USERS_PER_PAGE);
74			}
75
76			$template = $deleted ? 'users/trash.html.twig' : 'users/index.html.twig';
77
78			$statistics = [ ];
79
80			if($deleted === false) {
81			foreach ($typeFilterView->getTypes() as $type) {
82			$statistics[] = [
83			'type' => $type,
84			'count' => $this->repository->countUsers($type)
85			];
86			}
87			}
88
89			return $this->render($template, [
90			'users' => $paginator->getIterator(),
91			'page' => $page,
92			'pages' => $pages,
93			'grade' => $grade,
94			'grades' => $grades,
95			'q' => $q,
96			'statistics' => $statistics,
97			'count' => $this->repository->countUsers(),
98			'roleFilter' => $roleFilterView,
99			'typeFilter' => $typeFilterView,
100			'withoutParents' => $withoutParents,
101			'csrf_id' => static::CsrfTokenId,
102			'csrf_key' => static::CsrfTokenKey
103			]);
104			}
105
106			#[Route(path: '/users', name: 'users')]
107			#[Security("is_granted('ROLE_ADMIN') or is_granted('ROLE_PASSWORD_MANAGER')")]
108			public function index(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter): Response {
109			return $this->internalDisplay($request, $typeFilter, $roleFilter, false);
110			}
111
112			#[Route(path: '/users/trash', name: 'users_trash')]
113			#[IsGranted('ROLE_ADMIN')]
114			public function trash(Request $request, UserTypeFilter $typeFilter, UserRoleFilter $roleFilter): Response {
115			return $this->internalDisplay($request, $typeFilter, $roleFilter, true);
116			}
117
118			#[Route(path: '/users/{uuid}/attributes', name: 'show_attributes')]
119			#[IsGranted('ROLE_ADMIN')]
120			public function showAttributes(User $user, AttributeResolver $resolver, AttributeValueProvider $provider): Response {
121			$attributes = $resolver->getDetailedResultingAttributeValuesForUser($user);
122			$defaultAttributes = $provider->getCommonAttributesForUser($user);
123
124			return $this->render('users/attributes.html.twig', [
125			'selectedUser' => $user,
126			'attributes' => $attributes,
127			'defaultAttributes' => $defaultAttributes
128			]);
129			}
130
131			#[Route(path: '/users/add', name: 'add_user')]
132			#[IsGranted('ROLE_ADMIN')]
133			public function add(Request $request, AttributePersister $attributePersister, UserPasswordHasherInterface $passwordHasher): Response {
134			$user = new User();
135
136			$form = $this->createForm(UserType::class, $user);
137			$form->handleRequest($request);
138
139			if($form->isSubmitted() && $form->isValid()) {
140			$user->setPassword($passwordHasher->hashPassword($user, $form->get('group_password')->get('password')->getData()));
141
142			$this->repository->persist($user);
143
144			$attributeData = $this->getAttributeData($form);
145			$attributePersister->persistUserAttributes($attributeData, $user);
146
147			$this->addFlash('success', 'users.add.success');
148			return $this->redirectToRoute('users');
149			}
150
151			return $this->render('users/add.html.twig', [
152			'form' => $form->createView()
153			]);
154			}
155
156			#[Route(path: '/users/{uuid}/edit', name: 'edit_user')]
157			#[IsGranted('ROLE_ADMIN')]
158			public function edit(Request $request, User $user, AttributePersister $attributePersister, UserPasswordHasherInterface $passwordHasher): Response {
159			if($user->isDeleted()) {
160			throw new NotFoundHttpException();
161			}
162
163			$form = $this->createForm(UserType::class, $user);
164			$form->handleRequest($request);
165
166			if($form->isSubmitted() && $form->isValid()) {
167			if($form->has('group_password')) {
168			$password = $form->get('group_password')->get('password')->getData();
169
170			if (!empty($password) && !$user instanceof ActiveDirectoryUser) {
171			$user->setPassword($passwordHasher->hashPassword($user, $password));
172			}
173			}
174
175			$this->repository->persist($user);
176
177			$attributeData = $this->getAttributeData($form);
178			$attributePersister->persistUserAttributes($attributeData, $user);
179
180			$this->addFlash('success', 'users.edit.success');
181			return $this->redirectToRoute('users');
182			}
183
184			return $this->render('users/edit.html.twig', [
185			'form' => $form->createView(),
186			'requestedUser' => $user
187			]);
188			}
189
190			#[Route(path: '/users/{uuid}/remove', name: 'remove_user')]
191			#[IsGranted('ROLE_ADMIN')]
192			public function remove(User $user, Request $request, TranslatorInterface $translator): Response {
193			if($this->getUser() instanceof User && $this->getUser()->getId() === $user->getId()) {
194			$this->addFlash('error', 'users.remove.error.self');
195			return $this->redirectToRoute('users');
196			}
197
198			if($user->isDeleted() === false) {
199			if($request->isMethod('POST') && $this->isCsrfTokenValid(static::CsrfTokenId, $request->request->get(static::CsrfTokenKey))) {
200			$this->addFlash('success', 'users.remove.trash.success');
201			$this->repository->remove($user);
202			return $this->redirectToRoute('users');
203			} else {
204			$this->addFlash('error', 'users.remove.trash.error');
205			return $this->redirectToRoute('users');
206			}
207			}
208
209			$form = $this->createForm(ConfirmType::class, [], [
210			'message' => $translator->trans('users.remove.confirm', [
211			'%username%' => $user->getUsername(),
212			'%firstname%' => $user->getFirstname(),
213			'%lastname%' => $user->getLastname()
214			]),
215			'label' => 'users.remove.label'
216			]);
217			$form->handleRequest($request);
218
219			if($form->isSubmitted() && $form->isValid()) {
220			$this->repository->remove($user);
221
222			$this->addFlash('success', 'users.remove.success');
223			return $this->redirectToRoute('users');
224			}
225
226			return $this->render('users/remove.html.twig', [
227			'form' => $form->createView(),
228			'requestedUser' => $user
229			]);
230			}
231
232			#[Route(path: '/users/{uuid}/restore', name: 'restore_user', methods: ['POST'])]
233			#[IsGranted('ROLE_ADMIN')]
234			public function restore(User $user, Request $request): Response {
235			if($this->getUser() instanceof User && $this->getUser()->getId() === $user->getId()) {
236			$this->addFlash('error', 'users.restore.error.self');
237			return $this->redirectToRoute('users');
238			}
239
240			if($request->isMethod('POST') && $this->isCsrfTokenValid(static::CsrfTokenId, $request->request->get(static::CsrfTokenKey))) {
241			$this->addFlash('success', 'users.trash.restore.success');
242			$user->setDeletedAt(null);
243			$this->repository->persist($user);
244			return $this->redirectToRoute('users_trash');
245			}
246
247			$this->addFlash('error', 'users.trash.restore.error');
248			return $this->redirectToRoute('users_trash');
249			}
250
251			#[Route(path: '/users/{uuid}/reset_password_ad', name: 'reset_password_ad')]
252			#[IsGranted('ROLE_PASSWORD_MANAGER')]
253			public function resetPasswordActiveDirectory(Request $request, User $user, AdAuthInterface $adAuth, TranslatorInterface $translator): Response {
254			if(!$user instanceof ActiveDirectoryUser) {
255			$this->addFlash('error', 'users.reset_pw_ad.cannot_change');
256			return $this->redirectToRoute('users');
257			}
258
259			$form = $this->createForm(ResetPasswortActiveDirectoryType::class, [
260			'username' => $user->getUserIdentifier()
261			]);
262			$form->handleRequest($request);
263
264			if($form->isSubmitted() && $form->isValid()) {
265			$adminUsername = $form->get('admin_username')->getData();
266			$adminPassword = $form->get('admin_password')->getData();
267			$username = $user->getUserIdentifier();
268			$password = $form->get('password')->getData();
269
270			try {
271			$response = $adAuth->resetPassword(
272			new Credentials($username, $password),
273			new Credentials($adminUsername, $adminPassword)
274			);
275
276			if($response instanceof PasswordSuccessResponse) {
277			$this->addFlash('success', 'users.reset_pw_ad.success');
278			return $this->redirectToRoute('users');
279			} else if($response instanceof PasswordFailedResponse) {
280			$this->addFlash('error', $translator->trans('users.reset_pw_ad.failure', [
281			'%error%' => $response->getResult()
282			]));
283			}
284			} catch (SocketException $e) {
285			$this->addFlash('error', $translator->trans('users.reset_pw_ad.failure', [
286			'%error%' => $e->getMessage()
287			]));
288			}
289			}
290
291			return $this->render('users/reset_pw_ad.html.twig', [
292			'user' => $user,
293			'form' => $form->createView()
294			]);
295			}
296
297			#[Route(path: '/users/{uuid}/reset_password', name: 'reset_password')]
298			#[IsGranted('ROLE_PASSWORD_MANAGER')]
299			public function resetPassword(Request $request, User $user, ForgotPasswordManager $manager): Response {
300			if($manager->canResetPassword($user, '[email protected]') === false) {
301			$this->addFlash('error', 'users.reset_pw.cannot_change');
302			return $this->redirectToRoute('users');
303			}
304
305			$form = $this->createForm(ResetPasswordType::class, [
306			'email' => $user->getEmail()
307			]);
308			$form->handleRequest($request);
309
310			if($form->isSubmitted() && $form->isValid()) {
311			$email = $form->get('email')->getData();
312			$manager->resetPassword($user, $email);
313			$this->addFlash('success', 'forgot_pw.request.success');
314			return $this->redirectToRoute('users');
315			}
316
317			return $this->render('users/reset_pw.html.twig', [
318			'user' => $user,
319			'form'=> $form->createView()
320			]);
321			}
322
323			#[Route('/users/{uuid}/logout', name: 'user_logout_everywhere')]
324			#[IsGranted('ROLE_ADMIN')]
325			public function logout(User $user, LogoutHelper $logoutHelper, RefererHelper $refererHelper): Response {
326			$logoutHelper->logout($user);
327
328			$this->addFlash('success', 'sessions.logout_everywhere.success');
329			return $this->redirect(
330			$refererHelper->getRefererPathFromRequest('users')
331			);
332			}
333			}

SchulIT / idp

UserController::trash() A last analyzed 2023-04-26 09:21 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

UserController::trash() A
last analyzed 2023-04-26 09:21 UTC