superdesk / web-publisher

src/SWP/Bundle/CoreBundle/MessageHandler/Message/ContentPushMessage.php

Indentation +2 added lines, -2 removed lines

@@ -43,8 +43,8 @@
     public function toArray(): array
     {
         return [
-          'tenant' => $this->tenantId,
-          'content' => $this->content,
+            'tenant' => $this->tenantId,
+            'content' => $this->content,
         ];
     }
 }

src/SWP/Bundle/CoreBundle/Migrations/Version20180605111249.php

Indentation +1 added lines, -1 removed lines

@@ -39,7 +39,7 @@
     /**
      * @param Schema $schema
      */
-   public function postUp(Schema $schema) : void
+    public function postUp(Schema $schema) : void
     {
         $entityManager = $this->container->get('doctrine.orm.default_entity_manager');
         $query = $entityManager

src/SWP/Bundle/CoreBundle/Migrations/2018/10/Version20181008115755.php

Indentation +1 added lines, -1 removed lines

@@ -39,7 +39,7 @@
     /**
      * @param Schema $schema
      */
-   public function postUp(Schema $schema) : void
+    public function postUp(Schema $schema) : void
     {
         $entityManager = $this->container->get('doctrine.orm.default_entity_manager');
         $query = $entityManager

src/SWP/Bundle/CoreBundle/Migrations/Version20180314091410.php

Indentation +1 added lines, -1 removed lines

@@ -39,7 +39,7 @@
     /**
      * @param Schema $schema
      */
-   public function postUp(Schema $schema) : void
+    public function postUp(Schema $schema) : void
     {
         $entityManager = $this->container->get('doctrine.orm.default_entity_manager');
         $query = $entityManager

src/SWP/Bundle/ElasticSearchBundle/Controller/Api/PackageSearchController.php

Indentation +16 added lines, -16 removed lines

@@ -32,27 +32,27 @@ 
 
 class PackageSearchController extends AbstractController {
 
-  private PaginatorInterface $paginator;
-  private EventDispatcherInterface $eventDispatcher;
-  private CachedTenantContext $cachedTenantContext;
+    private PaginatorInterface $paginator;
+    private EventDispatcherInterface $eventDispatcher;
+    private CachedTenantContext $cachedTenantContext;
 
-  /**
-   * @param PaginatorInterface $paginator
-   * @param EventDispatcherInterface $eventDispatcher
-   * @param CachedTenantContext $cachedTenantContext
-   */
-  public function __construct(PaginatorInterface  $paginator, EventDispatcherInterface $eventDispatcher,
-                              CachedTenantContext $cachedTenantContext) {
+    /**
+     * @param PaginatorInterface $paginator
+     * @param EventDispatcherInterface $eventDispatcher
+     * @param CachedTenantContext $cachedTenantContext
+     */
+    public function __construct(PaginatorInterface  $paginator, EventDispatcherInterface $eventDispatcher,
+                                CachedTenantContext $cachedTenantContext) {
     $this->paginator = $paginator;
     $this->eventDispatcher = $eventDispatcher;
     $this->cachedTenantContext = $cachedTenantContext;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/packages/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_list_packages")
-   */
-  public function searchAction(Request $request, RepositoryManagerInterface $repositoryManager) {
+    /**
+     * @Route("/api/{version}/packages/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_list_packages")
+     */
+    public function searchAction(Request $request, RepositoryManagerInterface $repositoryManager) {
     $this->eventDispatcher->dispatch( new GenericEvent(), MultiTenancyEvents::TENANTABLE_DISABLE);
     $currentTenant = $this->cachedTenantContext->getTenant();
 
@@ -106,5 +106,5 @@ 
     );
 
     return new ResourcesListResponse($pagination, $responseContext);
-  }
+    }
 }

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

Indentation +18 added lines, -18 removed lines

@@ -28,24 +28,24 @@ 
 
 class SubscriptionController extends Controller {
 
-  private SubscriptionsProviderInterface $subscriptionsProvider;
-  private RepositoryInterface $userRepository;
-
-  /**
-   * @param SubscriptionsProviderInterface $subscriptionsProvider
-   * @param RepositoryInterface $userRepository
-   */
-  public function __construct(SubscriptionsProviderInterface $subscriptionsProvider,
-                              RepositoryInterface            $userRepository) {
+    private SubscriptionsProviderInterface $subscriptionsProvider;
+    private RepositoryInterface $userRepository;
+
+    /**
+     * @param SubscriptionsProviderInterface $subscriptionsProvider
+     * @param RepositoryInterface $userRepository
+     */
+    public function __construct(SubscriptionsProviderInterface $subscriptionsProvider,
+                                RepositoryInterface            $userRepository) {
     $this->subscriptionsProvider = $subscriptionsProvider;
     $this->userRepository = $userRepository;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/subscriptions/{userId}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_paywall_list_subscriptions", requirements={"id"="\d+"})
-   */
-  public function getAction(Request $request, int $userId) {
+    /**
+     * @Route("/api/{version}/subscriptions/{userId}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_paywall_list_subscriptions", requirements={"id"="\d+"})
+     */
+    public function getAction(Request $request, int $userId) {
     $subscriptionsProvider = $this->subscriptionsProvider;
 
     $filters = [
@@ -58,15 +58,15 @@ 
     $subscriptions = $subscriptionsProvider->getSubscriptions($user, $filters);
 
     return new SingleResourceResponse($subscriptions);
-  }
+    }
 
-  private function findOr404(int $id) {
+    private function findOr404(int $id) {
     $user = $this->userRepository->findOneById($id);
 
     if (!$user instanceof UserInterface) {
-      throw new NotFoundHttpException(sprintf('User with id "%s" was not found.', $id));
+        throw new NotFoundHttpException(sprintf('User with id "%s" was not found.', $id));
     }
 
     return $user;
-  }
+    }
 }

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

Indentation +35 added lines, -35 removed lines

@@ -29,40 +29,40 @@ 
 
 class ExternalDataController extends AbstractController {
 
-  private PackageRepositoryInterface $packageRepository;
-  private FactoryInterface $factory;
-
-  /**
-   * @param PackageRepositoryInterface $packageRepository
-   * @param FactoryInterface $factory
-   */
-  public function __construct(PackageRepositoryInterface $packageRepository, FactoryInterface $factory) {
+    private PackageRepositoryInterface $packageRepository;
+    private FactoryInterface $factory;
+
+    /**
+     * @param PackageRepositoryInterface $packageRepository
+     * @param FactoryInterface $factory
+     */
+    public function __construct(PackageRepositoryInterface $packageRepository, FactoryInterface $factory) {
     $this->packageRepository = $packageRepository;
     $this->factory = $factory;
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/extra/{slug}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PUT"}, name="swp_api_core_add_extra_data")
-   */
-  public function setAction(Request $request, string $slug): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/packages/extra/{slug}", options={"expose"=true}, defaults={"version"="v2"}, methods={"PUT"}, name="swp_api_core_add_extra_data")
+     */
+    public function setAction(Request $request, string $slug): SingleResourceResponseInterface {
     $packageRepository = $this->packageRepository;
     $existingPackage = $packageRepository->findOneBy(['slugline' => $slug]);
     if (null === $existingPackage) {
-      throw new NotFoundHttpException(sprintf('Package with slug %s was not found', $slug));
+        throw new NotFoundHttpException(sprintf('Package with slug %s was not found', $slug));
     }
 
     $externalData = $existingPackage->getExternalData();
     if (null === $externalData) {
-      foreach ($externalData as $data) {
+        foreach ($externalData as $data) {
         $packageRepository->remove($data);
-      }
-      $packageRepository->flush();
+        }
+        $packageRepository->flush();
     }
 
     if (null !== $request->getContent()) {
-      $validJson = self::getArrayFromJson($request->getContent());
-      $responseData = [];
-      foreach ($validJson as $key => $value) {
+        $validJson = self::getArrayFromJson($request->getContent());
+        $responseData = [];
+        foreach ($validJson as $key => $value) {
         /** @var ExternalDataInterface $externalData */
         $externalData = $this->factory->create();
         $externalData->setKey($key);
@@ -70,45 +70,45 @@ 
         $externalData->setPackage($existingPackage);
         $packageRepository->persist($externalData);
         $responseData[$externalData->getKey()] = $externalData->getValue();
-      }
-      $packageRepository->flush();
+        }
+        $packageRepository->flush();
 
-      return new SingleResourceResponse($responseData, new ResponseContext(200));
+        return new SingleResourceResponse($responseData, new ResponseContext(200));
     }
 
     return new SingleResourceResponse(['Provided request content is not valid JSON'], new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/packages/extra/{slug}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_extra_data")
-   */
-  public function getAction(string $slug): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/packages/extra/{slug}", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_get_extra_data")
+     */
+    public function getAction(string $slug): SingleResourceResponseInterface {
     $packageRepository = $this->packageRepository;
     $existingPackage = $packageRepository->findOneBy(['slugline' => $slug]);
     if (null === $existingPackage) {
-      throw new NotFoundHttpException(sprintf('package with slug %s was not found', $slug));
+        throw new NotFoundHttpException(sprintf('package with slug %s was not found', $slug));
     }
 
     $externalData = $existingPackage->getExternalData();
     if (null === $externalData) {
-      return new SingleResourceResponse([], new ResponseContext(200));
+        return new SingleResourceResponse([], new ResponseContext(200));
     }
 
     $responseData = [];
     /** @var ExternalDataInterface $data */
     foreach ($externalData as $data) {
-      $responseData[$data->getKey()] = $data->getValue();
+        $responseData[$data->getKey()] = $data->getValue();
     }
 
     return new SingleResourceResponse($responseData, new ResponseContext(200));
-  }
+    }
 
-  private static function getArrayFromJson($jsonString) {
+    private static function getArrayFromJson($jsonString) {
     $jsonArray = json_decode($jsonString, true);
     if (null === $jsonArray || JSON_ERROR_NONE !== json_last_error()) {
-      throw new \UnexpectedValueException('Provided request content is not valid JSON');
+        throw new \UnexpectedValueException('Provided request content is not valid JSON');
     }
 
     return $jsonArray;
-  }
+    }
 }

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

Indentation +53 added lines, -53 removed lines

@@ -37,45 +37,45 @@ 
 
 class RedirectRouteController extends AbstractController {
 
-  private FormFactoryInterface $formFactory;
-  private RepositoryInterface $redirectRouteRepository;
-  private EntityManagerInterface $entityManager;
-  private FactoryInterface $redirectRouteFactory;
-  private EventDispatcherInterface $eventDispatcher;
-
-  /**
-   * @param FormFactoryInterface $formFactory
-   * @param RepositoryInterface $redirectRouteRepository
-   * @param EntityManagerInterface $entityManager
-   * @param FactoryInterface $redirectRouteFactory
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(FormFactoryInterface   $formFactory, RepositoryInterface $redirectRouteRepository,
-                              EntityManagerInterface $entityManager, FactoryInterface $redirectRouteFactory,
-                              EventDispatcherInterface        $eventDispatcher) {
+    private FormFactoryInterface $formFactory;
+    private RepositoryInterface $redirectRouteRepository;
+    private EntityManagerInterface $entityManager;
+    private FactoryInterface $redirectRouteFactory;
+    private EventDispatcherInterface $eventDispatcher;
+
+    /**
+     * @param FormFactoryInterface $formFactory
+     * @param RepositoryInterface $redirectRouteRepository
+     * @param EntityManagerInterface $entityManager
+     * @param FactoryInterface $redirectRouteFactory
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(FormFactoryInterface   $formFactory, RepositoryInterface $redirectRouteRepository,
+                                EntityManagerInterface $entityManager, FactoryInterface $redirectRouteFactory,
+                                EventDispatcherInterface        $eventDispatcher) {
     $this->formFactory = $formFactory;
     $this->redirectRouteRepository = $redirectRouteRepository;
     $this->entityManager = $entityManager;
     $this->redirectRouteFactory = $redirectRouteFactory;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
 
-  /**
-   * @Route("/api/{version}/redirects/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_list_redirect_routes")
-   */
-  public function listAction(Request $request) {
+    /**
+     * @Route("/api/{version}/redirects/", methods={"GET"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_list_redirect_routes")
+     */
+    public function listAction(Request $request) {
     $redirectRouteRepository = $this->redirectRouteRepository;
 
     $redirectRoutes = $redirectRouteRepository->getPaginatedByCriteria($this->eventDispatcher, new Criteria(), $request->query->all('sorting'), new PaginationData($request));
 
     return new ResourcesListResponse($redirectRoutes);
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/redirects/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_redirect_route", requirements={"id"="\d+"})
-   */
-  public function deleteAction(int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/redirects/{id}", methods={"DELETE"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_delete_redirect_route", requirements={"id"="\d+"})
+     */
+    public function deleteAction(int $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     $redirectRoute = $this->findOr404($id);
 
@@ -83,69 +83,69 @@ 
     $objectManager->flush();
 
     return new SingleResourceResponse(null, new ResponseContext(204));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/redirects/", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_create_redirect_route")
-   */
-  public function createAction(Request $request): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/redirects/", methods={"POST"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_create_redirect_route")
+     */
+    public function createAction(Request $request): SingleResourceResponseInterface {
     $redirectRoute = $this->redirectRouteFactory->create();
     $form = $this->formFactory->createNamed('', RedirectRouteType::class, $redirectRoute, ['method' => $request->getMethod()]);
 
     $form->handleRequest($request);
 
     if ($this->checkIfSourceRouteExists($redirectRoute)) {
-      $this->ensureRedirectRouteExists($redirectRoute->getRouteName());
+        $this->ensureRedirectRouteExists($redirectRoute->getRouteName());
     }
 
     if ($form->isSubmitted() && $form->isValid()) {
-      if ($this->checkIfSourceRouteExists($redirectRoute)) {
+        if ($this->checkIfSourceRouteExists($redirectRoute)) {
         $redirectRoute->setStaticPrefix($redirectRoute->getRouteName());
-      } else {
+        } else {
         $redirectRoute->setStaticPrefix($redirectRoute->getRouteSource()->getStaticPrefix());
-      }
+        }
 
-      $this->redirectRouteRepository->add($redirectRoute);
+        $this->redirectRouteRepository->add($redirectRoute);
 
-      return new SingleResourceResponse($redirectRoute, new ResponseContext(201));
+        return new SingleResourceResponse($redirectRoute, new ResponseContext(201));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/redirects/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_update_redirect_route", requirements={"id"="\d+"})
-   */
-  public function updateAction(Request $request, int $id): SingleResourceResponseInterface {
+    /**
+     * @Route("/api/{version}/redirects/{id}", methods={"PATCH"}, options={"expose"=true}, defaults={"version"="v2"}, name="swp_api_core_update_redirect_route", requirements={"id"="\d+"})
+     */
+    public function updateAction(Request $request, int $id): SingleResourceResponseInterface {
     $objectManager = $this->entityManager;
     $redirectRoute = $this->findOr404($id);
     $form = $this->formFactory->createNamed('', RedirectRouteType::class, $redirectRoute, ['method' => $request->getMethod()]);
     $form->handleRequest($request);
 
     if ($form->isSubmitted() && $form->isValid()) {
-      $objectManager->flush();
+        $objectManager->flush();
 
-      return new SingleResourceResponse($redirectRoute, new ResponseContext(200));
+        return new SingleResourceResponse($redirectRoute, new ResponseContext(200));
     }
 
     return new SingleResourceResponse($form, new ResponseContext(400));
-  }
+    }
 
-  private function findOr404(int $id): RedirectRouteInterface {
+    private function findOr404(int $id): RedirectRouteInterface {
     if (null === $redirectRoute = $this->redirectRouteRepository->findOneById($id)) {
-      throw new NotFoundHttpException('Redirect route was not found.');
+        throw new NotFoundHttpException('Redirect route was not found.');
     }
 
     return $redirectRoute;
-  }
+    }
 
-  private function ensureRedirectRouteExists(?string $name): void {
+    private function ensureRedirectRouteExists(?string $name): void {
     if (null !== $this->redirectRouteRepository->findOneBy(['routeName' => $name])) {
-      throw new ConflictHttpException(sprintf('Redirect route "%s" already exists!', $name));
+        throw new ConflictHttpException(sprintf('Redirect route "%s" already exists!', $name));
+    }
     }
-  }
 
-  private function checkIfSourceRouteExists(RedirectRouteInterface $redirectRoute): bool {
+    private function checkIfSourceRouteExists(RedirectRouteInterface $redirectRoute): bool {
     return null === $redirectRoute->getRouteSource();
-  }
+    }
 }

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

Indentation +14 added lines, -14 removed lines

@@ -28,22 +28,22 @@ 
 
 class ArticleSourceController extends AbstractController {
 
-  private EntityRepository $entityRepository;
-  private EventDispatcherInterface $eventDispatcher;
-
-  /**
-   * @param EntityRepository $entityRepository
-   * @param EventDispatcherInterface $eventDispatcher
-   */
-  public function __construct(EntityRepository $entityRepository, EventDispatcherInterface $eventDispatcher) {
+    private EntityRepository $entityRepository;
+    private EventDispatcherInterface $eventDispatcher;
+
+    /**
+     * @param EntityRepository $entityRepository
+     * @param EventDispatcherInterface $eventDispatcher
+     */
+    public function __construct(EntityRepository $entityRepository, EventDispatcherInterface $eventDispatcher) {
     $this->entityRepository = $entityRepository;
     $this->eventDispatcher = $eventDispatcher;
-  }
+    }
 
-  /**
-   * @Route("/api/{version}/content/sources/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_article_sources")
-   */
-  public function listAction(Request $request): ResourcesListResponseInterface {
+    /**
+     * @Route("/api/{version}/content/sources/", options={"expose"=true}, defaults={"version"="v2"}, methods={"GET"}, name="swp_api_core_article_sources")
+     */
+    public function listAction(Request $request): ResourcesListResponseInterface {
     $sorting = $request->query->all('sorting');
     $lists = $this->entityRepository->getPaginatedByCriteria(
         $this->eventDispatcher,
@@ -52,5 +52,5 @@ 
         new PaginationData($request));
 
     return new ResourcesListResponse($lists);
-  }
+    }
 }