superdesk / web-publisher

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

Indentation +21 added lines, -21 removed lines

@@ -27,51 +27,51 @@
 
 class RedirectingController extends AbstractController {
 
-  private RouterInterface $router;
-  private ArticleRepositoryInterface $articleRepository;
+    private RouterInterface $router;
+    private ArticleRepositoryInterface $articleRepository;
 
-  /**
-   * @param RouterInterface $router
-   * @param ArticleRepositoryInterface $articleRepository
-   */
-  public function __construct(RouterInterface $router, ArticleRepositoryInterface $articleRepository) {
+    /**
+     * @param RouterInterface $router
+     * @param ArticleRepositoryInterface $articleRepository
+     */
+    public function __construct(RouterInterface $router, ArticleRepositoryInterface $articleRepository) {
     $this->router = $router;
     $this->articleRepository = $articleRepository;
-  }
+    }
 
 
-  public function redirectBasedOnExtraDataAction(Request $request, string $key, string $value): RedirectResponse {
+    public function redirectBasedOnExtraDataAction(Request $request, string $key, string $value): RedirectResponse {
     try {
-      $existingArticle = $this->articleRepository->getArticleByExtraData($key, $value)->getQuery()->getOneOrNullResult();
-      if (null === $existingArticle) {
+        $existingArticle = $this->articleRepository->getArticleByExtraData($key, $value)->getQuery()->getOneOrNullResult();
+        if (null === $existingArticle) {
         $existingArticle = $this->articleRepository->getArticleByPackageExtraData($key, $value)->getQuery()->getOneOrNullResult();
-      }
+        }
     } catch (NonUniqueResultException $e) {
-      $existingArticle = null;
+        $existingArticle = null;
     }
 
     if (null === $existingArticle || null === $existingArticle->getRoute()) {
-      throw $this->createNotFoundException('Article with provided data was not found.');
+        throw $this->createNotFoundException('Article with provided data was not found.');
     }
 
     return $this->redirect($this->generateArticleUrl($request, $existingArticle), 301);
-  }
+    }
 
-  public function redirectBasedOnSlugAction(Request $request, string $slug): RedirectResponse {
+    public function redirectBasedOnSlugAction(Request $request, string $slug): RedirectResponse {
     $existingArticle = $this->articleRepository->findOneBySlug($slug);
     if (null === $existingArticle || null === $existingArticle->getRoute()) {
-      throw $this->createNotFoundException('Article not found.');
+        throw $this->createNotFoundException('Article not found.');
     }
 
     return $this->redirect($this->generateArticleUrl($request, $existingArticle), 301);
-  }
+    }
 
-  private function generateArticleUrl(Request $request, ArticleInterface $article): string {
+    private function generateArticleUrl(Request $request, ArticleInterface $article): string {
     $parameters = ['slug' => $article->getSlug()];
     if ($request->query->has('amp')) {
-      $parameters['amp'] = 1;
+        $parameters['amp'] = 1;
     }
 
     return $this->router->generate($article->getRoute(), $parameters, UrlGeneratorInterface::ABSOLUTE_URL);
-  }
+    }
 }

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

Indentation +24 added lines, -24 removed lines

@@ -28,40 +28,40 @@ 
 
 class DefaultController extends AbstractController {
 
-  private CachedTenantContextInterface $tenantContext;
-  private MetaFactoryInterface $metaFactory;
-  private Context $templateEngineContext;
-  private RouteFactoryInterface $routeFactory;
+    private CachedTenantContextInterface $tenantContext;
+    private MetaFactoryInterface $metaFactory;
+    private Context $templateEngineContext;
+    private RouteFactoryInterface $routeFactory;
 
-  public function __construct(
-      CachedTenantContextInterface $tenantContext,
-      MetaFactoryInterface         $metaFactory,
-      Context                      $templateEngineContext,
-      RouteFactoryInterface        $routeFactory
-  ) {
+    public function __construct(
+        CachedTenantContextInterface $tenantContext,
+        MetaFactoryInterface         $metaFactory,
+        Context                      $templateEngineContext,
+        RouteFactoryInterface        $routeFactory
+    ) {
     $this->tenantContext = $tenantContext;
     $this->metaFactory = $metaFactory;
     $this->templateEngineContext = $templateEngineContext;
     $this->routeFactory = $routeFactory;
-  }
+    }
 
-  /**
-   * @Route("/", methods={"GET","POST"}, name="homepage")
-   */
-  public function indexAction(Request $request): Response {
+    /**
+     * @Route("/", methods={"GET","POST"}, name="homepage")
+     */
+    public function indexAction(Request $request): Response {
     /** @var TenantInterface $currentTenant */
     $currentTenant = $this->tenantContext->getTenant();
     $route = $currentTenant->getHomepage();
 
     if (null === $route) {
-      /** @var RouteInterface $route */
-      $route = $this->routeFactory->create();
-      $route->setStaticPrefix('/');
-      $route->setName('Homepage');
-      $route->setType('content');
-      $route->setTemplateName('index.html.twig');
-      $route->setCacheTimeInSeconds(360);
-      $request->attributes->set(DynamicRouter::ROUTE_KEY, $route);
+        /** @var RouteInterface $route */
+        $route = $this->routeFactory->create();
+        $route->setStaticPrefix('/');
+        $route->setName('Homepage');
+        $route->setType('content');
+        $route->setTemplateName('index.html.twig');
+        $route->setCacheTimeInSeconds(360);
+        $request->attributes->set(DynamicRouter::ROUTE_KEY, $route);
     }
 
     $this->templateEngineContext->setCurrentPage($this->metaFactory->create($route));
@@ -70,5 +70,5 @@ 
     $response->headers->set('Content-Type', 'text/html; charset=UTF-8');
 
     return $this->render('index.html.twig', [], $response);
-  }
+    }
 }

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

