superdesk / web-publisher

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

Indentation +85 added lines, -85 removed lines

@@ -26,137 +26,137 @@
 use Symfony\Component\Routing\Annotation\Route;
 
 class StaticThemeAssetsController extends Controller {
-  /**
-   * Directory with assets inside theme.
-   */
-  const ASSETS_DIRECTORY = 'public';
-
-  private TenantAwareThemeContextInterface $tenantAwareThemeContext;
-  private ThemeLoaderInterface $themeLoader;
-  private ThemeRepositoryInterface $themeRepository;
-
-  /**
-   * @param TenantAwareThemeContextInterface $tenantAwareThemeContext
-   * @param ThemeLoaderInterface $themeLoader
-   * @param ThemeRepositoryInterface $themeRepository
-   */
-  public function __construct(TenantAwareThemeContextInterface $tenantAwareThemeContext,
-                              ThemeLoaderInterface             $themeLoader,
-                              ThemeRepositoryInterface         $themeRepository) {
+    /**
+     * Directory with assets inside theme.
+     */
+    const ASSETS_DIRECTORY = 'public';
+
+    private TenantAwareThemeContextInterface $tenantAwareThemeContext;
+    private ThemeLoaderInterface $themeLoader;
+    private ThemeRepositoryInterface $themeRepository;
+
+    /**
+     * @param TenantAwareThemeContextInterface $tenantAwareThemeContext
+     * @param ThemeLoaderInterface $themeLoader
+     * @param ThemeRepositoryInterface $themeRepository
+     */
+    public function __construct(TenantAwareThemeContextInterface $tenantAwareThemeContext,
+                                ThemeLoaderInterface             $themeLoader,
+                                ThemeRepositoryInterface         $themeRepository) {
     $this->tenantAwareThemeContext = $tenantAwareThemeContext;
     $this->themeLoader = $themeLoader;
     $this->themeRepository = $themeRepository;
-  }
+    }
 
 
-  /**
-   * @Route("/{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_root", requirements={"fileName": "sw|manifest|favicon|ads|OneSignalSDKWorker|OneSignalSDKUpdaterWorker|amp-web-push-helper-frame|amp-web-push-permission-dialog"})
-   * @Route("/public-{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_root_public", requirements={"fileName"=".+"})
-   * @Route("/public/{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_public", requirements={"fileName"=".+"})
-   */
-  public function rootAction($fileName, $fileExtension, ThemeHierarchyProviderInterface $themeHierarchyProvider) {
+    /**
+     * @Route("/{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_root", requirements={"fileName": "sw|manifest|favicon|ads|OneSignalSDKWorker|OneSignalSDKUpdaterWorker|amp-web-push-helper-frame|amp-web-push-permission-dialog"})
+     * @Route("/public-{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_root_public", requirements={"fileName"=".+"})
+     * @Route("/public/{fileName}.{fileExtension}", methods={"GET"}, name="static_theme_assets_public", requirements={"fileName"=".+"})
+     */
+    public function rootAction($fileName, $fileExtension, ThemeHierarchyProviderInterface $themeHierarchyProvider) {
     $themes = $themeHierarchyProvider->getThemeHierarchy(
         $this->tenantAwareThemeContext->getTheme()
     );
 
     $fileName = (null === $fileExtension) ? basename($fileName) : $fileName . '.' . $fileExtension;
     foreach ($themes as $theme) {
-      $filePath = $theme->getPath() . '/' . self::ASSETS_DIRECTORY . '/' . $fileName;
-      if (null !== $response = $this->handleFileLoading($filePath)) {
+        $filePath = $theme->getPath() . '/' . self::ASSETS_DIRECTORY . '/' . $fileName;
+        if (null !== $response = $this->handleFileLoading($filePath)) {
         return $response;
-      }
+        }
     }
 
     throw new NotFoundHttpException('File was not found.');
-  }
-
-  /**
-   * @Route("/themes/{type}/{themeName}/screenshots/{fileName}", methods={"GET"}, name="static_theme_screenshots", requirements={
-   *     "type": "organization|tenant"
-   * })
-   */
-  public function screenshotsAction(string $type, string $themeName, $fileName) {
+    }
+
+    /**
+     * @Route("/themes/{type}/{themeName}/screenshots/{fileName}", methods={"GET"}, name="static_theme_screenshots", requirements={
+     *     "type": "organization|tenant"
+     * })
+     */
+    public function screenshotsAction(string $type, string $themeName, $fileName) {
     if ('organization' === $type) {
-      $theme = $this->loadOrganizationTheme(str_replace('__', '/', $themeName));
+        $theme = $this->loadOrganizationTheme(str_replace('__', '/', $themeName));
     } elseif ('tenant' === $type) {
-      $theme = $this->loadTenantTheme(str_replace('__', '/', $themeName));
+        $theme = $this->loadTenantTheme(str_replace('__', '/', $themeName));
     } else {
-      throw new NotFoundHttpException('File was not found.');
+        throw new NotFoundHttpException('File was not found.');
     }
 
     $filePath = $theme->getPath() . '/screenshots/' . $fileName;
     if (null !== $response = $this->handleFileLoading($filePath)) {
-      return $response;
+        return $response;
     }
 
     throw new NotFoundHttpException('File was not found.');
-  }
-
-  /**
-   * @param $filePath
-   *
-   * @return Response
-   */
-  private function handleFileLoading($filePath) {
+    }
+
+    /**
+     * @param $filePath
+     *
+     * @return Response
+     */
+    private function handleFileLoading($filePath) {
     if (file_exists($filePath)) {
-      $response = new Response(file_get_contents($filePath));
-      $disposition = $response->headers->makeDisposition(
-          ResponseHeaderBag::DISPOSITION_INLINE,
-          basename($filePath)
-      );
-      $response->headers->set('Content-Disposition', $disposition);
-
-      try {
-          $mime = MimeTypeHelper::getByPath($filePath);
-      } catch (\Exception $e) {
+        $response = new Response(file_get_contents($filePath));
+        $disposition = $response->headers->makeDisposition(
+            ResponseHeaderBag::DISPOSITION_INLINE,
+            basename($filePath)
+        );
+        $response->headers->set('Content-Disposition', $disposition);
+
+        try {
+            $mime = MimeTypeHelper::getByPath($filePath);
+        } catch (\Exception $e) {
         $mime = 'text/plain';
-      }
+        }
 
-      $response->headers->set('Content-Type', $mime);
-      $response->setStatusCode(Response::HTTP_OK);
-      $response->setPublic();
-      $response->setMaxAge(3600);
-      $response->setSharedMaxAge(7200);
+        $response->headers->set('Content-Type', $mime);
+        $response->setStatusCode(Response::HTTP_OK);
+        $response->setPublic();
+        $response->setMaxAge(3600);
+        $response->setSharedMaxAge(7200);
 
-      return $response;
+        return $response;
+    }
     }
-  }
 
-  /**
-   * @return mixed
-   */
-  private function loadOrganizationTheme(string $themeName) {
+    /**
+     * @return mixed
+     */
+    private function loadOrganizationTheme(string $themeName) {
     $loadedThemes = $this->themeLoader->load();
 
     return $this->filterThemes($loadedThemes, $themeName);
-  }
+    }
 
-  /**
-   * @return mixed
-   */
-  private function loadTenantTheme(string $themeName) {
+    /**
+     * @return mixed
+     */
+    private function loadTenantTheme(string $themeName) {
     $loadedThemes = $this->themeRepository->findAll();
 
     return $this->filterThemes($loadedThemes, $themeName);
-  }
-
-  /**
-   * @param array $loadedThemes
-   *
-   * @return mixed
-   */
-  private function filterThemes($loadedThemes, string $themeName) {
+    }
+
+    /**
+     * @param array $loadedThemes
+     *
+     * @return mixed
+     */
+    private function filterThemes($loadedThemes, string $themeName) {
     $themes = array_filter(
         $loadedThemes,
         function ($element) use (&$themeName) {
-          return $element->getName() === $themeName;
+            return $element->getName() === $themeName;
         }
     );
 
     if (0 === count($themes)) {
-      throw new NotFoundHttpException(sprintf('Theme with name "%s" was not found in organization themes.', $themeName));
+        throw new NotFoundHttpException(sprintf('Theme with name "%s" was not found in organization themes.', $themeName));
     }
 
     return reset($themes);
-  }
+    }
 }

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

