superdesk / web-publisher

src/SWP/Bundle/UserBundle/Controller/RegistrationController.php

Indentation +106 added lines, -106 removed lines

@@ -43,53 +43,53 @@ 
 
 class RegistrationController extends AbstractController {
 
-  private SettingsManagerInterface $settingsManager;
-  private ScopeContextInterface $scopeContext;
-  private EmailVerifier $emailVerifier;
-  private UserManagerInterface $userManager;
-  private EntityManagerInterface $entityManager;
-
-  /**
-   * @param SettingsManagerInterface $settingsManager
-   * @param ScopeContextInterface $scopeContext
-   * @param EmailVerifier $emailVerifier
-   * @param UserManagerInterface $userManager
-   * @param EntityManagerInterface $entityManager
-   */
-  public function __construct(
-      SettingsManagerInterface $settingsManager,
-      ScopeContextInterface $scopeContext,
-      EmailVerifier $emailVerifier,
-      UserManagerInterface $userManager,
-      EntityManagerInterface   $entityManager
-  ) {
+    private SettingsManagerInterface $settingsManager;
+    private ScopeContextInterface $scopeContext;
+    private EmailVerifier $emailVerifier;
+    private UserManagerInterface $userManager;
+    private EntityManagerInterface $entityManager;
+
+    /**
+     * @param SettingsManagerInterface $settingsManager
+     * @param ScopeContextInterface $scopeContext
+     * @param EmailVerifier $emailVerifier
+     * @param UserManagerInterface $userManager
+     * @param EntityManagerInterface $entityManager
+     */
+    public function __construct(
+        SettingsManagerInterface $settingsManager,
+        ScopeContextInterface $scopeContext,
+        EmailVerifier $emailVerifier,
+        UserManagerInterface $userManager,
+        EntityManagerInterface   $entityManager
+    ) {
     $this->settingsManager = $settingsManager;
     $this->scopeContext = $scopeContext;
     $this->emailVerifier = $emailVerifier;
     $this->userManager = $userManager;
     $this->entityManager = $entityManager;
-  }
-
-
-  /**
-   * @FOSRoute(
-   *     "/api/{version}/users/register/",
-   *     methods={"POST"},
-   *     options={"expose"=true},
-   *     defaults={"version"="v2"},
-   *     name="swp_api_core_register_user"
-   * )
-   */
-  public function registerAction(
-      Request                     $request,
-      UserPasswordHasherInterface $userPasswordEncoder,
-      UserManagerInterface        $userManager,
-      MailerInterface             $mailer
-  ) {
+    }
+
+
+    /**
+     * @FOSRoute(
+     *     "/api/{version}/users/register/",
+     *     methods={"POST"},
+     *     options={"expose"=true},
+     *     defaults={"version"="v2"},
+     *     name="swp_api_core_register_user"
+     * )
+     */
+    public function registerAction(
+        Request                     $request,
+        UserPasswordHasherInterface $userPasswordEncoder,
+        UserManagerInterface        $userManager,
+        MailerInterface             $mailer
+    ) {
     try {
-      $this->ensureThatRegistrationIsEnabled();
+        $this->ensureThatRegistrationIsEnabled();
     } catch (NotFoundHttpException $e) {
-      return new SingleResourceResponse(null, new ResponseContext(404));
+        return new SingleResourceResponse(null, new ResponseContext(404));
     }
 
     $user = $userManager->createUser();
@@ -98,69 +98,69 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $user->addRole('ROLE_USER');
-      // encode the plain password
-      $user->setPassword(
-          $userPasswordEncoder->hashPassword(
-              $user,
-              $form->get('plainPassword')->getData()
-          )
-      );
-
-      $entityManager = $this->entityManager;
-      $entityManager->persist($user);
-      $entityManager->flush();
-
-      $signatureComponents = $this->emailVerifier->getSignatureComponents('swp_user_verify_email', $user);
-      $url = $signatureComponents->getSignedUrl();
-
-      $mailer->sendConfirmationEmail($user, $url);
-
-      return new JsonResponse([
-          'message' => sprintf(
-              'The user has been created successfully.
+        $user->addRole('ROLE_USER');
+        // encode the plain password
+        $user->setPassword(
+            $userPasswordEncoder->hashPassword(
+                $user,
+                $form->get('plainPassword')->getData()
+            )
+        );
+
+        $entityManager = $this->entityManager;
+        $entityManager->persist($user);
+        $entityManager->flush();
+
+        $signatureComponents = $this->emailVerifier->getSignatureComponents('swp_user_verify_email', $user);
+        $url = $signatureComponents->getSignedUrl();
+
+        $mailer->sendConfirmationEmail($user, $url);
+
+        return new JsonResponse([
+            'message' => sprintf(
+                'The user has been created successfully.
                  An email has been sent to %s. It contains an activation link you must click to activate your account.',
-              $user->getEmail()
-          ),
-          'url' => $url,
-      ]);
+                $user->getEmail()
+            ),
+            'url' => $url,
+        ]);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
-
-  /**
-   * @Route("/verify/email", name="swp_user_verify_email")
-   */
-  public function verifyUserEmail(
-      Request $request,
-      GuardAuthenticatorHandler $guardHandler,
-      LoginAuthenticator $authenticator
-  ): Response {
+    }
+
+    /**
+     * @Route("/verify/email", name="swp_user_verify_email")
+     */
+    public function verifyUserEmail(
+        Request $request,
+        GuardAuthenticatorHandler $guardHandler,
+        LoginAuthenticator $authenticator
+    ): Response {
     $id = (int)$request->get('id'); // retrieve the user id from the url
 
     if ($request->isXmlHttpRequest()) {
-      return $this->verifyUserEmailFromPWA($id, $request);
+        return $this->verifyUserEmailFromPWA($id, $request);
     }
 
     // Verify the user id exists and is not null
     if (null === $id) {
-      return $this->redirectToRoute('homepage');
+        return $this->redirectToRoute('homepage');
     }
 
     $user = $this->userManager->find($id);
 
     // Ensure the user exists in persistence
     if (null === $user) {
-      return $this->redirectToRoute('homepage');
+        return $this->redirectToRoute('homepage');
     }
     // validate email confirmation link, sets User::isVerified=true and persists
     try {
-      $this->emailVerifier->handleEmailConfirmation($request, $user);
+        $this->emailVerifier->handleEmailConfirmation($request, $user);
     } catch (VerifyEmailExceptionInterface $exception) {
-      $this->addFlash('verify_email_error', $exception->getReason());
+        $this->addFlash('verify_email_error', $exception->getReason());
 
-      return $this->redirectToRoute('homepage');
+        return $this->redirectToRoute('homepage');
     }
 
 
@@ -174,63 +174,63 @@ 
     $this->addFlash('success', 'The user has been created successfully.');
 
     return $this->redirectToRoute('swp_user_registration_confirmed');
-  }
+    }
 
-  /**
-   * Tell the user his account is now confirmed.
-   */
-  public function confirmedAction(Request $request) {
+    /**
+     * Tell the user his account is now confirmed.
+     */
+    public function confirmedAction(Request $request) {
     $user = $this->getUser();
     if (!is_object($user) || !$user instanceof UserInterface) {
-      $this->createAccessDeniedException('This user does not have access to this section.');
+        $this->createAccessDeniedException('This user does not have access to this section.');
     }
 
     return $this->render('@SWPUser/Registration/confirmed.html.twig', [
         'user' => $user,
     ]);
-  }
+    }
 
-  /**
-   * @throws NotFoundHttpException
-   */
-  private function ensureThatRegistrationIsEnabled() {
+    /**
+     * @throws NotFoundHttpException
+     */
+    private function ensureThatRegistrationIsEnabled() {
     $settingName = 'registration_enabled';
     $setting = $this->settingsManager->getOneSettingByName($settingName);
     $registrationEnabled = $this->settingsManager
         ->get($settingName, $setting['scope'], $this->scopeContext->getScopeOwner($setting['scope']));
     if (!$registrationEnabled) {
-      throw new NotFoundHttpException('Registration is disabled.');
+        throw new NotFoundHttpException('Registration is disabled.');
+    }
     }
-  }
 
-  private function verifyUserEmailFromPWA(int $id, Request $request): JsonResponse {
+    private function verifyUserEmailFromPWA(int $id, Request $request): JsonResponse {
     // Verify the user id exists and is not null
     if (null === $id) {
-      return new JsonResponse(
-          ['error' => 'User does not exist']
-      );
+        return new JsonResponse(
+            ['error' => 'User does not exist']
+        );
     }
 
     $user = $this->userManager->find($id);
 
     // Ensure the user exists in persistence
     if (null === $user) {
-      return new JsonResponse(
-          ['error' => 'User does not exist']
-      );
+        return new JsonResponse(
+            ['error' => 'User does not exist']
+        );
     }
 
     // validate email confirmation link, sets User::isVerified=true and persists
     try {
-      $this->emailVerifier->handleEmailConfirmation($request, $user);
+        $this->emailVerifier->handleEmailConfirmation($request, $user);
     } catch (VerifyEmailExceptionInterface $exception) {
-      return new JsonResponse(
-          ['error' => 'Registration confirmation invalid']
-      );
+        return new JsonResponse(
+            ['error' => 'Registration confirmation invalid']
+        );
     }
 
     return new JsonResponse(
         ['message' => 'The user has been created successfully.']
     );
-  }
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -137,7 +137,7 @@
       GuardAuthenticatorHandler $guardHandler,
       LoginAuthenticator $authenticator
   ): Response {
-    $id = (int)$request->get('id'); // retrieve the user id from the url
+    $id = (int) $request->get('id'); // retrieve the user id from the url
 
     if ($request->isXmlHttpRequest()) {
       return $this->verifyUserEmailFromPWA($id, $request);

src/SWP/Bundle/UserBundle/Security/UserProvider.php

Spacing +1 added lines, -1 removed lines

@@ -54,7 +54,7 @@
         return $user;
     }
 
-    public function loadUserByIdentifier(string $identifier): SecurityUserInterface|UserInterface
+    public function loadUserByIdentifier(string $identifier): SecurityUserInterface | UserInterface
     {
         $user = $this->findUser($identifier);
 

src/SWP/Bundle/CoreBundle/Controller/AuthController.php

Indentation +100 added lines, -100 removed lines

@@ -38,117 +38,117 @@ 
 
 class AuthController extends AbstractController
 {
-  protected FormFactoryInterface $formFactory;
-  protected ApiKeyRepositoryInterface $apiKeyRepository;
-  protected ApiKeyFactory $apiKeyFactory;
-  protected LockFactory $lockFactory;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param ApiKeyRepositoryInterface $apiKeyRepository
-   * @param ApiKeyFactory $apiKeyFactory
-   * @param LockFactory $lockFactory
-   */
-  public function __construct(
-      FormFactoryInterface $formFactory,
-      ApiKeyRepositoryInterface $apiKeyRepository,
-      ApiKeyFactory$apiKeyFactory,
-      LockFactory $lockFactory
-  ) {
+    protected FormFactoryInterface $formFactory;
+    protected ApiKeyRepositoryInterface $apiKeyRepository;
+    protected ApiKeyFactory $apiKeyFactory;
+    protected LockFactory $lockFactory;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param ApiKeyRepositoryInterface $apiKeyRepository
+     * @param ApiKeyFactory $apiKeyFactory
+     * @param LockFactory $lockFactory
+     */
+    public function __construct(
+        FormFactoryInterface $formFactory,
+        ApiKeyRepositoryInterface $apiKeyRepository,
+        ApiKeyFactory$apiKeyFactory,
+        LockFactory $lockFactory
+    ) {
     $this->formFactory = $formFactory;
     $this->apiKeyRepository = $apiKeyRepository;
     $this->apiKeyFactory = $apiKeyFactory;
     $this->lockFactory = $lockFactory;
-  }
-
-
-  /**
-   * @Route(
-   *     "/api/{version}/auth/",
-   *     options={"expose"=true},
-   *     defaults={"version"="v2"},
-   *     methods={"POST"},
-   *     name="swp_api_auth"
-   * )
-   */
-  public function authenticateAction(
-      Request $request,
-      UserProviderInterface $userProvider,
-      UserPasswordHasherInterface $userPasswordEncoder
-  ) {
+    }
+
+
+    /**
+     * @Route(
+     *     "/api/{version}/auth/",
+     *     options={"expose"=true},
+     *     defaults={"version"="v2"},
+     *     methods={"POST"},
+     *     name="swp_api_auth"
+     * )
+     */
+    public function authenticateAction(
+        Request $request,
+        UserProviderInterface $userProvider,
+        UserPasswordHasherInterface $userPasswordEncoder
+    ) {
     $form = $this->formFactory->createNamed('', UserAuthenticationType::class, []);
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $formData = $form->getData();
+        $formData = $form->getData();
 
-      try {
+        try {
         $user = $userProvider->loadUserByIdentifier($formData['username']);
-      } catch (AuthenticationException $e) {
+        } catch (AuthenticationException $e) {
         $user = null;
-      }
+        }
 
-      if ((null !== $user) && $userPasswordEncoder->isPasswordValid($user, $formData['password'])) {
+        if ((null !== $user) && $userPasswordEncoder->isPasswordValid($user, $formData['password'])) {
         return $this->returnApiTokenResponse($user);
-      }
+        }
     }
 
     return new SingleResourceResponse([
         'status' => 401,
         'message' => 'Unauthorized',
     ], new ResponseContext(401));
-  }
-
-  /**
-   * @Route(
-   *     "/api/{version}/auth/superdesk/",
-   *     options={"expose"=true},
-   *     methods={"POST"},
-   *     defaults={"version"="v2"},
-   *     name="swp_api_auth_superdesk"
-   * )
-   */
-  public function authenticateWithSuperdeskAction(
-      Request               $request,
-      LoggerInterface       $logger,
-      array                 $superdeskServers,
-      UserProviderInterface $userProvider,
-      UserManagerInterface  $userManager
-  ) {
+    }
+
+    /**
+     * @Route(
+     *     "/api/{version}/auth/superdesk/",
+     *     options={"expose"=true},
+     *     methods={"POST"},
+     *     defaults={"version"="v2"},
+     *     name="swp_api_auth_superdesk"
+     * )
+     */
+    public function authenticateWithSuperdeskAction(
+        Request               $request,
+        LoggerInterface       $logger,
+        array                 $superdeskServers,
+        UserProviderInterface $userProvider,
+        UserManagerInterface  $userManager
+    ) {
     $form = $this->formFactory->createNamed('', SuperdeskCredentialAuthenticationType::class, []);
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $formData = $form->getData();
-      $authorizedSuperdeskHosts = $superdeskServers;
-      $superdeskUser = null;
-      $client = new GuzzleHttp\Client();
+        $formData = $form->getData();
+        $authorizedSuperdeskHosts = $superdeskServers;
+        $superdeskUser = null;
+        $client = new GuzzleHttp\Client();
 
-      foreach ($authorizedSuperdeskHosts as $baseUrl) {
+        foreach ($authorizedSuperdeskHosts as $baseUrl) {
         try {
-          $apiRequest = new GuzzleHttp\Psr7\Request('GET', sprintf('%s/api/sessions/%s', $baseUrl, $formData['sessionId']), [
-              'Authorization' => $formData['token'],
-          ]);
+            $apiRequest = new GuzzleHttp\Psr7\Request('GET', sprintf('%s/api/sessions/%s', $baseUrl, $formData['sessionId']), [
+                'Authorization' => $formData['token'],
+            ]);
 
-          $apiResponse = $client->send($apiRequest);
-          if (200 !== $apiResponse->getStatusCode()) {
+            $apiResponse = $client->send($apiRequest);
+            if (200 !== $apiResponse->getStatusCode()) {
             $logger->warning(sprintf('[%s] Unsuccessful response from Superdesk Server: %s', $apiResponse->getStatusCode(), $apiResponse->getBody()->getContents()));
 
             continue;
-          }
+            }
 
-          $content = json_decode($apiResponse->getBody()->getContents(), true);
-          if (is_array($content) && array_key_exists('user', $content)) {
+            $content = json_decode($apiResponse->getBody()->getContents(), true);
+            if (is_array($content) && array_key_exists('user', $content)) {
             $superdeskUser = $content['user'];
 
             break;
-          }
+            }
         } catch (GuzzleHttp\Exception\ClientException $e) {
-          $logger->warning(sprintf('Error when logging in Superdesk: %s', $e->getMessage()));
+            $logger->warning(sprintf('Error when logging in Superdesk: %s', $e->getMessage()));
 
-          continue;
+            continue;
+        }
         }
-      }
 
-      if (null === $superdeskUser) {
+        if (null === $superdeskUser) {
         return new SingleResourceResponse([
             'status' => 401,
             'message' => <<<'MESSAGE'
@@ -156,18 +156,18 @@ 
 Make sure that Publisher can talk to Superdesk instance. Set it's address in "SUPERDESK_SERVERS" environment variable.
 MESSAGE,
         ], new ResponseContext(401));
-      }
+        }
 
-      $publisherUser = $userProvider->findOneByEmail($superdeskUser['email']);
-      if (null === $publisherUser) {
+        $publisherUser = $userProvider->findOneByEmail($superdeskUser['email']);
+        if (null === $publisherUser) {
         try {
-          $publisherUser = $userProvider->loadUserByUsername($superdeskUser['username']);
+            $publisherUser = $userProvider->loadUserByUsername($superdeskUser['username']);
         } catch (AuthenticationException $e) {
-          $publisherUser = null;
+            $publisherUser = null;
+        }
         }
-      }
 
-      if (null === $publisherUser) {
+        if (null === $publisherUser) {
         /** @var UserInterface $publisherUser */
         $publisherUser = $userManager->createUser();
         $publisherUser->setUsername($superdeskUser['username']);
@@ -177,20 +177,20 @@ 
         $publisherUser->setLastName(\array_key_exists('last_name', $superdeskUser) ? $superdeskUser['last_name'] : '');
         $publisherUser->setPassword(password_hash(random_bytes(36), PASSWORD_BCRYPT));
         $userManager->updateUser($publisherUser);
-      }
+        }
 
-      if (null !== $publisherUser) {
+        if (null !== $publisherUser) {
         return $this->returnApiTokenResponse($publisherUser, str_replace('Basic ', '', $formData['token']));
-      }
+        }
     }
 
     return new SingleResourceResponse([
         'status' => 401,
         'message' => 'Unauthorized',
     ], new ResponseContext(401));
-  }
+    }
 
-  private function returnApiTokenResponse(UserInterface $user, string $token = null): SingleResourceResponseInterface {
+    private function returnApiTokenResponse(UserInterface $user, string $token = null): SingleResourceResponseInterface {
     /** @var ApiKeyInterface $apiKey */
     $apiKey = $this->generateOrGetApiKey($user, $token);
 
@@ -201,36 +201,36 @@ 
         ],
         'user' => $user,
     ]);
-  }
+    }
 