Indentation +69 added lines, -69 removed lines

@@ -45,39 +45,39 @@ 
 
 class PackageController extends Controller {
 
-  private FormFactoryInterface $formFactory;
-  private EventDispatcherInterface $eventDispatcher;
-  private CachedTenantContextInterface $cachedTenantContext;
-  private ArticlePublisherInterface $articlePublisher;
-  private PersisterRegistry $elasticaPersisterRegistry;
-  private PackageRepositoryInterface $packageRepository;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param CachedTenantContextInterface $cachedTenantContext
-   * @param ArticlePublisherInterface $articlePublisher
-   * @param PersisterRegistry $elasticaPersisterRegistry
-   * @param PackageRepositoryInterface $packageRepository
-   */
-  public function __construct(FormFactoryInterface         $formFactory, EventDispatcherInterface $eventDispatcher,
-                              CachedTenantContextInterface $cachedTenantContext,
-                              ArticlePublisherInterface    $articlePublisher,
-                              PersisterRegistry            $elasticaPersisterRegistry,
-                              PackageRepositoryInterface   $packageRepository) {
+    private FormFactoryInterface $formFactory;
+    private EventDispatcherInterface $eventDispatcher;
+    private CachedTenantContextInterface $cachedTenantContext;
+    private ArticlePublisherInterface $articlePublisher;
+    private PersisterRegistry $elasticaPersisterRegistry;
+    private PackageRepositoryInterface $packageRepository;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param CachedTenantContextInterface $cachedTenantContext
+     * @param ArticlePublisherInterface $articlePublisher
+     * @param PersisterRegistry $elasticaPersisterRegistry
+     * @param PackageRepositoryInterface $packageRepository
+     */
+    public function __construct(FormFactoryInterface         $formFactory, EventDispatcherInterface $eventDispatcher,
+                                CachedTenantContextInterface $cachedTenantContext,
+                                ArticlePublisherInterface    $articlePublisher,
+                                PersisterRegistry            $elasticaPersisterRegistry,
+                                PackageRepositoryInterface   $packageRepository) {
     $this->formFactory = $formFactory;
     $this->eventDispatcher = $eventDispatcher;
     $this->cachedTenantContext = $cachedTenantContext;
     $this->articlePublisher = $articlePublisher;
     $this->elasticaPersisterRegistry = $elasticaPersisterRegistry;
     $this->packageRepository = $packageRepository;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/packages/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_packages")
-   */
-  public function listAction(Request $request) {
+    /**
+     * @Route("/api/{version}/packages/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_packages")
+     */
+    public function listAction(Request $request) {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     $tenantContext = $this->cachedTenantContext;
 
@@ -88,19 +88,19 @@ 
         ]), $request->query->all('sorting'), new PaginationData($request));
 
     return new ResourcesListResponse($packages);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_show_package", requirements={"id"="\d+"})
-   */
-  public function getAction(int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/packages/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_show_package", requirements={"id"="\d+"})
+     */
+    public function getAction(int $id): SingleResourceResponseInterface {
     return new SingleResourceResponse($this->findOr404($id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/{id}/publish/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_publish_package", requirements={"id"="\d+"})
-   */
-  public function publishAction(Request $request, int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/packages/{id}/publish/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_publish_package", requirements={"id"="\d+"})
+     */
+    public function publishAction(Request $request, int $id): SingleResourceResponseInterface {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     /** @var PackageInterface $package */
     $package = $this->findOr404($id);
@@ -109,74 +109,74 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->articlePublisher->publish($package, $form->getData());
-      $this->elasticaPersisterRegistry->getPersister('swp_package')->replaceOne($package);
+        $this->articlePublisher->publish($package, $form->getData());
+        $this->elasticaPersisterRegistry->getPersister('swp_package')->replaceOne($package);
 
-      return new SingleResourceResponse(null, new ResponseContext(201));
+        return new SingleResourceResponse(null, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/{id}/unpublish/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_unpublish_package", requirements={"id"="\d+"})
-   */
-  public function unpublishAction(Request $request, int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/packages/{id}/unpublish/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_unpublish_package", requirements={"id"="\d+"})
+     */
+    public function unpublishAction(Request $request, int $id): SingleResourceResponseInterface {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     $package = $this->findOr404($id);
     $form = $this->formFactory->createNamed('', UnpublishFromTenantsType::class, null, ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $formData = $form->getData();
-      /** @var Collection $tenants */
-      $tenants = $formData['tenants'];
-      $this->articlePublisher->unpublish($package, $tenants->toArray());
+        $formData = $form->getData();
+        /** @var Collection $tenants */
+        $tenants = $formData['tenants'];
+        $this->articlePublisher->unpublish($package, $tenants->toArray());
 
-      return new SingleResourceResponse(null, new ResponseContext(200));
+        return new SingleResourceResponse(null, new ResponseContext(200));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
-
-  /**
-   * @Route("/api/{version}/packages/{id}/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_package", requirements={"id"="\d+"})
-   *
-   * @return SingleResourceResponse
-   */
-  public function updateAction(Request $request, int $id) {
+    }
+
+    /**
+     * @Route("/api/{version}/packages/{id}/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_package", requirements={"id"="\d+"})
+     *
+     * @return SingleResourceResponse
+     */
+    public function updateAction(Request $request, int $id) {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     $package = $this->findOr404($id);
     $form = $this->formFactory->createNamed('', PackageType::class, $package, ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      if (ContentInterface::STATUS_CANCELED === $package->getPubStatus()) {
+        if (ContentInterface::STATUS_CANCELED === $package->getPubStatus()) {
         $package->setStatus(ContentInterface::STATUS_CANCELED);
-      }
-      $this->getPackageRepository()->flush();
+        }
+        $this->getPackageRepository()->flush();
 
-      return new SingleResourceResponse($package, new ResponseContext(200));
+        return new SingleResourceResponse($package, new ResponseContext(200));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @return object|null
-   */
-  private function findOr404(int $id) {
+    /**
+     * @return object|null
+     */
+    private function findOr404(int $id) {
     $this->eventDispatcher->dispatch(new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     $tenantContext = $this->cachedTenantContext;
 
     if (null === $package = $this->getPackageRepository()->findOneBy(['id' => $id, 'organization' => $tenantContext->getTenant()->getOrganization()])) {
-      throw new NotFoundHttpException('Package was not found.');
+        throw new NotFoundHttpException('Package was not found.');
     }
 
     return $package;
-  }
+    }
 
-  protected function getPackageRepository() {
+    protected function getPackageRepository() {
     return $this->packageRepository;
-  }
+    }
 }

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

Indentation +69 added lines, -69 removed lines

@@ -37,86 +37,86 @@ 
 
 class MenuController extends AbstractController {
 
-  private FormFactoryInterface $formFactory;
-  private EventDispatcherInterface $eventDispatcher;
-  private MenuItemRepositoryInterface $menuItemRepository;
-  private MenuItemManager $menuItemManager;
-  private MenuFactoryInterface $menuFactory;
-  private EntityManagerInterface $entityManager;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param MenuItemRepositoryInterface $menuItemRepository
-   * @param MenuItemManager $menuItemManager
-   * @param MenuFactoryInterface $menuFactory
-   * @param EntityManagerInterface $entityManager
-   */
-  public function __construct(FormFactoryInterface        $formFactory, EventDispatcherInterface $eventDispatcher,
-                              MenuItemRepositoryInterface $menuItemRepository, MenuItemManager $menuItemManager,
-                              MenuFactoryInterface        $menuFactory, EntityManagerInterface $entityManager) {
+    private FormFactoryInterface $formFactory;
+    private EventDispatcherInterface $eventDispatcher;
+    private MenuItemRepositoryInterface $menuItemRepository;
+    private MenuItemManager $menuItemManager;
+    private MenuFactoryInterface $menuFactory;
+    private EntityManagerInterface $entityManager;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param MenuItemRepositoryInterface $menuItemRepository
+     * @param MenuItemManager $menuItemManager
+     * @param MenuFactoryInterface $menuFactory
+     * @param EntityManagerInterface $entityManager
+     */
+    public function __construct(FormFactoryInterface        $formFactory, EventDispatcherInterface $eventDispatcher,
+                                MenuItemRepositoryInterface $menuItemRepository, MenuItemManager $menuItemManager,
+                                MenuFactoryInterface        $menuFactory, EntityManagerInterface $entityManager) {
     $this->formFactory = $formFactory;
     $this->eventDispatcher = $eventDispatcher;
     $this->menuItemRepository = $menuItemRepository;
     $this->menuItemManager = $menuItemManager;
     $this->menuFactory = $menuFactory;
     $this->entityManager = $entityManager;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/menus/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_menu")
-   */
-  public function listAction(Request $request): ResourcesListResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_menu")
+     */
+    public function listAction(Request $request): ResourcesListResponseInterface {
     $menuRepository = $this->menuItemRepository;
     $page = $request->query->get('page', 1);
     $limit = $request->query->get('limit', 10);
 
     return new ResourcesListResponse($menuRepository->findRootNodes($this->eventDispatcher, $page, $limit));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/{id}/children/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_children_menu")
-   */
-  public function listChildrenAction($id): ResourcesListResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/{id}/children/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_list_children_menu")
+     */
+    public function listChildrenAction($id): ResourcesListResponseInterface {
     $menuRepository = $this->menuItemRepository;
 
     $menus = $menuRepository->findChildrenAsTree($this->eventDispatcher, $this->findOr404($id));
 
     return new ResourcesListResponse($menus);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/{id}/move/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_move_menu", requirements={"id"="\d+"})
-   */
-  public function moveAction(Request $request, $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/{id}/move/", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_move_menu", requirements={"id"="\d+"})
+     */
+    public function moveAction(Request $request, $id): SingleResourceResponseInterface {
     $menuItem = $this->findOr404($id);
     $form = $this->formFactory->createNamed('', MenuItemMoveType::class, [], ['method' => $request->getMethod()]);
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $menuItemManager = $this->menuItemManager;
-      $formData = $form->getData();
+        $menuItemManager = $this->menuItemManager;
+        $formData = $form->getData();
 
-      $menuItemManager->move($menuItem, $formData['parent'], $formData['position']);
+        $menuItemManager->move($menuItem, $formData['parent'], $formData['position']);
 
-      return new SingleResourceResponse($menuItem);
+        return new SingleResourceResponse($menuItem);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_menu")
-   */
-  public function getAction($id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_menu")
+     */
+    public function getAction($id): SingleResourceResponseInterface {
     return new SingleResourceResponse($this->findOr404($id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_create_menu")
-   */
-  public function createAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_create_menu")
+     */
+    public function createAction(Request $request): SingleResourceResponseInterface {
     /* @var MenuItemInterface $menu */
     $menu = $this->menuFactory->create();
     $form = $this->formFactory->createNamed('', MenuType::class, $menu, ['method' => $request->getMethod()]);
@@ -124,20 +124,20 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->menuItemManager->update($menu);
-      $this->menuItemRepository->add($menu);
-      $this->eventDispatcher->dispatch(new GenericEvent($menu), MenuEvents::MENU_CREATED);
+        $this->menuItemManager->update($menu);
+        $this->menuItemRepository->add($menu);
+        $this->eventDispatcher->dispatch(new GenericEvent($menu), MenuEvents::MENU_CREATED);
 
-      return new SingleResourceResponse($menu, new ResponseContext(201));
+        return new SingleResourceResponse($menu, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"DELETE"}, name="swp_api_core_delete_menu")
-   */
-  public function deleteAction(int $id) {
+    /**
+     * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"DELETE"}, name="swp_api_core_delete_menu")
+     */
+    public function deleteAction(int $id) {
     $repository = $this->menuItemRepository;
     $menu = $this->findOr404($id);
 
@@ -145,12 +145,12 @@ 
     $this->eventDispatcher->dispatch(new GenericEvent($menu), MenuEvents::MENU_DELETED);
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_menu")
-   */
-  public function updateAction(Request $request, $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/menus/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_menu")
+     */
+    public function updateAction(Request $request, $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     $menu = $this->findOr404($id);
 
@@ -158,23 +158,23 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->menuItemManager->update($menu);
-      $objectManager->flush();
+        $this->menuItemManager->update($menu);
+        $objectManager->flush();
 
-      $this->eventDispatcher->dispatch(new GenericEvent($menu), MenuEvents::MENU_UPDATED);
+        $this->eventDispatcher->dispatch(new GenericEvent($menu), MenuEvents::MENU_UPDATED);
 
-      return new SingleResourceResponse($menu);
+        return new SingleResourceResponse($menu);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  private function findOr404($id): MenuItemInterface {
+    private function findOr404($id): MenuItemInterface {
     /* @var MenuItemInterface $menu */
     if (null === $menu = $this->menuItemRepository->findOneBy(['id' => $id])) {
-      throw new NotFoundHttpException('Menu item was not found.');
+        throw new NotFoundHttpException('Menu item was not found.');
     }
 
     return $menu;
-  }
+    }
 }

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

Indentation +38 added lines, -38 removed lines

@@ -37,30 +37,30 @@ 
 
 class ArticleCommentsController extends AbstractController {
 
-  private ArticleRepositoryInterface $articleRepository;
-  private ArticleResolverInterface $articleResolver;
-  private FormFactoryInterface $formFactory;
-  private EventDispatcherInterface $eventDispatcher;
-
-  /**
-   * @param ArticleRepositoryInterface $articleRepository
-   * @param ArticleResolverInterface $articleResolver
-   * @param FormFactoryInterface $formFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(ArticleRepositoryInterface $articleRepository, ArticleResolverInterface $articleResolver,
-                              FormFactoryInterface       $formFactory, EventDispatcherInterface $eventDispatcher) {
+    private ArticleRepositoryInterface $articleRepository;
+    private ArticleResolverInterface $articleResolver;
+    private FormFactoryInterface $formFactory;
+    private EventDispatcherInterface $eventDispatcher;
+
+    /**
+     * @param ArticleRepositoryInterface $articleRepository
+     * @param ArticleResolverInterface $articleResolver
+     * @param FormFactoryInterface $formFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(ArticleRepositoryInterface $articleRepository, ArticleResolverInterface $articleResolver,
+                                FormFactoryInterface       $formFactory, EventDispatcherInterface $eventDispatcher) {
     $this->articleRepository = $articleRepository;
     $this->articleResolver = $articleResolver;
     $this->formFactory = $formFactory;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/content/articles", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_article_comments")
-   */
-  public function updateAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/articles", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_article_comments")
+     */
+    public function updateAction(Request $request): SingleResourceResponseInterface {
     $repository = $this->articleRepository;
     $articleResolver = $this->articleResolver;
     $form = $this->formFactory->createNamed('', ArticleCommentsType::class, [], ['method' => $request->getMethod()]);
@@ -68,42 +68,42 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $data = $form->getData();
-      $article = null;
-      if (null !== $data['url']) {
+        $data = $form->getData();
+        $article = null;
+        if (null !== $data['url']) {
         $article = strpos($data['url'], '/r/') ? $repository->findOneBySlug(
             str_replace('/r/', '', $this->getFragmentFromUrl($data['url'], 'path'))
         ) : $articleResolver->resolve($data['url']);
-      } elseif (null !== $data['id']) {
+        } elseif (null !== $data['id']) {
         $article = $repository->findOneBy(['id' => $data['id']]);
-      }
+        }
 
-      if (null === $article) {
+        if (null === $article) {
         throw new NotFoundHttpException('Article was not found');
-      }
+        }
 
-      $article->setCommentsCount((int)$data['commentsCount']);
-      $article->cancelTimestampable();
-      $repository->flush();
+        $article->setCommentsCount((int)$data['commentsCount']);
+        $article->cancelTimestampable();
+        $repository->flush();
 
-      $this->eventDispatcher->dispatch(new ArticleEvent(
-          $article,
-          $article->getPackage(),
-          ArticleEvents::POST_UPDATE
-      ), ArticleEvents::POST_UPDATE);
+        $this->eventDispatcher->dispatch(new ArticleEvent(
+            $article,
+            $article->getPackage(),
+            ArticleEvents::POST_UPDATE
+        ), ArticleEvents::POST_UPDATE);
 
-      return new SingleResourceResponse($article);
+        return new SingleResourceResponse($article);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  private function getFragmentFromUrl(string $url, string $fragment): ?string {
+    private function getFragmentFromUrl(string $url, string $fragment): ?string {
     $fragments = parse_url($url);
     if (!array_key_exists($fragment, $fragments)) {
-      return null;
+        return null;
     }
 
     return $fragments[$fragment];
-  }
+    }
 }

Spacing +1 added lines, -1 removed lines

@@ -82,7 +82,7 @@
         throw new NotFoundHttpException('Article was not found');
       }
 
-      $article->setCommentsCount((int)$data['commentsCount']);
+      $article->setCommentsCount((int) $data['commentsCount']);
       $article->cancelTimestampable();
       $repository->flush();
 

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

Indentation +32 added lines, -32 removed lines

@@ -34,36 +34,36 @@ 
 
 class FbiaFeedController extends AbstractController {
 
-  private FormFactoryInterface $formFactory;
-  private RepositoryInterface $facebookInstantArticlesFeedRepository;
-  private FactoryInterface $facebookInstantArticlesFeedFactory;
-  private EventDispatcherInterface $eventDispatcher;
+    private FormFactoryInterface $formFactory;
+    private RepositoryInterface $facebookInstantArticlesFeedRepository;
+    private FactoryInterface $facebookInstantArticlesFeedFactory;
+    private EventDispatcherInterface $eventDispatcher;
 
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param RepositoryInterface $facebookInstantArticlesFeedRepository
-   * @param FactoryInterface $facebookInstantArticlesFeedFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(FormFactoryInterface     $formFactory,
-                              RepositoryInterface      $facebookInstantArticlesFeedRepository,
-                              FactoryInterface         $facebookInstantArticlesFeedFactory,
-                              EventDispatcherInterface $eventDispatcher) {
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param RepositoryInterface $facebookInstantArticlesFeedRepository
+     * @param FactoryInterface $facebookInstantArticlesFeedFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(FormFactoryInterface     $formFactory,
+                                RepositoryInterface      $facebookInstantArticlesFeedRepository,
+                                FactoryInterface         $facebookInstantArticlesFeedFactory,
+                                EventDispatcherInterface $eventDispatcher) {
     $this->formFactory = $formFactory;
     $this->facebookInstantArticlesFeedRepository = $facebookInstantArticlesFeedRepository;
     $this->facebookInstantArticlesFeedFactory = $facebookInstantArticlesFeedFactory;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/facebook/instantarticles/feed/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_list_facebook_instant_articles_feed")
-   */
-  public function listAction(Request $request): ResourcesListResponseInterface {
+    /**
+     * @Route("/api/{version}/facebook/instantarticles/feed/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_list_facebook_instant_articles_feed")
+     */
+    public function listAction(Request $request): ResourcesListResponseInterface {
     $repository = $this->facebookInstantArticlesFeedRepository;
     $sort = $request->query->all('sorting');
     if (empty($sort)) {
-      $sort = ['createdAt' => 'desc'];
+        $sort = ['createdAt' => 'desc'];
     }
 
     $items = $repository->getPaginatedByCriteria(
@@ -74,33 +74,33 @@ 
     );
 
     return new ResourcesListResponse($items);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/facebook/instantarticles/feed/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_create_facebook_instant_articles_feed")
-   */
-  public function createAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/facebook/instantarticles/feed/", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_create_facebook_instant_articles_feed")
+     */
+    public function createAction(Request $request): SingleResourceResponseInterface {
     /* @var FacebookInstantArticlesFeedInterface $feed */
     $feed = $this->facebookInstantArticlesFeedFactory->create();
     $form = $this->formFactory->createNamed('', FacebookInstantArticlesFeedType::class, $feed, ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $this->checkIfFeedExists($feed->getContentBucket(), $feed->getFacebookPage());
-      $this->facebookInstantArticlesFeedRepository->add($feed);
+        $this->checkIfFeedExists($feed->getContentBucket(), $feed->getFacebookPage());
+        $this->facebookInstantArticlesFeedRepository->add($feed);
 
-      return new SingleResourceResponse($feed, new ResponseContext(201));
+        return new SingleResourceResponse($feed, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  private function checkIfFeedExists($contentBucket, $facebookPage) {
+    private function checkIfFeedExists($contentBucket, $facebookPage) {
     if (null !== $this->facebookInstantArticlesFeedRepository->findOneBy([
             'contentBucket' => $contentBucket,
             'facebookPage' => $facebookPage,
         ])) {
-      throw new ConflictHttpException('Feed for that page and content bucket already exists!');
+        throw new ConflictHttpException('Feed for that page and content bucket already exists!');
+    }
     }
-  }
 }

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

Indentation +51 added lines, -51 removed lines

@@ -34,86 +34,86 @@ 
 
 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")
-   * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
-   */
-  public function getAction(RuleInterface $rule) {
+    /**
+     * @Route("/api/{version}/rules/{id}", requirements={"id"="\d+"}, options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_rule")
+     * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
+     */
+    public function getAction(RuleInterface $rule) {
     return new SingleResourceResponse($rule);
-  }
+    }
 
-  /**
-   * @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+"})
-   * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
-   */
-  public function deleteAction(RuleInterface $rule) {
+    /**
+     * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_rule", methods={"DELETE"}, requirements={"id"="\d+"})
+     * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
+     */
+    public function deleteAction(RuleInterface $rule) {
     $ruleRepository = $this->ruleRepository;
     $ruleRepository->remove($rule);
 
     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+"})
-   * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
-   */
-  public function updateAction(Request $request, RuleInterface $rule) {
+    /**
+     * @Route("/api/{version}/rules/{id}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PATCH"}, name="swp_api_core_update_rule", requirements={"id"="\d+"})
+     * @ParamConverter("rule", class="SWP\Bundle\CoreBundle\Model\Rule")
+     */
+    public function updateAction(Request $request, RuleInterface $rule) {
     $objectManager = $this->entityManager;
 
     $form = $this->formFactory->createNamed('', RuleType::class, $rule, [
@@ -122,12 +122,12 @@ 
 
     $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));
-  }
+    }
 }

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

Indentation +23 added lines, -23 removed lines

@@ -13,21 +13,21 @@ 
 use Symfony\Component\Routing\Annotation\Route;
 
 class ExternalOauthController extends Controller {
-  public const PUBLISHER_JWT_COOKIE = 'publisher_jwt';
+    public const PUBLISHER_JWT_COOKIE = 'publisher_jwt';
 
-  private ClientRegistry $clientRegistry;
+    private ClientRegistry $clientRegistry;
 
-  /**
-   * @param ClientRegistry $clientRegistry
-   */
-  public function __construct(ClientRegistry $clientRegistry) {
+    /**
+     * @param ClientRegistry $clientRegistry
+     */
+    public function __construct(ClientRegistry $clientRegistry) {
     $this->clientRegistry = $clientRegistry;
-  }
+    }
 
-  /**
-   * @Route("/connect/oauth", name="connect_oauth_start")
-   */
-  public function connectAction(Request $request): Response {
+    /**
+     * @Route("/connect/oauth", name="connect_oauth_start")
+     */
+    public function connectAction(Request $request): Response {
     $referer = $request->headers->get('referer');
 
     return $this->clientRegistry
@@ -35,20 +35,20 @@ 
         ->redirect([
             'openid', 'email', 'profile',
         ], ['state' => $referer]);
-  }
-
-  /**
-   * This is where the user is redirected after being succesfully authenticated by the OAuth server.
-   *
-   * @Route("/connect/oauth/check", name="connect_oauth_check")
-   */
-  public function connectCheckAction(Request $request, JWTTokenManagerInterface $jwtTokenManager): Response {
+    }
+
+    /**
+     * This is where the user is redirected after being succesfully authenticated by the OAuth server.
+     *
+     * @Route("/connect/oauth/check", name="connect_oauth_check")
+     */
+    public function connectCheckAction(Request $request, JWTTokenManagerInterface $jwtTokenManager): Response {
     // If we didn't log in, something went wrong. Throw an exception!
     if (!($user = $this->getUser())) {
-      $response = $this->render('bundles/TwigBundle/Exception/error403.html.twig');
-      $response->setStatusCode(403);
+        $response = $this->render('bundles/TwigBundle/Exception/error403.html.twig');
+        $response->setStatusCode(403);
 
-      return $response;
+        return $response;
     }
 
     $state = $request->query->get('state');
@@ -57,5 +57,5 @@ 
     $response->headers->setCookie(Cookie::create(self::PUBLISHER_JWT_COOKIE, $jwtTokenManager->create($user)));
 
     return $response;
-  }
+    }
 }

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

Spacing +1 added lines, -1 removed lines

@@ -123,7 +123,7 @@
     $route = $this->findRouteOr404($routeId);
 
     /** @var string $content */
-    $content = (string)$request->getContent();
+    $content = (string) $request->getContent();
     $dispatcher = $this->eventDispatcher;
     $package = $this->dataTransformer->transform($content);
     $dispatcher->dispatch(new GenericEvent($package), Events::SWP_VALIDATION);

Indentation +81 added lines, -81 removed lines

@@ -46,36 +46,36 @@ 
 
 class PackagePreviewController extends Controller {
 
-  private EventDispatcherInterface $eventDispatcher;
-  private DataTransformerInterface $dataTransformer;
-  private PackageRepositoryInterface $packageRepository;
-  private RouteRepositoryInterface $routeRepository;
-  private RepositoryInterface $packagePreviewTokenRepository;
-  private PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory;
-  private TemplateNameResolverInterface $templateNameResolver;
-  private ArticlePreviewerInterface $articlePreviewer;
-  private ArticlePreviewContextInterface $articlePreviewContext;
-
-  /**
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param DataTransformerInterface $dataTransformer
-   * @param PackageRepositoryInterface $packageRepository
-   * @param RouteRepositoryInterface $routeRepository
-   * @param RepositoryInterface $packagePreviewTokenRepository
-   * @param PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory
-   * @param TemplateNameResolverInterface $templateNameResolver
-   * @param ArticlePreviewerInterface $articlePreviewer
-   * @param ArticlePreviewContextInterface $articlePreviewContext
-   */
-  public function __construct(EventDispatcherInterface            $eventDispatcher,
-                              DataTransformerInterface            $dataTransformer,
-                              PackageRepositoryInterface          $packageRepository,
-                              RouteRepositoryInterface            $routeRepository,
-                              RepositoryInterface                 $packagePreviewTokenRepository,
-                              PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory,
-                              TemplateNameResolverInterface       $templateNameResolver,
-                              ArticlePreviewerInterface           $articlePreviewer,
-                              ArticlePreviewContextInterface      $articlePreviewContext) {
+    private EventDispatcherInterface $eventDispatcher;
+    private DataTransformerInterface $dataTransformer;
+    private PackageRepositoryInterface $packageRepository;
+    private RouteRepositoryInterface $routeRepository;
+    private RepositoryInterface $packagePreviewTokenRepository;
+    private PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory;
+    private TemplateNameResolverInterface $templateNameResolver;
+    private ArticlePreviewerInterface $articlePreviewer;
+    private ArticlePreviewContextInterface $articlePreviewContext;
+
+    /**
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param DataTransformerInterface $dataTransformer
+     * @param PackageRepositoryInterface $packageRepository
+     * @param RouteRepositoryInterface $routeRepository
+     * @param RepositoryInterface $packagePreviewTokenRepository
+     * @param PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory
+     * @param TemplateNameResolverInterface $templateNameResolver
+     * @param ArticlePreviewerInterface $articlePreviewer
+     * @param ArticlePreviewContextInterface $articlePreviewContext
+     */
+    public function __construct(EventDispatcherInterface            $eventDispatcher,
+                                DataTransformerInterface            $dataTransformer,
+                                PackageRepositoryInterface          $packageRepository,
+                                RouteRepositoryInterface            $routeRepository,
+                                RepositoryInterface                 $packagePreviewTokenRepository,
+                                PackagePreviewTokenFactoryInterface $packagePreviewTokenFactory,
+                                TemplateNameResolverInterface       $templateNameResolver,
+                                ArticlePreviewerInterface           $articlePreviewer,
+                                ArticlePreviewContextInterface      $articlePreviewContext) {
     $this->eventDispatcher = $eventDispatcher;
     $this->dataTransformer = $dataTransformer;
     $this->packageRepository = $packageRepository;
@@ -85,13 +85,13 @@ 
     $this->templateNameResolver = $templateNameResolver;
     $this->articlePreviewer = $articlePreviewer;
     $this->articlePreviewContext = $articlePreviewContext;
-  }
+    }
 
 
-  /**
-   * @Route("/preview/package/{routeId}/{id}", options={"expose"=true}, requirements={"id"="\d+", "routeId"="\d+", "token"=".+"}, methods={"GET"}, name="swp_package_preview")
-   */
-  public function previewAction(int $routeId, $id) {
+    /**
+     * @Route("/preview/package/{routeId}/{id}", options={"expose"=true}, requirements={"id"="\d+", "routeId"="\d+", "token"=".+"}, methods={"GET"}, name="swp_package_preview")
+     */
+    public function previewAction(int $routeId, $id) {
     /** @var RouteInterface $route */
     $route = $this->findRouteOr404($routeId);
     /** @var PackageInterface $package */
@@ -105,22 +105,22 @@ 
     $this->eventDispatcher->dispatch(new GenericEvent($articlePreview), ArticleEvents::PREVIEW);
 
     if (null !== ($url = $articlePreview->getPreviewUrl())) {
-      return new RedirectResponse($url);
+        return new RedirectResponse($url);
     }
 
     $route = $this->ensureRouteTemplateExists($route, $article);
 
     try {
-      return $this->render($route->getArticlesTemplateName());
+        return $this->render($route->getArticlesTemplateName());
     } catch (\Exception $e) {
-      throw $this->createNotFoundException(sprintf('Template for route with id "%d" (%s) not found!', $route->getId(), $route->getName()));
+        throw $this->createNotFoundException(sprintf('Template for route with id "%d" (%s) not found!', $route->getId(), $route->getName()));
+    }
     }
-  }
 
-  /**
-   * @FOSRoute("/api/{version}/preview/package/generate_token/{routeId}", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_preview_package_token", requirements={"routeId"="\d+"})
-   */
-  public function generateTokenAction(Request $request, int $routeId): SingleResourceResponseInterface {
+    /**
+     * @FOSRoute("/api/{version}/preview/package/generate_token/{routeId}", options={"expose"=true}, defaults={"version"="v2"}, methods={"POST"}, name="swp_api_core_preview_package_token", requirements={"routeId"="\d+"})
+     */
+    public function generateTokenAction(Request $request, int $routeId): SingleResourceResponseInterface {
     $route = $this->findRouteOr404($routeId);
 
     /** @var string $content */
@@ -133,27 +133,27 @@ 
     $existingPreviewToken = $tokenRepository->findOneBy(['route' => $route]);
 
     if (null === $existingPreviewToken) {
-      $packagePreviewToken = $this->packagePreviewTokenFactory->createTokenizedWith($route, $content);
+        $packagePreviewToken = $this->packagePreviewTokenFactory->createTokenizedWith($route, $content);
 
-      $tokenRepository->persist($packagePreviewToken);
-      $tokenRepository->flush();
+        $tokenRepository->persist($packagePreviewToken);
+        $tokenRepository->flush();
 
-      return $this->returnResponseWithPreviewUrl($packagePreviewToken);
+        return $this->returnResponseWithPreviewUrl($packagePreviewToken);
     }
 
     $this->updatePackagePreviewTokenBody($content, $existingPreviewToken);
 
     return $this->returnResponseWithPreviewUrl($existingPreviewToken);
-  }
+    }
 
-  /**
-   * @Route("/preview/publish/package/{token}", options={"expose"=true}, requirements={"token"=".+"}, methods={"GET"}, name="swp_package_preview_publish")
-   */
-  public function publishPreviewAction(string $token) {
+    /**
+     * @Route("/preview/publish/package/{token}", options={"expose"=true}, requirements={"token"=".+"}, methods={"GET"}, name="swp_package_preview_publish")
+     */
+    public function publishPreviewAction(string $token) {
     $existingPreviewToken = $this->packagePreviewTokenRepository->findOneBy(['token' => $token]);
 
     if (null === $existingPreviewToken) {
-      throw $this->createNotFoundException(sprintf('Token %s is not valid.', $token));
+        throw $this->createNotFoundException(sprintf('Token %s is not valid.', $token));
     }
 
     $article = $this->getArticleForPreview($existingPreviewToken);
@@ -161,17 +161,17 @@ 
     $route = $this->ensureRouteTemplateExists($route, $article);
 
     return $this->renderTemplateOr404($route);
-  }
+    }
 
-  private function updatePackagePreviewTokenBody(string $content, PackagePreviewTokenInterface $packagePreviewToken) {
+    private function updatePackagePreviewTokenBody(string $content, PackagePreviewTokenInterface $packagePreviewToken) {
     if (md5($content) !== md5($packagePreviewToken->getBody())) {
-      $packagePreviewToken->setBody($content);
+        $packagePreviewToken->setBody($content);
 
-      $this->packagePreviewTokenRepository->flush();
+        $this->packagePreviewTokenRepository->flush();
+    }
     }
-  }
 
-  private function returnResponseWithPreviewUrl(PackagePreviewTokenInterface $packagePreviewToken): SingleResourceResponseInterface {
+    private function returnResponseWithPreviewUrl(PackagePreviewTokenInterface $packagePreviewToken): SingleResourceResponseInterface {
     $article = $this->getArticleForPreview($packagePreviewToken);
     $articlePreview = new ArticlePreview();
     $articlePreview->setArticle($article);
@@ -181,19 +181,19 @@ 
     $url = $articlePreview->getPreviewUrl();
 
     if (null === $url) {
-      $url = $this->generateUrl(
-          'swp_package_preview_publish',
-          ['token' => $packagePreviewToken->getToken()],
-          UrlGeneratorInterface::ABSOLUTE_URL
-      );
+        $url = $this->generateUrl(
+            'swp_package_preview_publish',
+            ['token' => $packagePreviewToken->getToken()],
+            UrlGeneratorInterface::ABSOLUTE_URL
+        );
     }
 
     return new SingleResourceResponse([
         'preview_url' => $url,
     ]);
-  }
+    }
 
-  private function getArticleForPreview(PackagePreviewTokenInterface $packagePreviewToken): ArticleInterface {
+    private function getArticleForPreview(PackagePreviewTokenInterface $packagePreviewToken): ArticleInterface {
     $dispatcher = $this->eventDispatcher;
     $package = $this->dataTransformer->transform($packagePreviewToken->getBody());
     $dispatcher->dispatch(new GenericEvent($package), Events::SWP_VALIDATION);
@@ -204,40 +204,40 @@ 
     $articlePreviewContext->setIsPreview(true);
 
     return $articlePreviewer->preview($package, $packagePreviewToken->getRoute());
-  }
+    }
 
-  private function renderTemplateOr404(RouteInterface $route): Response {
+    private function renderTemplateOr404(RouteInterface $route): Response {
     try {
-      return $this->render($templateName = $route->getArticlesTemplateName());
+        return $this->render($templateName = $route->getArticlesTemplateName());
     } catch (\InvalidArgumentException $e) {
-      throw $this->createNotFoundException(sprintf('Template %s for route with id "%d" (%s) not found!', $templateName, $route->getId(), $route->getName()));
+        throw $this->createNotFoundException(sprintf('Template %s for route with id "%d" (%s) not found!', $templateName, $route->getId(), $route->getName()));
+    }
     }
-  }
 
-  private function ensureRouteTemplateExists(RouteInterface $route, ArticleInterface $article): RouteInterface {
+    private function ensureRouteTemplateExists(RouteInterface $route, ArticleInterface $article): RouteInterface {
     if (null === $route->getArticlesTemplateName()) {
-      $templateNameResolver = $this->templateNameResolver;
-      $route->setArticlesTemplateName($templateNameResolver->resolve($article));
+        $templateNameResolver = $this->templateNameResolver;
+        $route->setArticlesTemplateName($templateNameResolver->resolve($article));
     }
 
     return $route;
-  }
+    }
 
-  private function findRouteOr404(int $id): RouteInterface {
+    private function findRouteOr404(int $id): RouteInterface {
     /** @var RouteInterface $route */
     if (null === ($route = $this->routeRepository->findOneBy(['id' => $id]))) {
-      throw $this->createNotFoundException(sprintf('Route with id: "%s" not found!', $id));
+        throw $this->createNotFoundException(sprintf('Route with id: "%s" not found!', $id));
     }
 
     return $route;
-  }
+    }
 
-  private function findPackageOr404(string $id): PackageInterface {
+    private function findPackageOr404(string $id): PackageInterface {
     /** @var PackageInterface $package */
     if (null === ($package = $this->packageRepository->findOneBy(['id' => $id]))) {
-      throw $this->createNotFoundException(sprintf('Package with id: "%s" not found!', $id));
+        throw $this->createNotFoundException(sprintf('Package with id: "%s" not found!', $id));
     }
 
     return $package;
-  }
+    }
 }