Indentation +33 added lines, -33 removed lines

@@ -29,50 +29,50 @@
 
 class ThemeLogoController extends Controller {
 
-  private Filesystem $filesystem;
-  private ThemeLogoUploaderInterface $themeLogoUploader;
-  private CacheInterface $cacheInterface;
+    private Filesystem $filesystem;
+    private ThemeLogoUploaderInterface $themeLogoUploader;
+    private CacheInterface $cacheInterface;
 
-  /**
-   * @param Filesystem $filesystem
-   * @param ThemeLogoUploaderInterface $themeLogoUploader
-   * @param CacheInterface $cacheInterface
-   */
-  public function __construct(Filesystem     $filesystem, ThemeLogoUploaderInterface $themeLogoUploader,
-                              CacheInterface $cacheInterface) {
+    /**
+     * @param Filesystem $filesystem
+     * @param ThemeLogoUploaderInterface $themeLogoUploader
+     * @param CacheInterface $cacheInterface
+     */
+    public function __construct(Filesystem     $filesystem, ThemeLogoUploaderInterface $themeLogoUploader,
+                                CacheInterface $cacheInterface) {
     $this->filesystem = $filesystem;
     $this->themeLogoUploader = $themeLogoUploader;
     $this->cacheInterface = $cacheInterface;
-  }
+    }
 
-  /**
-   * @Route("/theme_logo/{id}", options={"expose"=true}, requirements={"id"=".+"}, methods={"GET"}, name="swp_theme_logo_get")
-   */
-  public function getLogoAction(string $id) {
+    /**
+     * @Route("/theme_logo/{id}", options={"expose"=true}, requirements={"id"=".+"}, methods={"GET"}, name="swp_theme_logo_get")
+     */
+    public function getLogoAction(string $id) {
     $cacheKey = md5(serialize(['upload', $id]));
     return $this->cacheInterface->get($cacheKey, function (CacheItemInterface $item, &$save) use ($id) {
-      $item->expiresAfter(63072000);
+        $item->expiresAfter(63072000);
 
-      $fileSystem = $this->filesystem;
-      $themeLogoUploader = $this->themeLogoUploader;
-      $id = $themeLogoUploader->getThemeLogoUploadPath($id);
-      $file = $fileSystem->has($id);
-      if (!$file) {
+        $fileSystem = $this->filesystem;
+        $themeLogoUploader = $this->themeLogoUploader;
+        $id = $themeLogoUploader->getThemeLogoUploadPath($id);
+        $file = $fileSystem->has($id);
+        if (!$file) {
         $save = false;
         throw new NotFoundHttpException('File was not found.');
-      }
+        }
 
-      $path = $fileSystem->get($id)->getPath();
-      $response = new Response();
-      $disposition = $response->headers->makeDisposition(ResponseHeaderBag::DISPOSITION_INLINE, pathinfo($path, PATHINFO_BASENAME));
-      $response->headers->set('Content-Disposition', $disposition);
-      $response->headers->set('Content-Type', MimeTypeHelper::getByPath($path));
-      $response->setPublic();
-      $response->setMaxAge(63072000);
-      $response->setSharedMaxAge(63072000);
-      $response->setContent($fileSystem->read($path));
+        $path = $fileSystem->get($id)->getPath();
+        $response = new Response();
+        $disposition = $response->headers->makeDisposition(ResponseHeaderBag::DISPOSITION_INLINE, pathinfo($path, PATHINFO_BASENAME));
+        $response->headers->set('Content-Disposition', $disposition);
+        $response->headers->set('Content-Type', MimeTypeHelper::getByPath($path));
+        $response->setPublic();
+        $response->setMaxAge(63072000);
+        $response->setSharedMaxAge(63072000);
+        $response->setContent($fileSystem->read($path));
 
-      return $response;
+        return $response;
     });
-  }
+    }
 }

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.']
     );
-  }
+    }
 }

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/Controller/SeoMetadataController.php

Indentation +50 added lines, -50 removed lines

