superdesk / web-publisher

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

Spacing +2 added lines, -2 removed lines

@@ -123,8 +123,8 @@
 
             $subEvent = new ControllerEvent($event->getKernel(), $controller, $stubRequest, HttpKernelInterface::SUB_REQUEST);
             $kernelSubEvent = new RequestEvent($event->getKernel(), $stubRequest, HttpKernelInterface::SUB_REQUEST);
-            $dispatcher->dispatch( $kernelSubEvent, KernelEvents::REQUEST);
-            $dispatcher->dispatch( $subEvent, KernelEvents::CONTROLLER);
+            $dispatcher->dispatch($kernelSubEvent, KernelEvents::REQUEST);
+            $dispatcher->dispatch($subEvent, KernelEvents::CONTROLLER);
             $controller = $subEvent->getController();
 
             $argumentResolver = new ArgumentResolver();

src/SWP/Bundle/ContentBundle/Doctrine/ORM/ArticleRepository.php

Spacing +2 added lines, -2 removed lines

@@ -151,7 +151,7 @@ 
             $paginationData = new PaginationData();
         }
 
-        return $this->getPaginator($eventDispatcher,$queryBuilder, $paginationData);
+        return $this->getPaginator($eventDispatcher, $queryBuilder, $paginationData);
     }
 
     /**
@@ -172,7 +172,7 @@ 
                 ->leftJoin('a.extraEmbedFields', 'eef');
 
             foreach ((array) $criteria->get('extra') as $key => $value) {
-                if(is_array($value)) {
+                if (is_array($value)) {
                     $andX = $queryBuilder->expr()->andX();
                     $andX->add($queryBuilder->expr()->eq('eef.fieldName', $queryBuilder->expr()->literal($key)));
                     $andX->add($queryBuilder->expr()->eq('eef.embed', $queryBuilder->expr()->literal($value['embed'])));

src/SWP/Bundle/ContentBundle/Doctrine/ORM/RelatedArticleRepository.php

Spacing +1 added lines, -1 removed lines

@@ -61,7 +61,7 @@
             $paginationData = new PaginationData();
         }
 
-        return $this->getPaginator($eventDispatcher,$queryBuilder, $paginationData);
+        return $this->getPaginator($eventDispatcher, $queryBuilder, $paginationData);
     }
 
     private function applyCustomCriteria(QueryBuilder $queryBuilder, Criteria $criteria): void

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

Indentation +14 added lines, -14 removed lines

@@ -27,32 +27,32 @@
 
 class AuthorController extends AbstractController {
 
-  private ArticleAuthorRepositoryInterface $articleAuthorRepository; // swp.repository.author
+    private ArticleAuthorRepositoryInterface $articleAuthorRepository; // swp.repository.author
 
-  /**
-   * @param ArticleAuthorRepositoryInterface $articleAuthorRepository
-   */
-  public function __construct(ArticleAuthorRepositoryInterface $articleAuthorRepository) {
+    /**
+     * @param ArticleAuthorRepositoryInterface $articleAuthorRepository
+     */
+    public function __construct(ArticleAuthorRepositoryInterface $articleAuthorRepository) {
     $this->articleAuthorRepository = $articleAuthorRepository;
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/authors/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_author", requirements={"id"="\d+"})
-   */
-  public function deleteAction(int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/authors/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_author", requirements={"id"="\d+"})
+     */
+    public function deleteAction(int $id): SingleResourceResponseInterface {
     $authorRepository = $this->articleAuthorRepository;
     $author = $this->findOr404($id);
 
     $authorRepository->remove($author);
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  private function findOr404(int $id): ArticleAuthorInterface {
+    private function findOr404(int $id): ArticleAuthorInterface {
     if (null === $author = $this->articleAuthorRepository->findOneById($id)) {
-      throw new NotFoundHttpException('Author was not found.');
+        throw new NotFoundHttpException('Author was not found.');
     }
 
     return $author;
-  }
+    }
 }

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

Spacing +2 added lines, -2 removed lines

@@ -48,7 +48,7 @@ 
   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 PackageRepositoryInterface $packageRepository;//swp.repository.package
+  private PackageRepositoryInterface $packageRepository; //swp.repository.package
   private FileProviderInterface $fileProvider;
 
   /**
@@ -126,7 +126,7 @@ 
         );
       }
 
-      throw new \Exception('Uploaded file is not valid:' . $uploadedFile->getErrorMessage());
+      throw new \Exception('Uploaded file is not valid:'.$uploadedFile->getErrorMessage());
     }
 
     return new SingleResourceResponse($form);

Indentation +53 added lines, -53 removed lines

@@ -41,32 +41,32 @@ 
 use FOS\RestBundle\Controller\Annotations\Route;
 
 class ContentPushController extends AbstractController {
-  private EventDispatcherInterface $eventDispatcher;
-  private FormFactoryInterface $formFactory;
-  private MessageBusInterface $messageBus;
-  private CachedTenantContextInterface $cachedTenantContext; //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 PackageRepositoryInterface $packageRepository;//swp.repository.package
-  private FileProviderInterface $fileProvider;
-
-  /**
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param FormFactoryInterface $formFactory
-   * @param MessageBusInterface $messageBus
-   * @param CachedTenantContextInterface $cachedTenantContext
-   * @param DataTransformerInterface $dataTransformer
-   * @param MediaManagerInterface $mediaManager
-   * @param EntityManagerInterface $entityManager
-   * @param PackageRepositoryInterface $packageRepository
-   * @param FileProviderInterface $fileProvider
-   */
-  public function __construct(EventDispatcherInterface $eventDispatcher, FormFactoryInterface $formFactory,
-                              MessageBusInterface      $messageBus, CachedTenantContextInterface $cachedTenantContext,
-                              DataTransformerInterface $dataTransformer, MediaManagerInterface $mediaManager,
-                              EntityManagerInterface   $entityManager, PackageRepositoryInterface $packageRepository,
-                              FileProviderInterface    $fileProvider) {
+    private EventDispatcherInterface $eventDispatcher;
+    private FormFactoryInterface $formFactory;
+    private MessageBusInterface $messageBus;
+    private CachedTenantContextInterface $cachedTenantContext; //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 PackageRepositoryInterface $packageRepository;//swp.repository.package
+    private FileProviderInterface $fileProvider;
+
+    /**
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param FormFactoryInterface $formFactory
+     * @param MessageBusInterface $messageBus
+     * @param CachedTenantContextInterface $cachedTenantContext
+     * @param DataTransformerInterface $dataTransformer
+     * @param MediaManagerInterface $mediaManager
+     * @param EntityManagerInterface $entityManager
+     * @param PackageRepositoryInterface $packageRepository
+     * @param FileProviderInterface $fileProvider
+     */
+    public function __construct(EventDispatcherInterface $eventDispatcher, FormFactoryInterface $formFactory,
+                                MessageBusInterface      $messageBus, CachedTenantContextInterface $cachedTenantContext,
+                                DataTransformerInterface $dataTransformer, MediaManagerInterface $mediaManager,
+                                EntityManagerInterface   $entityManager, PackageRepositoryInterface $packageRepository,
+                                FileProviderInterface    $fileProvider) {
     $this->eventDispatcher = $eventDispatcher;
     $this->formFactory = $formFactory;
     $this->messageBus = $messageBus;
@@ -76,13 +76,13 @@ 
     $this->entityManager = $entityManager;
     $this->packageRepository = $packageRepository;
     $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): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/push", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_push")
+     */
+    public function pushContentAction(Request $request): SingleResourceResponseInterface {
     $package = $this->dataTransformer->transform($request->getContent());
     $this->eventDispatcher->dispatch(new GenericEvent($package), Events::SWP_VALIDATION);
 
@@ -91,27 +91,27 @@ 
     $this->messageBus->dispatch(new ContentPushMessage($currentTenant->getId(), $request->getContent()));
 
     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(
@@ -124,23 +124,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;
@@ -152,9 +152,9 @@ 
         'mime_type' => Mime::getMimeFromExtension($file->getFileExtension()),
         'filemeta' => [],
     ]);
-  }
+    }
 
-  protected function getPackageRepository() {
+    protected function getPackageRepository() {
     return $this->packageRepository;
-  }
+    }
 }

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