-  private function generateOrGetApiKey(UserInterface $user, $token): ?ApiKeyInterface {
+    private function generateOrGetApiKey(UserInterface $user, $token): ?ApiKeyInterface {
     $apiKey = null;
     if (null !== $token) {
-      $apiKey = $this->apiKeyRepository->getValidToken($token)->getQuery()->getOneOrNullResult();
+        $apiKey = $this->apiKeyRepository->getValidToken($token)->getQuery()->getOneOrNullResult();
     } else {
-      $validKeys = $this->apiKeyRepository->getValidTokenForUser($user)->getQuery()->getResult();
-      if (count($validKeys) > 0) {
+        $validKeys = $this->apiKeyRepository->getValidTokenForUser($user)->getQuery()->getResult();
+        if (count($validKeys) > 0) {
         $apiKey = reset($validKeys);
-      }
+        }
     }
 
     if (null === $apiKey) {
-      $apiKey = $this->apiKeyFactory->create($user, $token);
+        $apiKey = $this->apiKeyFactory->create($user, $token);
 
-      try {
+        try {
         $lock = $this->lockFactory->createLock(md5(json_encode(['type' => 'user_api_key', 'user' => $user->getId()])), 2);
         if (!$lock->acquire()) {
-          throw new RuntimeException('Other api key is created right now for this user');
+            throw new RuntimeException('Other api key is created right now for this user');
         }
         $this->apiKeyRepository->add($apiKey);
         $lock->release();
-      } catch (RuntimeException $e) {
+        } catch (RuntimeException $e) {
         sleep(2);
 
         return $this->generateOrGetApiKey($user, $token);
-      }
+        }
     }
 
     return $apiKey;
-  }
+    }
 }