@@ -20,10 +20,10 @@ 
 use FOS\RestBundle\Controller\Annotations\Route;
 
 class SeoMetadataController extends AbstractController {
-  private FormFactoryInterface $formFactory;
-  private FactoryInterface $seoMetadataFactory;
-  private RepositoryInterface $seoMetadataRepository;
-  private EventDispatcherInterface $eventDispatcher;
+    private FormFactoryInterface $formFactory;
+    private FactoryInterface $seoMetadataFactory;
+    private RepositoryInterface $seoMetadataRepository;
+    private EventDispatcherInterface $eventDispatcher;
     protected MediaManagerInterface $mediaManager;
 
     /**
@@ -33,29 +33,29 @@ 
      * @param EventDispatcherInterface $eventDispatcher
      * @param MediaManagerInterface $mediaManager
      */
-  public function __construct(
-      FormFactoryInterface $formFactory,
-      FactoryInterface $seoMetadataFactory,
-      RepositoryInterface  $seoMetadataRepository,
-      EventDispatcherInterface $eventDispatcher,
-      MediaManagerInterface $mediaManager
-  ) {
+    public function __construct(
+        FormFactoryInterface $formFactory,
+        FactoryInterface $seoMetadataFactory,
+        RepositoryInterface  $seoMetadataRepository,
+        EventDispatcherInterface $eventDispatcher,
+        MediaManagerInterface $mediaManager
+    ) {
     $this->formFactory = $formFactory;
     $this->seoMetadataFactory = $seoMetadataFactory;
     $this->seoMetadataRepository = $seoMetadataRepository;
     $this->eventDispatcher = $eventDispatcher;
-      $this->mediaManager = $mediaManager;
-  }
+        $this->mediaManager = $mediaManager;
+    }
 
-  /**
-   * @Route("/api/{version}/packages/seo/{packageGuid}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PUT"}, name="swp_api_core_seo_metadata_put")
-   */
-  public function put(Request $request, string $packageGuid): SingleResourceResponse {
+    /**
+     * @Route("/api/{version}/packages/seo/{packageGuid}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PUT"}, name="swp_api_core_seo_metadata_put")
+     */
+    public function put(Request $request, string $packageGuid): SingleResourceResponse {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
 
     $seoMetadata = $this->seoMetadataRepository->findOneByPackageGuid($packageGuid);
     if (null === $seoMetadata) {
-      $seoMetadata = $this->seoMetadataFactory->create();
+        $seoMetadata = $this->seoMetadataFactory->create();
     }
 
     $form = $this->formFactory->createNamed('', SeoMetadataType::class, $seoMetadata, ['method' => $request->getMethod()]);
@@ -63,48 +63,48 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $seoMetadata->setPackageGuid($packageGuid);
-      $this->seoMetadataRepository->add($seoMetadata);
+        $seoMetadata->setPackageGuid($packageGuid);
+        $this->seoMetadataRepository->add($seoMetadata);
 
-      return new SingleResourceResponse($seoMetadata, new ResponseContext(200));
+        return new SingleResourceResponse($seoMetadata, new ResponseContext(200));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/seo/{packageGuid}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_seo_metadata_get")
-   */
-  public function getAction(string $packageGuid): SingleResourceResponse {
+    /**
+     * @Route("/api/{version}/packages/seo/{packageGuid}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_seo_metadata_get")
+     */
+    public function getAction(string $packageGuid): SingleResourceResponse {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
 
-      $seoMetadata = $this->seoMetadataRepository->findOneByPackageGuid($packageGuid);
+        $seoMetadata = $this->seoMetadataRepository->findOneByPackageGuid($packageGuid);
     if (null === $seoMetadata) {
-      throw new NotFoundHttpException('SEO metadata not found!');
+        throw new NotFoundHttpException('SEO metadata not found!');
     }
 
-      $response = [
-          "meta_title" => $seoMetadata->getMetaTitle(),
-          "meta_description" => $seoMetadata->getMetaDescription(),
-          "og_title" => $seoMetadata->getOgTitle(),
-          "og_description" => $seoMetadata->getOgDescription(),
-          "twitter_title" => $seoMetadata->getTwitterTitle(),
-          "twitter_description" => $seoMetadata->getTwitterDescription(),
-      ];
-
-      if ($seoMetadata->getMetaMedia()) {
-          $metaImage = $seoMetadata->getMetaMedia()->getImage();
-          $response['_links']['meta_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
-      }
-      if ($seoMetadata->getOgMedia()) {
-          $metaImage = $seoMetadata->getOgMedia()->getImage();
-          $response['_links']['og_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
-      }
-      if ($seoMetadata->getTwitterMedia()) {
-          $metaImage = $seoMetadata->getTwitterMedia()->getImage();
-          $response['_links']['twitter_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
-      }
+        $response = [
+            "meta_title" => $seoMetadata->getMetaTitle(),
+            "meta_description" => $seoMetadata->getMetaDescription(),
+            "og_title" => $seoMetadata->getOgTitle(),
+            "og_description" => $seoMetadata->getOgDescription(),
+            "twitter_title" => $seoMetadata->getTwitterTitle(),
+            "twitter_description" => $seoMetadata->getTwitterDescription(),
+        ];
+
+        if ($seoMetadata->getMetaMedia()) {
+            $metaImage = $seoMetadata->getMetaMedia()->getImage();
+            $response['_links']['meta_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
+        }
+        if ($seoMetadata->getOgMedia()) {
+            $metaImage = $seoMetadata->getOgMedia()->getImage();
+            $response['_links']['og_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
+        }
+        if ($seoMetadata->getTwitterMedia()) {
+            $metaImage = $seoMetadata->getTwitterMedia()->getImage();
+            $response['_links']['twitter_media_url'] = [ 'href' => $this->mediaManager->getMediaPublicUrl($metaImage)];
+        }
 
     return new SingleResourceResponse($response, new ResponseContext(200));
-  }
+    }
 }

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

Indentation +154 added lines, -154 removed lines

@@ -44,36 +44,36 @@ 
 
 class ContentListController extends AbstractController {
 
-  private ContentListRepositoryInterface $contentListRepository;
-  private ContentListItemRepositoryInterface $contentListItemRepository;
-  private ContentListServiceInterface $contentListService;
-  private FormFactoryInterface $formFactory;
-  private EntityManagerInterface $entityManager;
-  private EventDispatcherInterface $eventDispatcher;
-  private FactoryInterface $factory;
-  private string $invalidationCacheUrl;
-  private string $invalidationToken;
-
-  /**
-   * @param ContentListRepositoryInterface $contentListRepository
-   * @param ContentListItemRepositoryInterface $contentListItemRepository
-   * @param ContentListServiceInterface $contentListService
-   * @param FormFactoryInterface $formFactory
-   * @param EntityManagerInterface $entityManager
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param FactoryInterface $factory
-   */
-  public function __construct(
-      ContentListRepositoryInterface     $contentListRepository,
-      ContentListItemRepositoryInterface $contentListItemRepository,
-      ContentListServiceInterface        $contentListService,
-      FormFactoryInterface               $formFactory,
-      EntityManagerInterface             $entityManager,
-      EventDispatcherInterface           $eventDispatcher,
-      FactoryInterface                   $factory,
-      string $invalidationCacheUrl,
-      string $invalidationToken
-  ) {
+    private ContentListRepositoryInterface $contentListRepository;
+    private ContentListItemRepositoryInterface $contentListItemRepository;
+    private ContentListServiceInterface $contentListService;
+    private FormFactoryInterface $formFactory;
+    private EntityManagerInterface $entityManager;
+    private EventDispatcherInterface $eventDispatcher;
+    private FactoryInterface $factory;
+    private string $invalidationCacheUrl;
+    private string $invalidationToken;
+
+    /**
+     * @param ContentListRepositoryInterface $contentListRepository
+     * @param ContentListItemRepositoryInterface $contentListItemRepository
+     * @param ContentListServiceInterface $contentListService
+     * @param FormFactoryInterface $formFactory
+     * @param EntityManagerInterface $entityManager
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param FactoryInterface $factory
+     */
+    public function __construct(
+        ContentListRepositoryInterface     $contentListRepository,
+        ContentListItemRepositoryInterface $contentListItemRepository,
+        ContentListServiceInterface        $contentListService,
+        FormFactoryInterface               $formFactory,
+        EntityManagerInterface             $entityManager,
+        EventDispatcherInterface           $eventDispatcher,
+        FactoryInterface                   $factory,
+        string $invalidationCacheUrl,
+        string $invalidationToken
+    ) {
     $this->contentListRepository = $contentListRepository;
     $this->contentListItemRepository = $contentListItemRepository;
     $this->contentListService = $contentListService;
@@ -83,65 +83,65 @@ 
     $this->factory = $factory;
     $this->invalidationCacheUrl = $invalidationCacheUrl;
     $this->invalidationToken = $invalidationToken;
-  }
-
-  public static function invalidateCache(string $url, string $token, array $data = [])
-  {
-      try {
-          $client = new Client();
-
-          $headers = [
-              'Content-Type' => 'application/json',
-          ];
-          $queryParams = [
-              'secret' => $token,
-          ];
-
-          $response = $client->request('POST', $url,  [
-              'headers' => $headers,
-              'json' => $data,
-              'query' => $queryParams
-          ]);
-          $responseBody = $response->getBody()->getContents();
-          $result = [
-              'request' => [
-                  'headers' => $headers,
-                  'json' => $data,
-                  'query' => $queryParams
-              ],
-              'response' => [
-                  'status' => $response->getStatusCode(),
-                  'body' => $responseBody,
-                  'ReasonPhrase' => $response->getReasonPhrase()
-              ]
-          ];
-
-          file_put_contents('/tmp/cache_invalidation.json', json_encode($result) . PHP_EOL, FILE_APPEND);
-      } catch (\Throwable $e) {
-          file_put_contents('/tmp/cache_invalidation_errors.json', $e->getMessage() . PHP_EOL, FILE_APPEND);
-      }
-  }
-
-  /**
-   * @Route("/api/{version}/content/lists/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_content_list_lists")
-   */
-  public function listAction(Request $request): ResourcesListResponseInterface {
+    }
+
+    public static function invalidateCache(string $url, string $token, array $data = [])
+    {
+        try {
+            $client = new Client();
+
+            $headers = [
+                'Content-Type' => 'application/json',
+            ];
+            $queryParams = [
+                'secret' => $token,
+            ];
+
+            $response = $client->request('POST', $url,  [
+                'headers' => $headers,
+                'json' => $data,
+                'query' => $queryParams
+            ]);
+            $responseBody = $response->getBody()->getContents();
+            $result = [
+                'request' => [
+                    'headers' => $headers,
+                    'json' => $data,
+                    'query' => $queryParams
+                ],
+                'response' => [
+                    'status' => $response->getStatusCode(),
+                    'body' => $responseBody,
+                    'ReasonPhrase' => $response->getReasonPhrase()
+                ]
+            ];
+
+            file_put_contents('/tmp/cache_invalidation.json', json_encode($result) . PHP_EOL, FILE_APPEND);
+        } catch (\Throwable $e) {
+            file_put_contents('/tmp/cache_invalidation_errors.json', $e->getMessage() . PHP_EOL, FILE_APPEND);
+        }
+    }
+
+    /**
+     * @Route("/api/{version}/content/lists/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_content_list_lists")
+     */
+    public function listAction(Request $request): ResourcesListResponseInterface {
     $lists = $this->contentListRepository->getPaginatedByCriteria($this->eventDispatcher, new Criteria(), $request->query->all('sorting'), new PaginationData($request));
 
     return new ResourcesListResponse($lists);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_content_show_lists", requirements={"id"="\d+"})
-   */
-  public function getAction($id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_content_show_lists", requirements={"id"="\d+"})
+     */
+    public function getAction($id): SingleResourceResponseInterface {
     return new SingleResourceResponse($this->findOr404($id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_content_create_lists")
-   */
-  public function createAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_content_create_lists")
+     */
+    public function createAction(Request $request): SingleResourceResponseInterface {
     /* @var ContentListInterface $contentList */
     $contentList = $this->factory->create();
     $form = $this->formFactory->createNamed('', ContentListType::class, $contentList, ['method' => $request->getMethod()]);
@@ -150,28 +150,28 @@ 
     $this->ensureContentListExists($contentList->getName());
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->contentListRepository->add($contentList);
-      self::invalidateCache(
-          $this->invalidationCacheUrl,
-          $this->invalidationToken,
-          [
-              'id' => $contentList->getId(),
-              'name' => $contentList->getName(),
-              'type' => $contentList->getType(),
-              'action' => 'CREATE'
-          ]
+        $this->contentListRepository->add($contentList);
+        self::invalidateCache(
+            $this->invalidationCacheUrl,
+            $this->invalidationToken,
+            [
+                'id' => $contentList->getId(),
+                'name' => $contentList->getName(),
+                'type' => $contentList->getType(),
+                'action' => 'CREATE'
+            ]
         );
 
-      return new SingleResourceResponse($contentList, new ResponseContext(201));
+        return new SingleResourceResponse($contentList, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_content_update_lists", requirements={"id"="\d+"})
-   */
-  public function updateAction(Request $request, int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_content_update_lists", requirements={"id"="\d+"})
+     */
+    public function updateAction(Request $request, int $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     /** @var ContentListInterface $contentList */
     $contentList = $this->findOr404($id);
@@ -182,12 +182,12 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->eventDispatcher->dispatch(
-          new GenericEvent($contentList, ['filters' => $filters, 'previousLimit' => $listLimit]),
-          ContentListEvents::LIST_CRITERIA_CHANGE
-      );
+        $this->eventDispatcher->dispatch(
+            new GenericEvent($contentList, ['filters' => $filters, 'previousLimit' => $listLimit]),
+            ContentListEvents::LIST_CRITERIA_CHANGE
+        );
 
-      $objectManager->flush();
+        $objectManager->flush();
         self::invalidateCache(
             $this->invalidationCacheUrl,
             $this->invalidationToken,
@@ -199,54 +199,54 @@ 
             ]
         );
 
-      return new SingleResourceResponse($contentList);
+        return new SingleResourceResponse($contentList);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"DELETE"}, name="swp_api_content_delete_lists", requirements={"id"="\d+"})
-   */
-  public function deleteAction($id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"DELETE"}, name="swp_api_content_delete_lists", requirements={"id"="\d+"})
+     */
+    public function deleteAction($id): SingleResourceResponseInterface {
     $repository = $this->contentListRepository;
     $contentList = $this->findOr404($id);
 
     $repository->remove($contentList);
-      self::invalidateCache(
-          $this->invalidationCacheUrl,
-          $this->invalidationToken,
-          [
-              'id' => $contentList->getId(),
-              'name' => $contentList->getName(),
-              'type' => $contentList->getType(),
-              'action' => 'DELETE'
-          ]
-      );
+        self::invalidateCache(
+            $this->invalidationCacheUrl,
+            $this->invalidationToken,
+            [
+                'id' => $contentList->getId(),
+                'name' => $contentList->getName(),
+                'type' => $contentList->getType(),
+                'action' => 'DELETE'
+            ]
+        );
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{id}", requirements={"id"="\w+"}, defaults={"version"="v2"}, methods={"LINK","UNLINK"}, name="swp_api_content_list_link_unlink")
-   */
-  public function linkUnlinkToContentListAction(Request $request, string $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/{id}", requirements={"id"="\w+"}, defaults={"version"="v2"}, methods={"LINK","UNLINK"}, name="swp_api_content_list_link_unlink")
+     */
+    public function linkUnlinkToContentListAction(Request $request, string $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     /** @var ContentListInterface $contentList */
     $contentList = $this->findOr404($id);
 
     $matched = false;
     foreach ($request->attributes->get('links', []) as $key => $objectArray) {
-      if (!is_array($objectArray)) {
+        if (!is_array($objectArray)) {
         continue;
-      }
+        }
 
-      $object = $objectArray['object'];
-      if ($object instanceof Exception) {
+        $object = $objectArray['object'];
+        if ($object instanceof Exception) {
         throw $object;
-      }
+        }
 
-      if ($object instanceof ArticleInterface) {
+        if ($object instanceof ArticleInterface) {
         $contentListItem = $this->contentListItemRepository
             ->findOneBy([
                 'contentList' => $contentList,
@@ -254,59 +254,59 @@ 
             ]);
 
         if ('LINK' === $request->getMethod()) {
-          $position = 0;
-          if (count($notConvertedLinks = RequestParser::getNotConvertedLinks($request->attributes->get('links'))) > 0) {
+            $position = 0;
+            if (count($notConvertedLinks = RequestParser::getNotConvertedLinks($request->attributes->get('links'))) > 0) {
             foreach ($notConvertedLinks as $link) {
-              if (isset($link['resourceType']) && 'position' === $link['resourceType']) {
+                if (isset($link['resourceType']) && 'position' === $link['resourceType']) {
                 $position = $link['resource'];
-              }
+                }
+            }
             }
-          }
 
-          if (false === $position && $contentListItem) {
+            if (false === $position && $contentListItem) {
             throw new ConflictHttpException('This content is already linked to Content List');
-          }
+            }
 
-          if (!$contentListItem) {
+            if (!$contentListItem) {
             $contentListItem = $this->contentListService->addArticleToContentList($contentList, $object, $position);
             $objectManager->persist($contentListItem);
-          } else {
+            } else {
             $contentListItem->setPosition($position);
-          }
+            }
 
-          $objectManager->flush();
+            $objectManager->flush();
         } elseif ('UNLINK' === $request->getMethod()) {
-          if ($contentListItem->getContentList() !== $contentList) {
+            if ($contentListItem->getContentList() !== $contentList) {
             throw new ConflictHttpException('Content is not linked to content list');
-          }
-          $objectManager->remove($contentListItem);
+            }
+            $objectManager->remove($contentListItem);
         }
 
         $matched = true;
 
         break;
-      }
+        }
     }
     if (false === $matched) {
-      throw new NotFoundHttpException('Any supported link object was not found');
+        throw new NotFoundHttpException('Any supported link object was not found');
     }
 
     $objectManager->flush();
 
     return new SingleResourceResponse($contentList, new ResponseContext(201));
-  }
+    }
 
-  private function findOr404($id) {
+    private function findOr404($id) {
     if (null === $list = $this->contentListRepository->find($id)) {
-      throw new NotFoundHttpException(sprintf('Content list with id "%s" was not found.', $id));
+        throw new NotFoundHttpException(sprintf('Content list with id "%s" was not found.', $id));
     }
 
     return $list;
-  }
+    }
 
-  private function ensureContentListExists($name) {
+    private function ensureContentListExists($name) {
     if (null !== $this->contentListRepository->findOneBy(['name' => $name])) {
-      throw new ConflictHttpException(sprintf('Content list named "%s" already exists!', $name));
+        throw new ConflictHttpException(sprintf('Content list named "%s" already exists!', $name));
+    }
     }
-  }
 }

src/SWP/Bundle/ContentBundle/Controller/ArticleController.php

Indentation +63 added lines, -63 removed lines

@@ -36,27 +36,27 @@ 
 
 class ArticleController extends AbstractController {
 
-  private FormFactoryInterface $formFactory;
-  private RouteProviderInterface $routeProvider; // swp.provider.route
-  private ArticleRepositoryInterface $articleRepository; //swp.repository.article
-  private ArticleProviderInterface $articleProvider; //swp.provider.article
-  private EventDispatcherInterface  $eventDispatcher;
-  private EntityManagerInterface $entityManager; // swp.object_manager.article
-  private ArticleServiceInterface $articleService; // swp.service.article
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param RouteProviderInterface $routeProvider
-   * @param ArticleRepositoryInterface $articleRepository
-   * @param ArticleProviderInterface $articleProvider
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param EntityManagerInterface $entityManager
-   * @param ArticleServiceInterface $articleService
-   */
-  public function __construct(FormFactoryInterface       $formFactory, RouteProviderInterface $routeProvider,
-                              ArticleRepositoryInterface $articleRepository, ArticleProviderInterface $articleProvider,
-                              EventDispatcherInterface   $eventDispatcher, EntityManagerInterface $entityManager,
-                              ArticleServiceInterface    $articleService) {
+    private FormFactoryInterface $formFactory;
+    private RouteProviderInterface $routeProvider; // swp.provider.route
+    private ArticleRepositoryInterface $articleRepository; //swp.repository.article
+    private ArticleProviderInterface $articleProvider; //swp.provider.article
+    private EventDispatcherInterface  $eventDispatcher;
+    private EntityManagerInterface $entityManager; // swp.object_manager.article
+    private ArticleServiceInterface $articleService; // swp.service.article
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param RouteProviderInterface $routeProvider
+     * @param ArticleRepositoryInterface $articleRepository
+     * @param ArticleProviderInterface $articleProvider
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param EntityManagerInterface $entityManager
+     * @param ArticleServiceInterface $articleService
+     */
+    public function __construct(FormFactoryInterface       $formFactory, RouteProviderInterface $routeProvider,
+                                ArticleRepositoryInterface $articleRepository, ArticleProviderInterface $articleProvider,
+                                EventDispatcherInterface   $eventDispatcher, EntityManagerInterface $entityManager,
+                                ArticleServiceInterface    $articleService) {
     $this->formFactory = $formFactory;
     $this->routeProvider = $routeProvider;
     $this->articleRepository = $articleRepository;
@@ -64,30 +64,30 @@ 
     $this->eventDispatcher = $eventDispatcher;
     $this->entityManager = $entityManager;
     $this->articleService = $articleService;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/content/articles/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_list_articles")
-   *
-   * @throws \Exception
-   */
-  public function listAction(Request $request): ResourcesListResponseInterface {
+    /**
+     * @Route("/api/{version}/content/articles/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_list_articles")
+     *
+     * @throws \Exception
+     */
+    public function listAction(Request $request): ResourcesListResponseInterface {
     $authors = '';
     if (null !== $request->query->get('author', null)) {
-      $authors = explode(', ', $request->query->get('author'));
+        $authors = explode(', ', $request->query->get('author'));
     }
 
     if ($request->query->get('route', false) && $request->query->get('includeSubRoutes', false)) {
-      $routeObject = $this->routeProvider->getOneById($request->query->get('route'));
+        $routeObject = $this->routeProvider->getOneById($request->query->get('route'));
 
-      if (null !== $routeObject) {
+        if (null !== $routeObject) {
         $ids = [$routeObject->getId()];
         foreach ($routeObject->getChildren() as $child) {
-          $ids[] = $child->getId();
+            $ids[] = $child->getId();
         }
         $request->query->set('route', $ids);
-      }
+        }
     }
 
     $articles = $this->articleRepository
@@ -102,25 +102,25 @@ 
         ]), $request->query->all('sorting'), new PaginationData($request));
 
     return new ResourcesListResponse($articles);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/articles/{id}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_articles", requirements={"id"=".+"})
-   */
-  public function getAction($id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/articles/{id}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_articles", requirements={"id"=".+"})
+     */
+    public function getAction($id): SingleResourceResponseInterface {
     $article = $this->articleProvider->getOneById($id);
 
     if (null === $article) {
-      throw new NotFoundHttpException('Article was not found');
+        throw new NotFoundHttpException('Article was not found');
     }
 
     return new SingleResourceResponse($article);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/article/search-code", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_articles_by_code", requirements={"code"=".+"})
-   */
-  public function getByCodeAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/article/search-code", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_articles_by_code", requirements={"code"=".+"})
+     */
+    public function getByCodeAction(Request $request): SingleResourceResponseInterface {
     // Extract parameters from the request
     $code = $request->query->get('code', '');
     //$tenantCode = $request->query->get('tenant_code', '');
@@ -134,16 +134,16 @@ 
         ->getOneOrNullResult();
 
     if (null === $article) {
-      throw new NotFoundHttpException('Article was not found');
+        throw new NotFoundHttpException('Article was not found');
     }
 
     return new SingleResourceResponse($article);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/articles/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_update_articles", requirements={"id"=".+"})
-   */
-  public function updateAction(Request $request, $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/articles/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_update_articles", requirements={"id"=".+"})
+     */
+    public function updateAction(Request $request, $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     $article = $this->findOr404($id);
     $originalArticleStatus = $article->getStatus();
@@ -152,32 +152,32 @@ 
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->articleService->reactOnStatusChange($originalArticleStatus, $article);
-      $objectManager->flush();
-      $objectManager->refresh($article);
+        $this->articleService->reactOnStatusChange($originalArticleStatus, $article);
+        $objectManager->flush();
+        $objectManager->refresh($article);
 
-      return new SingleResourceResponse($article);
+        return new SingleResourceResponse($article);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(500));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/articles/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_delete_articles", requirements={"id"=".+"})
-   */
-  public function deleteAction($id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/articles/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_delete_articles", requirements={"id"=".+"})
+     */
+    public function deleteAction($id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     $objectManager->remove($this->findOr404($id));
     $objectManager->flush();
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  private function findOr404($id) {
+    private function findOr404($id) {
     if (null === $article = $this->articleProvider->getOneById($id)) {
-      throw new NotFoundHttpException('Article was not found.');
+        throw new NotFoundHttpException('Article was not found.');
     }
 
     return $article;
-  }
+    }
 }

src/SWP/Bundle/ContentBundle/Controller/ContentPushController.php

Indentation +47 added lines, -47 removed lines

@@ -42,15 +42,15 @@ 
 use FOS\RestBundle\Controller\Annotations\Route;
 
 class ContentPushController extends AbstractController {
-  private EventDispatcherInterface $eventDispatcher;
-  private FormFactoryInterface $formFactory;
-  private MessageBusInterface $messageBus;//swp_multi_tenancy.tenant_context
-  private DataTransformerInterface $dataTransformer; // swp_bridge.transformer.json_to_package
-  private MediaManagerInterface $mediaManager; // swp_content_bundle.manager.media
-  private EntityManagerInterface $entityManager; // swp.object_manager.media
-  private PackageRepository $packageRepository;//swp.repository.package
-  private  ArticleRepositoryInterface $articleRepository;//swp.repository.article
-  private FileProviderInterface $fileProvider;
+    private EventDispatcherInterface $eventDispatcher;
+    private FormFactoryInterface $formFactory;
+    private MessageBusInterface $messageBus;//swp_multi_tenancy.tenant_context
+    private DataTransformerInterface $dataTransformer; // swp_bridge.transformer.json_to_package
+    private MediaManagerInterface $mediaManager; // swp_content_bundle.manager.media
+    private EntityManagerInterface $entityManager; // swp.object_manager.media
+    private PackageRepository $packageRepository;//swp.repository.package
+    private  ArticleRepositoryInterface $articleRepository;//swp.repository.article
+    private FileProviderInterface $fileProvider;
 
     /**
      * @param EventDispatcherInterface $eventDispatcher
@@ -63,17 +63,17 @@ 
      * @param ArticleRepositoryInterface $articleRepository
      * @param FileProviderInterface $fileProvider
      */
-  public function __construct(
-      EventDispatcherInterface $eventDispatcher,
-      FormFactoryInterface $formFactory,
-      MessageBusInterface $messageBus,
-      DataTransformerInterface $dataTransformer,
-      MediaManagerInterface $mediaManager,
-      EntityManagerInterface $entityManager,
-      PackageRepository $packageRepository,
-      ArticleRepositoryInterface $articleRepository,
-      FileProviderInterface    $fileProvider
-  ) {
+    public function __construct(
+        EventDispatcherInterface $eventDispatcher,
+        FormFactoryInterface $formFactory,
+        MessageBusInterface $messageBus,
+        DataTransformerInterface $dataTransformer,
+        MediaManagerInterface $mediaManager,
+        EntityManagerInterface $entityManager,
+        PackageRepository $packageRepository,
+        ArticleRepositoryInterface $articleRepository,
+        FileProviderInterface    $fileProvider
+    ) {
     $this->eventDispatcher = $eventDispatcher;
     $this->formFactory = $formFactory;
     $this->messageBus = $messageBus;
@@ -83,13 +83,13 @@ 
     $this->packageRepository = $packageRepository;
     $this->articleRepository = $articleRepository;
     $this->fileProvider = $fileProvider;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/content/push", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_push")
-   */
-  public function pushContentAction(Request $request, TenantContextInterface $tenantContext): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/push", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_push")
+     */
+    public function pushContentAction(Request $request, TenantContextInterface $tenantContext): SingleResourceResponseInterface {
     $package = $this->dataTransformer->transform($request->getContent());
     $this->eventDispatcher->dispatch(new GenericEvent($package), Events::SWP_VALIDATION);
 
@@ -100,7 +100,7 @@ 
     );
 
     return new SingleResourceResponse(['status' => 'OK'], new ResponseContext(201));
-  }
+    }
 
 
     /**
@@ -128,25 +128,25 @@ 
         return new SingleResourceResponse(['status' => 'OK'], new ResponseContext(201));
     }
 
-  /**
-   * @Route("/api/{version}/assets/push", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_assets_push")
-   */
-  public function pushAssetsAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/assets/push", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_assets_push")
+     */
+    public function pushAssetsAction(Request $request): SingleResourceResponseInterface {
     $form = $this->formFactory->createNamed('', MediaFileType::class);
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $mediaManager = $this->mediaManager;
-      $uploadedFile = $form->getData()['media'];
-      $mediaId = $request->request->get('mediaId');
+        $mediaManager = $this->mediaManager;
+        $uploadedFile = $form->getData()['media'];
+        $mediaId = $request->request->get('mediaId');
 
-      if ($uploadedFile->isValid()) {
+        if ($uploadedFile->isValid()) {
         $fileProvider = $this->fileProvider;
         $file = $fileProvider->getFile(ArticleMedia::handleMediaId($mediaId), $uploadedFile->guessExtension());
 
         if (null === $file) {
-          $file = $mediaManager->handleUploadedFile($uploadedFile, $mediaId);
-          $this->entityManager->flush();
+            $file = $mediaManager->handleUploadedFile($uploadedFile, $mediaId);
+            $this->entityManager->flush();
         }
 
         return new SingleResourceResponse(
@@ -159,23 +159,23 @@ 
             ],
             new ResponseContext(201)
         );
-      }
+        }
 
-      throw new \Exception('Uploaded file is not valid:' . $uploadedFile->getErrorMessage());
+        throw new \Exception('Uploaded file is not valid:' . $uploadedFile->getErrorMessage());
     }
 
     return new SingleResourceResponse($form);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/assets/{action}/{mediaId}.{extension}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, requirements={"mediaId"=".+", "action"="get|push"}, name="swp_api_assets_get")
-   */
-  public function getAssetsAction(string $mediaId, string $extension): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/assets/{action}/{mediaId}.{extension}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, requirements={"mediaId"=".+", "action"="get|push"}, name="swp_api_assets_get")
+     */
+    public function getAssetsAction(string $mediaId, string $extension): SingleResourceResponseInterface {
     $fileProvider = $this->fileProvider;
     $file = $fileProvider->getFile(ArticleMedia::handleMediaId($mediaId), $extension);
 
     if (null === $file) {
-      throw new NotFoundHttpException('Media don\'t exist in storage');
+        throw new NotFoundHttpException('Media don\'t exist in storage');
     }
 
     $mediaManager = $this->mediaManager;
@@ -187,9 +187,9 @@ 
         'mime_type' => MimeTypeHelper::getByExtension($file->getFileExtension()),
         'filemeta' => [],
     ]);
-  }
+    }
 
-  protected function getPackageRepository() {
+    protected function getPackageRepository() {
     return $this->packageRepository;
-  }
+    }
 }

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

Indentation +104 added lines, -104 removed lines

@@ -45,41 +45,41 @@ 
 use FOS\RestBundle\Controller\Annotations\Route;
 
 class ContentListItemController extends AbstractController {
-  private ContentListItemRepositoryInterface $contentListItemRepository;
-  private EntityManagerInterface $entityManager;
-  private ContentListServiceInterface $contentListService;
-  private EventDispatcherInterface $eventDispatcher;
-
-  /**
-   * @param ContentListItemRepositoryInterface $contentListItemRepository
-   * @param EntityManagerInterface $entityManager
-   * @param ContentListServiceInterface $contentListService
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(
-      ContentListItemRepositoryInterface $contentListItemRepository,
-      EntityManagerInterface $entityManager,
-      ContentListServiceInterface $contentListService,
-      EventDispatcherInterface $eventDispatcher,
-      string $invalidationCacheUrl,
-      string $invalidationToken
-  ) {
-      $this->contentListItemRepository = $contentListItemRepository;
-      $this->entityManager = $entityManager;
-      $this->contentListService = $contentListService;
-      $this->eventDispatcher = $eventDispatcher;
-      $this->invalidationCacheUrl = $invalidationCacheUrl;
-      $this->invalidationToken = $invalidationToken;
-  }
-
-
-  /**
-   * @Route("/api/{version}/content/lists/{id}/items/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_items", requirements={"id"="\d+"})
-   */
-  public function listAction(Request $request, int $id): ResourcesListResponseInterface {
+    private ContentListItemRepositoryInterface $contentListItemRepository;
+    private EntityManagerInterface $entityManager;
+    private ContentListServiceInterface $contentListService;
+    private EventDispatcherInterface $eventDispatcher;
+
+    /**
+     * @param ContentListItemRepositoryInterface $contentListItemRepository
+     * @param EntityManagerInterface $entityManager
+     * @param ContentListServiceInterface $contentListService
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(
+        ContentListItemRepositoryInterface $contentListItemRepository,
+        EntityManagerInterface $entityManager,
+        ContentListServiceInterface $contentListService,
+        EventDispatcherInterface $eventDispatcher,
+        string $invalidationCacheUrl,
+        string $invalidationToken
+    ) {
+        $this->contentListItemRepository = $contentListItemRepository;
+        $this->entityManager = $entityManager;
+        $this->contentListService = $contentListService;
+        $this->eventDispatcher = $eventDispatcher;
+        $this->invalidationCacheUrl = $invalidationCacheUrl;
+        $this->invalidationToken = $invalidationToken;
+    }
+
+
+    /**
+     * @Route("/api/{version}/content/lists/{id}/items/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_items", requirements={"id"="\d+"})
+     */
+    public function listAction(Request $request, int $id): ResourcesListResponseInterface {
     $sort = $request->query->all('sorting');
     if (empty($sort)) {
-      $sort = ['sticky' => 'desc'];
+        $sort = ['sticky' => 'desc'];
     }
 
     $items = $this->contentListItemRepository->getPaginatedByCriteria(
@@ -112,20 +112,20 @@ 
     );
 
     return new ResourcesListResponse($items, $responseContext);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{listId}/items/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_show_lists_item", requirements={"id"="\d+"})
-   */
-  public function getAction($listId, $id) {
+    /**
+     * @Route("/api/{version}/content/lists/{listId}/items/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_show_lists_item", requirements={"id"="\d+"})
+     */
+    public function getAction($listId, $id) {
     return new SingleResourceResponse($this->findOr404($listId, $id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/lists/{listId}/items/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_lists_item", requirements={"id"="\d+", "listId"="\d+"})
-   */
-  public function updateAction(Request $request, FormFactoryInterface $formFactory, $listId,
-                                       $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/lists/{listId}/items/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_lists_item", requirements={"id"="\d+", "listId"="\d+"})
+     */
+    public function updateAction(Request $request, FormFactoryInterface $formFactory, $listId,
+                                        $id): SingleResourceResponseInterface {
     $contentListItem = $this->findOr404($listId, $id);
     $form = $formFactory->createNamed(
         '',
@@ -137,13 +137,13 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $contentListItem->getContentList()->setUpdatedAt(new DateTime());
+        $contentListItem->getContentList()->setUpdatedAt(new DateTime());
 
-      if (null !== $contentListItem->getStickyPosition()) {
+        if (null !== $contentListItem->getStickyPosition()) {
         $contentListItem->setPosition($contentListItem->getStickyPosition());
-      }
+        }
 
-      $this->entityManager->flush();
+        $this->entityManager->flush();
         ContentListController::invalidateCache(
             $this->invalidationCacheUrl,
             $this->invalidationToken,
@@ -155,46 +155,46 @@ 
             ]
         );
 
-      return new SingleResourceResponse($contentListItem);
+        return new SingleResourceResponse($contentListItem);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
-
-  /**
-   * @Route("/api/{version}/content/lists/{listId}/items/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_batch_update_lists_item", requirements={"listId"="\d+"})
-   */
-  public function batchUpdateAction(
-      Request                        $request,
-      FormFactoryInterface           $formFactory,
-      ContentListRepositoryInterface $contentListRepository,
-      ArticleRepositoryInterface     $articleRepository,
-      EventDispatcherInterface       $eventDispatcher,
-      int                            $listId
-  ): SingleResourceResponseInterface {
+    }
+
+    /**
+     * @Route("/api/{version}/content/lists/{listId}/items/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_batch_update_lists_item", requirements={"listId"="\d+"})
+     */
+    public function batchUpdateAction(
+        Request                        $request,
+        FormFactoryInterface           $formFactory,
+        ContentListRepositoryInterface $contentListRepository,
+        ArticleRepositoryInterface     $articleRepository,
+        EventDispatcherInterface       $eventDispatcher,
+        int                            $listId
+    ): SingleResourceResponseInterface {
     /** @var ContentListInterface $list */
     $list = $contentListRepository->findOneBy(['id' => $listId]);
     if (null === $list) {
-      throw new NotFoundHttpException(sprintf('Content list with id "%s" was not found.', $list));
+        throw new NotFoundHttpException(sprintf('Content list with id "%s" was not found.', $list));
     }
 
     $form = $formFactory->createNamed('', ContentListItemsType::class, [], ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $data = $form->getData();
-      $updatedAt = DateTime::createFromFormat(DateTime::RFC3339, $data['updatedAt'], new DateTimeZone('UTC'));
-      $updatedAt->setTimezone(new DateTimeZone('UTC'));
-      $listUpdatedAt = $list->getUpdatedAt();
-      $listUpdatedAt->setTimezone(new DateTimeZone('UTC'));
-      if ($updatedAt < $listUpdatedAt) {
+        $data = $form->getData();
+        $updatedAt = DateTime::createFromFormat(DateTime::RFC3339, $data['updatedAt'], new DateTimeZone('UTC'));
+        $updatedAt->setTimezone(new DateTimeZone('UTC'));
+        $listUpdatedAt = $list->getUpdatedAt();
+        $listUpdatedAt->setTimezone(new DateTimeZone('UTC'));
+        if ($updatedAt < $listUpdatedAt) {
         throw new ConflictHttpException('List was already updated');
-      }
+        }
 
-      $updatedArticles = [];
-      $updatedItemsInvalidateCache = [];
-      /** @var ContentListAction $item */
-      foreach ($data['items'] as $item) {
+        $updatedArticles = [];
+        $updatedItemsInvalidateCache = [];
+        /** @var ContentListAction $item */
+        foreach ($data['items'] as $item) {
         $position = $item->getPosition();
         $isSticky = $item->isSticky();
         $contentId = $item->getContentId();
@@ -208,7 +208,7 @@ 
 
 
         switch ($item->getAction()) {
-          case ContentListAction::ACTION_MOVE:
+            case ContentListAction::ACTION_MOVE:
             $updated = false;
             $contentListItem = $this->findByContentOr404($list, $contentId);
 
@@ -236,7 +236,7 @@ 
             $updatedArticles[$contentId] = $contentListItem->getContent();
 
             break;
-          case ContentListAction::ACTION_ADD:
+            case ContentListAction::ACTION_ADD:
             $this->ensureThereIsNoItemOnPositionOrThrow409(
                 $listId,
                 $position,
@@ -250,7 +250,7 @@ 
             $updatedArticles[$contentId] = $contentListItem->getContent();
 
             break;
-          case ContentListAction::ACTION_DELETE:
+            case ContentListAction::ACTION_DELETE:
             $contentListItem = $this->findByContentOr404($list, $contentId);
             $this->entityManager->remove($contentListItem);
             $list->setUpdatedAt(new DateTime('now'));
@@ -259,17 +259,17 @@ 
 
             break;
         }
-      }
+        }
 
-      $this->contentListService->repositionStickyItems($list);
+        $this->contentListService->repositionStickyItems($list);
 
-      foreach ($updatedArticles as $updatedArticle) {
+        foreach ($updatedArticles as $updatedArticle) {
         $eventDispatcher->dispatch(new ArticleEvent(
             $updatedArticle,
             $updatedArticle->getPackage(),
             ArticleEvents::POST_UPDATE
         ), ArticleEvents::POST_UPDATE);
-      }
+        }
         ContentListController::invalidateCache(
             $this->invalidationCacheUrl,
             $this->invalidationToken,
@@ -282,13 +282,13 @@ 
             ]
         );
 
-      return new SingleResourceResponse($list, new ResponseContext(201));
+        return new SingleResourceResponse($list, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  private function findByContentOr404($listId, $contentId): ContentListItemInterface {
+    private function findByContentOr404($listId, $contentId): ContentListItemInterface {
     /** @var ContentListItemInterface $listItem */
     $listItem = $this->contentListItemRepository->findOneBy([
         'contentList' => $listId,
@@ -296,13 +296,13 @@ 
     ]);
 
     if (null === $listItem) {
-      throw new NotFoundHttpException(sprintf('Content list item with content_id "%s" was not found on that list. If You want to add new item - use action type "add".', $contentId));
+        throw new NotFoundHttpException(sprintf('Content list item with content_id "%s" was not found on that list. If You want to add new item - use action type "add".', $contentId));
     }
 
     return $listItem;
-  }
+    }
 
-  private function findOr404($listId, $id): ContentListItemInterface {
+    private function findOr404($listId, $id): ContentListItemInterface {
     /** @var ContentListItemInterface $listItem */
     $listItem = $this->contentListItemRepository->findOneBy([
         'contentList' => $listId,
@@ -310,29 +310,29 @@ 
     ]);
 
     if (null === $listItem) {
-      throw new NotFoundHttpException(sprintf('Content list item with id "%s" was not found.', $id));
+        throw new NotFoundHttpException(sprintf('Content list item with id "%s" was not found.', $id));
     }
 
     return $listItem;
-  }
+    }
 
-  private function ensureThereIsNoItemOnPositionOrThrow409(
-      int $listId,
-      int $position,
-      bool $isSticky,
-      string $action): void {
-      $existingContentListItem = $this->contentListService->isAnyItemPinnedOnPosition($listId, $position);
+    private function ensureThereIsNoItemOnPositionOrThrow409(
+        int $listId,
+        int $position,
+        bool $isSticky,
+        string $action): void {
+        $existingContentListItem = $this->contentListService->isAnyItemPinnedOnPosition($listId, $position);
 
-      if (!$existingContentListItem && !$isSticky) {
-          return;
-      }
+        if (!$existingContentListItem && !$isSticky) {
+            return;
+        }
 
-      if ($existingContentListItem && $existingContentListItem->isSticky()) {
+        if ($existingContentListItem && $existingContentListItem->isSticky()) {
         throw new ConflictHttpException('There is already an item pinned on that position. Unpin it first.');
-      }
+        }
 
-      if ($action === ContentListAction::ACTION_MOVE && $isSticky) {
-          throw new ConflictHttpException('Cannot move pinned item. Unpin it first.');
-      }
-  }
+        if ($action === ContentListAction::ACTION_MOVE && $isSticky) {
+            throw new ConflictHttpException('Cannot move pinned item. Unpin it first.');
+        }
+    }
 }