Indentation +65 added lines, -65 removed lines

@@ -42,31 +42,31 @@ 
 
 class RouteController extends FOSRestController {
 
-  private FormFactoryInterface $formFactory;
-  private EventDispatcherInterface $eventDispatcher;
-  private RouteProviderInterface $routeProvider; // swp.provider.route
-  private RouteRepositoryInterface $routeRepository; // swp.repository.route
-  private RouteServiceInterface $routeService; // swp.service.route
-  private RouteFactoryInterface $routeFactory; // swp.factory.route
-  private KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory; //swp_pagination_rep
-  private EntityManagerInterface $entityManager; // swp.object_manager.route
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param RouteProviderInterface $routeProvider
-   * @param RouteRepositoryInterface $routeRepository
-   * @param RouteServiceInterface $routeService
-   * @param RouteFactoryInterface $routeFactory
-   * @param KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory
-   * @param EntityManagerInterface $entityManager
-   */
-  public function __construct(FormFactoryInterface              $formFactory, EventDispatcherInterface $eventDispatcher,
-                              RouteProviderInterface            $routeProvider,
-                              RouteRepositoryInterface          $routeRepository, RouteServiceInterface $routeService,
-                              RouteFactoryInterface             $routeFactory,
-                              KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory,
-                              EntityManagerInterface            $entityManager) {
+    private FormFactoryInterface $formFactory;
+    private EventDispatcherInterface $eventDispatcher;
+    private RouteProviderInterface $routeProvider; // swp.provider.route
+    private RouteRepositoryInterface $routeRepository; // swp.repository.route
+    private RouteServiceInterface $routeService; // swp.service.route
+    private RouteFactoryInterface $routeFactory; // swp.factory.route
+    private KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory; //swp_pagination_rep
+    private EntityManagerInterface $entityManager; // swp.object_manager.route
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param RouteProviderInterface $routeProvider
+     * @param RouteRepositoryInterface $routeRepository
+     * @param RouteServiceInterface $routeService
+     * @param RouteFactoryInterface $routeFactory
+     * @param KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory
+     * @param EntityManagerInterface $entityManager
+     */
+    public function __construct(FormFactoryInterface              $formFactory, EventDispatcherInterface $eventDispatcher,
+                                RouteProviderInterface            $routeProvider,
+                                RouteRepositoryInterface          $routeRepository, RouteServiceInterface $routeService,
+                                RouteFactoryInterface             $routeFactory,
+                                KnpPaginatorRepresentationFactory $knpPaginatorRepresentationFactory,
+                                EntityManagerInterface            $entityManager) {
     $this->formFactory = $formFactory;
     $this->eventDispatcher = $eventDispatcher;
     $this->routeProvider = $routeProvider;
@@ -75,13 +75,13 @@ 
     $this->routeFactory = $routeFactory;
     $this->knpPaginatorRepresentationFactory = $knpPaginatorRepresentationFactory;
     $this->entityManager = $entityManager;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/content/routes/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_list_routes")
-   */
-  public function listAction(Request $request) {
+    /**
+     * @Route("/api/{version}/content/routes/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_list_routes")
+     */
+    public function listAction(Request $request) {
     $routeRepository = $this->routeRepository;
 
     $routes = $routeRepository->getPaginatedByCriteria($this->eventDispatcher, new Criteria([
@@ -89,28 +89,28 @@ 
     ]), $request->query->all('sorting'), new PaginationData($request));
 
     return $this->handleView(View::create($this->knpPaginatorRepresentationFactory->createRepresentation($routes, $request), 200));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/routes/{id}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_routes", requirements={"id"=".+"})
-   */
-  public function getAction($id) {
+    /**
+     * @Route("/api/{version}/content/routes/{id}", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_show_routes", requirements={"id"=".+"})
+     */
+    public function getAction($id) {
     return new SingleResourceResponse($this->findOr404($id));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/routes/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_delete_routes", requirements={"id"=".+"})
-   */
-  public function deleteAction(int $id): Response {
+    /**
+     * @Route("/api/{version}/content/routes/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_delete_routes", requirements={"id"=".+"})
+     */
+    public function deleteAction(int $id): Response {
     $repository = $this->routeRepository;
     $route = $this->findOr404($id);
 
     if (null !== $route->getContent()) {
-      throw new ConflictHttpException('Route has content attached to it.');
+        throw new ConflictHttpException('Route has content attached to it.');
     }
 
     if (0 < $route->getChildren()->count()) {
-      throw new ConflictHttpException('Remove route children before removing this route.');
+        throw new ConflictHttpException('Remove route children before removing this route.');
     }
 
     $eventDispatcher = $this->eventDispatcher;
@@ -119,12 +119,12 @@ 
     $eventDispatcher->dispatch(new RouteEvent($route, RouteEvents::POST_DELETE), RouteEvents::POST_DELETE);
 
     return $this->handleView(View::create(true, 204));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/routes/", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_create_routes")
-   */
-  public function createAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/content/routes/", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_create_routes")
+     */
+    public function createAction(Request $request): SingleResourceResponseInterface {
     /** @var RouteInterface $route */
     $route = $this->routeFactory->create();
     $form = $this->formFactory->createNamed('', RouteType::class, $route, ['method' => $request->getMethod()]);
@@ -133,20 +133,20 @@ 
     $this->ensureRouteExists($route->getName());
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $route = $this->routeService->createRoute($form->getData());
+        $route = $this->routeService->createRoute($form->getData());
 
-      $this->routeRepository->add($route);
+        $this->routeRepository->add($route);
 
-      return new SingleResourceResponse($route, new ResponseContext(201));
+        return new SingleResourceResponse($route, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/routes/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_update_routes", requirements={"id"=".+"})
-   */
-  public function updateAction(Request $request, $id): Response {
+    /**
+     * @Route("/api/{version}/content/routes/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_content_update_routes", requirements={"id"=".+"})
+     */
+    public function updateAction(Request $request, $id): Response {
     $objectManager = $this->entityManager;
     $route = $this->findOr404($id);
     $previousRoute = clone $route;
@@ -154,27 +154,27 @@ 
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $route = $this->routeService->updateRoute($previousRoute, $form->getData());
+        $route = $this->routeService->updateRoute($previousRoute, $form->getData());
 
-      $objectManager->flush();
+        $objectManager->flush();
 
-      return $this->handleView(View::create($route, 200));
+        return $this->handleView(View::create($route, 200));
     }
 
     return $this->handleView(View::create($form, 400));
-  }
+    }
 
-  private function findOr404($id) {
+    private function findOr404($id) {
     if (null === $route = $this->routeProvider->getOneById($id)) {
-      throw new NotFoundHttpException('Route was not found.');
+        throw new NotFoundHttpException('Route was not found.');
     }
 
     return $route;
-  }
+    }
 
-  private function ensureRouteExists($name) {
+    private function ensureRouteExists($name) {
     if (null !== $this->routeRepository->findOneByName($name)) {
-      throw new ConflictHttpException(sprintf('Route "%s" already exists!', $name));
+        throw new ConflictHttpException(sprintf('Route "%s" already exists!', $name));
+    }
     }
-  }
 }

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

Indentation +17 added lines, -17 removed lines

@@ -28,25 +28,25 @@ 
 use Symfony\Component\HttpFoundation\Request;
 
 class RelatedArticleController extends AbstractController {
-  private RelatedArticleRepositoryInterface $relatedArticleRepository;
-  private ArticleProviderInterface $articleProvider;
-  private EventDispatcherInterface $eventDispatcher;
+    private RelatedArticleRepositoryInterface $relatedArticleRepository;
+    private ArticleProviderInterface $articleProvider;
+    private EventDispatcherInterface $eventDispatcher;
 
-  /**
-   * @param RelatedArticleRepositoryInterface $relatedArticleRepository
-   * @param ArticleProviderInterface $articleProvider
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(RelatedArticleRepositoryInterface $relatedArticleRepository,
-                              ArticleProviderInterface          $articleProvider,
-                              EventDispatcherInterface          $eventDispatcher) {
+    /**
+     * @param RelatedArticleRepositoryInterface $relatedArticleRepository
+     * @param ArticleProviderInterface $articleProvider
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(RelatedArticleRepositoryInterface $relatedArticleRepository,
+                                ArticleProviderInterface          $articleProvider,
+                                EventDispatcherInterface          $eventDispatcher) {
     $this->relatedArticleRepository = $relatedArticleRepository;
     $this->articleProvider = $articleProvider;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
 
-  public function listAction(Request $request, string $id) {
+    public function listAction(Request $request, string $id) {
     $article = $this->findOr404($id);
 
     $repository = $this->relatedArticleRepository;
@@ -61,15 +61,15 @@ 
     );
 
     return new ResourcesListResponse($items);
-  }
+    }
 
-  private function findOr404(string $id): ArticleInterface {
+    private function findOr404(string $id): ArticleInterface {
     $article = $this->articleProvider->getOneById($id);
 
     if (null === $article) {
-      throw new NotFoundHttpException(sprintf('Article "%s" was not found.', $id));
+        throw new NotFoundHttpException(sprintf('Article "%s" was not found.', $id));
     }
 
     return $article;
-  }
+    }
 }

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

Indentation +57 added lines, -57 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/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();
@@ -129,32 +129,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/WebhookBundle/Controller/AbstractAPIController.php

Indentation +28 added lines, -28 removed lines

@@ -32,59 +32,59 @@
 use Symfony\Component\HttpFoundation\Request;
 
 abstract class AbstractAPIController extends Controller {
-  public function listWebhooks(EventDispatcherInterface $eventDispatcher, RepositoryInterface $repository,
-                               Request         $request): ResourcesListResponse {
+    public function listWebhooks(EventDispatcherInterface $eventDispatcher, RepositoryInterface $repository,
+                                Request         $request): ResourcesListResponse {
     $webhooks = $repository->getPaginatedByCriteria($eventDispatcher, new Criteria(), $request->query->all('sorting',), new PaginationData($request));
 
     return new ResourcesListResponse($webhooks);
-  }
+    }
 
-  public function getSingleWebhook(WebhookInterface $webhook): SingleResourceResponse {
+    public function getSingleWebhook(WebhookInterface $webhook): SingleResourceResponse {
     return new SingleResourceResponse($webhook);
-  }
-
-  public function createWebhook(
-      RepositoryInterface  $ruleRepository,
-      FactoryInterface     $ruleFactory,
-      Request              $request,
-      FormFactoryInterface $formFactory
-  ): SingleResourceResponse {
+    }
+
+    public function createWebhook(
+        RepositoryInterface  $ruleRepository,
+        FactoryInterface     $ruleFactory,
+        Request              $request,
+        FormFactoryInterface $formFactory
+    ): SingleResourceResponse {
     $webhook = $ruleFactory->create();
     $form = $formFactory->createNamed('', WebhookType::class, $webhook);
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $ruleRepository->add($webhook);
+        $ruleRepository->add($webhook);
 
-      return new SingleResourceResponse($webhook, new ResponseContext(201));
+        return new SingleResourceResponse($webhook, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  public function deleteWebhook(RepositoryInterface $webhookRepository,
+    public function deleteWebhook(RepositoryInterface $webhookRepository,
                                 WebhookInterface    $webhook): SingleResourceResponse {
     $webhookRepository->remove($webhook);
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
-
-  public function updateWebhook(
-      ObjectManager        $objectManager,
-      Request              $request,
-      WebhookInterface     $webhook,
-      FormFactoryInterface $formFactory
-  ): SingleResourceResponse {
+    }
+
+    public function updateWebhook(
+        ObjectManager        $objectManager,
+        Request              $request,
+        WebhookInterface     $webhook,
+        FormFactoryInterface $formFactory
+    ): SingleResourceResponse {
     $form = $formFactory->createNamed('', WebhookType::class, $webhook, ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
     if ($form->isSubmitted() && $form->isValid()) {
-      $objectManager->flush();
-      $objectManager->refresh($webhook);
+        $objectManager->flush();
+        $objectManager->refresh($webhook);
 
-      return new SingleResourceResponse($webhook);
+        return new SingleResourceResponse($webhook);
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 }