superdesk / web-publisher

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

Indentation +43 added lines, -43 removed lines

@@ -35,39 +35,39 @@ 
 
 class PublishDestinationController extends Controller {
 
-  private FormFactoryInterface $formFactory;
-  private EventDispatcherInterface $eventDispatcher;
-  private CachedTenantContextInterface $cachedTenantContext;
-  private RepositoryInterface $publishDestinationRepository;
-  private EntityManagerInterface $entityManager;
-  private FactoryInterface $publishDestinationFactory;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param CachedTenantContextInterface $cachedTenantContext
-   * @param RepositoryInterface $publishDestinationRepository
-   * @param EntityManagerInterface $entityManager
-   * @param FactoryInterface $publishDestinationFactory
-   */
-  public function __construct(FormFactoryInterface         $formFactory,
-                              EventDispatcherInterface     $eventDispatcher,
-                              CachedTenantContextInterface $cachedTenantContext,
-                              RepositoryInterface          $publishDestinationRepository,
-                              EntityManagerInterface       $entityManager,
-                              FactoryInterface             $publishDestinationFactory) {
+    private FormFactoryInterface $formFactory;
+    private EventDispatcherInterface $eventDispatcher;
+    private CachedTenantContextInterface $cachedTenantContext;
+    private RepositoryInterface $publishDestinationRepository;
+    private EntityManagerInterface $entityManager;
+    private FactoryInterface $publishDestinationFactory;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param CachedTenantContextInterface $cachedTenantContext
+     * @param RepositoryInterface $publishDestinationRepository
+     * @param EntityManagerInterface $entityManager
+     * @param FactoryInterface $publishDestinationFactory
+     */
+    public function __construct(FormFactoryInterface         $formFactory,
+                                EventDispatcherInterface     $eventDispatcher,
+                                CachedTenantContextInterface $cachedTenantContext,
+                                RepositoryInterface          $publishDestinationRepository,
+                                EntityManagerInterface       $entityManager,
+                                FactoryInterface             $publishDestinationFactory) {
     $this->formFactory = $formFactory;
     $this->eventDispatcher = $eventDispatcher;
     $this->cachedTenantContext = $cachedTenantContext;
     $this->publishDestinationRepository = $publishDestinationRepository;
     $this->entityManager = $entityManager;
     $this->publishDestinationFactory = $publishDestinationFactory;
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/organization/destinations/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_publishing_destination_create")
-   */
-  public function createAction(Request $request): SingleResourceResponse {
+    /**
+     * @Route("/api/{version}/organization/destinations/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_publishing_destination_create")
+     */
+    public function createAction(Request $request): SingleResourceResponse {
     $tenantContext = $this->cachedTenantContext;
 
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
@@ -78,26 +78,26 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $repository = $this->publishDestinationRepository;
-      /** @var PublishDestinationInterface $publishDestination */
-      $publishDestination = $repository->findOneByTenant($destination->getTenant());
-      if (null !== $publishDestination) {
+        $repository = $this->publishDestinationRepository;
+        /** @var PublishDestinationInterface $publishDestination */
+        $publishDestination = $repository->findOneByTenant($destination->getTenant());
+        if (null !== $publishDestination) {
         $repository->remove($publishDestination);
-      }
+        }
 
-      $currentOrganization->addPublishDestination($destination);
-      $this->entityManager->flush();
+        $currentOrganization->addPublishDestination($destination);
+        $this->entityManager->flush();
 
-      return new SingleResourceResponse($destination, new ResponseContext(200));
+        return new SingleResourceResponse($destination, new ResponseContext(200));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/organization/destinations/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_publishing_destination_update", requirements={"id"="\d+"})
-   */
-  public function updateAction(Request $request, $id): SingleResourceResponse {
+    /**
+     * @Route("/api/{version}/organization/destinations/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_publishing_destination_update", requirements={"id"="\d+"})
+     */
+    public function updateAction(Request $request, $id): SingleResourceResponse {
     $objectManager = $this->entityManager;
     $publishDestination = $this->findOr404($id);
 
@@ -110,14 +110,14 @@ 
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $objectManager->flush();
-      $objectManager->refresh($publishDestination);
+        $objectManager->flush();
+        $objectManager->refresh($publishDestination);
 
-      return new SingleResourceResponse($publishDestination);
+        return new SingleResourceResponse($publishDestination);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
     private function findOr404(int $id)
     {

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

Indentation +57 added lines, -57 removed lines

@@ -32,83 +32,83 @@ 
 
 class RuleController extends FOSRestController {
 
-  private FormFactoryInterface $formFactory;
-  private EntityManagerInterface $entityManager;
-  private RuleRepositoryInterface $ruleRepository;
-  private FactoryInterface $ruleFactory;
-  private EventDispatcherInterface $eventDispatcher;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param EntityManagerInterface $entityManager
-   * @param RuleRepositoryInterface $ruleRepository
-   * @param FactoryInterface $ruleFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(FormFactoryInterface    $formFactory, EntityManagerInterface $entityManager,
-                              RuleRepositoryInterface $ruleRepository, FactoryInterface $ruleFactory,
-                              EventDispatcherInterface         $eventDispatcher) {
+    private FormFactoryInterface $formFactory;
+    private EntityManagerInterface $entityManager;
+    private RuleRepositoryInterface $ruleRepository;
+    private FactoryInterface $ruleFactory;
+    private EventDispatcherInterface $eventDispatcher;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param EntityManagerInterface $entityManager
+     * @param RuleRepositoryInterface $ruleRepository
+     * @param FactoryInterface $ruleFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(FormFactoryInterface    $formFactory, EntityManagerInterface $entityManager,
+                                RuleRepositoryInterface $ruleRepository, FactoryInterface $ruleFactory,
+                                EventDispatcherInterface         $eventDispatcher) {
     $this->formFactory = $formFactory;
     $this->entityManager = $entityManager;
     $this->ruleRepository = $ruleRepository;
     $this->ruleFactory = $ruleFactory;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/rules/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_rule")
-   */
-  public function listAction(Request $request) {
+    /**
+     * @Route("/api/{version}/rules/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_rule")
+     */
+    public function listAction(Request $request) {
     $rules = $this->ruleRepository
         ->getPaginatedByCriteria($this->eventDispatcher, new Criteria(), $request->query->all('sorting'), new PaginationData($request));
 
     if (0 === $rules->count()) {
-      throw new NotFoundHttpException('No rules were found.');
+        throw new NotFoundHttpException('No rules were found.');
     }
 
     return new ResourcesListResponse($rules);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/rules/{id}", requirements={"id"="\d+"}, options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_rule")
-   */
-  public function getAction(int $id) {
+    /**
+     * @Route("/api/{version}/rules/{id}", requirements={"id"="\d+"}, options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_rule")
+     */
+    public function getAction(int $id) {
     return new SingleResourceResponse($this->findOr404($id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/rules/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_create_rule")
-   */
-  public function createAction(Request $request) {
+    /**
+     * @Route("/api/{version}/rules/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_create_rule")
+     */
+    public function createAction(Request $request) {
     $ruleRepository = $this->ruleRepository;
     $rule = $this->ruleFactory->create();
     $form = $this->formFactory->createNamed('', RuleType::class, $rule);
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $ruleRepository->add($rule);
+        $ruleRepository->add($rule);
 
-      return new SingleResourceResponse($rule, new ResponseContext(201));
+        return new SingleResourceResponse($rule, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_rule", methods={"DELETE"}, requirements={"id"="\d+"})
-   */
-  public function deleteAction(int $id) {
+    /**
+     * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_rule", methods={"DELETE"}, requirements={"id"="\d+"})
+     */
+    public function deleteAction(int $id) {
     $ruleRepository = $this->ruleRepository;
     $ruleRepository->remove($this->findOr404($id));
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_rule", requirements={"id"="\d+"})
-   */
-  public function updateAction(Request $request, int $id) {
+    /**
+     * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_rule", requirements={"id"="\d+"})
+     */
+    public function updateAction(Request $request, int $id) {
     $rule = $this->findOr404($id);
     $objectManager = $this->entityManager;
 
@@ -118,21 +118,21 @@ 
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $objectManager->flush();
-      $objectManager->refresh($rule);
+        $objectManager->flush();
+        $objectManager->refresh($rule);
 
-      return new SingleResourceResponse($rule);
+        return new SingleResourceResponse($rule);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
-
-  private function findOr404(int $id)
-  {
-      $rule = $this->ruleRepository->findOneBy(['id' => $id]);
-      if (null === ($rule)) {
-          throw new NotFoundHttpException('Rule was not found.');
-      }
-      return $rule;
-  }
+    }
+
+    private function findOr404(int $id)
+    {
+        $rule = $this->ruleRepository->findOneBy(['id' => $id]);
+        if (null === ($rule)) {
+            throw new NotFoundHttpException('Rule was not found.');
+        }
+        return $rule;
+    }
 }

src/SWP/Bundle/ContentBundle/EventListener/MimeTypeListener.php

Spacing +1 added lines, -1 removed lines

@@ -47,7 +47,7 @@
                     }
                 }
                 $mim = MimeTypeHelper::getByExtension($extension);
-                $response->headers->set('Content-Type', $mim .'; charset=UTF-8');
+                $response->headers->set('Content-Type', $mim.'; charset=UTF-8');
             }
         }
     }

src/SWP/Bundle/CoreBundle/Command/TestCommand.php

Spacing +13 added lines, -13 removed lines

@@ -50,38 +50,38 @@
     protected function execute(InputInterface $input, OutputInterface $output)
     {
         $dir = $this->container->getParameter('kernel.project_dir');
-        $path = $dir . '/' . $input->getArgument('path');
+        $path = $dir.'/'.$input->getArgument('path');
 
         if (!file_exists($path)) {
-            throw new \InvalidArgumentException('File ' . $path . ' doe not exist.');
+            throw new \InvalidArgumentException('File '.$path.' doe not exist.');
         }
 
-        $output->writeln('<info>Checking file:</info> ' . $path);
+        $output->writeln('<info>Checking file:</info> '.$path);
 
         $mimType = new FileBinaryMimeTypeGuesser();
-        $output->writeln('<info>FileBinaryMimeTypeGuesser:</info> ' . $mimType->guessMimeType($path));
+        $output->writeln('<info>FileBinaryMimeTypeGuesser:</info> '.$mimType->guessMimeType($path));
 
         $mimType = new FileinfoMimeTypeGuesser();
-        $output->writeln('<info>FileinfoMimeTypeGuesser:</info> ' . $mimType->guessMimeType($path));
+        $output->writeln('<info>FileinfoMimeTypeGuesser:</info> '.$mimType->guessMimeType($path));
 
         $mim = MimeTypes::getDefault()->guessMimeType($path);
-        $output->writeln('<info>Default Symfony MimType:</info> ' . $mim);
+        $output->writeln('<info>Default Symfony MimType:</info> '.$mim);
 
 
         $mimByExtension = MimeTypes::getDefault()->getMimeTypes($ext = pathinfo($path, PATHINFO_EXTENSION));
-        $output->writeln('<info>MimType by extension:</info> ' . implode(',', $mimByExtension));
+        $output->writeln('<info>MimType by extension:</info> '.implode(',', $mimByExtension));
 
 
         $mimExtension = MimeTypes::getDefault()->getExtensions($mimByExtension[0]);
-        $output->writeln('<info>Extension of mim types:</info> ' . $mimByExtension[0] . ' <info>is:</info> ' . implode(',', $mimExtension));
+        $output->writeln('<info>Extension of mim types:</info> '.$mimByExtension[0].' <info>is:</info> '.implode(',', $mimExtension));
 
         $output->writeln('--------------- My ----------------');
 
-        $output->writeln('<info>My MimTypes checker:</info> ' . \SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getByPath($path));
-        $output->writeln('<info>My Extensions by MimTypes checker:</info> ' . \SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('application/json'));
-        $output->writeln('<info>My Extensions by MimTypes checker:</info> ' . \SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('application/javascript'));
-        $output->writeln('<info>My Extensions by MimTypes checker:</info> ' . \SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('image/png'));
-        $output->writeln('<info>My Extensions by MimTypes checker:</info> ' . \SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('image/jpeg'));
+        $output->writeln('<info>My MimTypes checker:</info> '.\SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getByPath($path));
+        $output->writeln('<info>My Extensions by MimTypes checker:</info> '.\SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('application/json'));
+        $output->writeln('<info>My Extensions by MimTypes checker:</info> '.\SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('application/javascript'));
+        $output->writeln('<info>My Extensions by MimTypes checker:</info> '.\SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('image/png'));
+        $output->writeln('<info>My Extensions by MimTypes checker:</info> '.\SWP\Bundle\CoreBundle\Util\MimeTypeHelper::getExtensionByMimeType('image/jpeg'));
 
         return 0;
     }

src/SWP/Bundle/CoreBundle/Util/MimeTypeHelper.php

Spacing +3 added lines, -3 removed lines

@@ -20,7 +20,7 @@ 
      * @param bool $all
      * @return array|string
      */
-    public static function getByPath(string $path, bool $all = false): array|string
+    public static function getByPath(string $path, bool $all = false): array | string
     {
         $ext = pathinfo($path, PATHINFO_EXTENSION);
         return self::getByExtension($ext, $all);
@@ -31,7 +31,7 @@ 
      * @param bool $all
      * @return array|string
      */
-    public static function getByExtension(string $ext, bool $all = false): array|string
+    public static function getByExtension(string $ext, bool $all = false): array | string
     {
         $mimeType = MimeTypes::getDefault();
         $types = $mimeType->getMimeTypes($ext);
@@ -52,7 +52,7 @@ 
      * @param bool $all
      * @return array|string
      */
-    public static function getExtensionByMimeType(string $mime, bool $all = false): array|string
+    public static function getExtensionByMimeType(string $mime, bool $all = false): array | string
     {
         $mimeType = MimeTypes::getDefault();
         $extensions = $mimeType->getExtensions($mime);

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;
-  }
+    }
 }

src/SWP/Bundle/CoreBundle/Migrations/2021/01/Version20210112135542.php

Spacing +2 added lines, -2 removed lines

@@ -126,9 +126,9 @@
             return $data;
         }
 
-        $callback = function ($matches) {
+        $callback = function($matches) {
             $matches[2] = trim(preg_replace('/\s\s+/', ' ', $matches[2]));
-            return 's:' . mb_strlen($matches[2]) . ':"' . $matches[2] . '";';
+            return 's:'.mb_strlen($matches[2]).':"'.$matches[2].'";';
         };
 
         $data = preg_replace_callback('!s:(\d+):"(.*?)";!s', $callback, $data);