vendor/crehler/mojebambino-catalog/src/Controller/StoreApi/CatalogController.php line 167

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  3. /**
  4.  * @copyright 2020 Crehler Sp. z o. o.
  5.  * @link https://crehler.com/
  6.  * @support support@crehler.com
  7.  *
  8.  * @author Mateusz Flasiński
  9.  *
  10.  * For the full copyright and license information, please view the LICENSE
  11.  * file that was distributed with this source code.
  12.  */
  14. namespace Crehler\Catalog\Controller\StoreApi;
  16. use Crehler\Catalog\Content\BookmarksResponse;
  17. use Crehler\Catalog\Content\CatalogBasicDataResponse;
  18. use Crehler\Catalog\Content\CatalogFileResponse;
  19. use Crehler\Catalog\Content\CatalogFlatDataResponse;
  20. use Crehler\Catalog\Content\CatalogPageDetailResponse;
  21. use Crehler\Catalog\Content\StoreApiCatalogResponse;
  22. use Crehler\Catalog\Content\TableOfContentsResponse;
  23. use Crehler\Catalog\Entity\Catalog\CatalogEntity;
  24. use Crehler\Catalog\Service\CatalogCacheManager;
  25. use Crehler\Catalog\Service\CatalogReader\BookmarksTreeService;
  26. use Crehler\Catalog\Service\CatalogReader\Loader\CatalogPageLoader;
  27. use Crehler\Catalog\Service\CatalogReader\Loader\TableOfContentsLoader;
  28. use Crehler\Catalog\Service\FlatDataManager\FlatLoaderInterface;
  29. use Crehler\Catalog\Service\PdfMergeService;
  30. use OpenApi\Annotations as OA;
  31. use Shopware\Core\Framework\DataAbstractionLayer\EntityRepositoryInterface;
  32. use Shopware\Core\Framework\DataAbstractionLayer\Search\Criteria;
  33. use Shopware\Core\Framework\Routing\Annotation\RouteScope;
  34. use Shopware\Core\System\SalesChannel\SalesChannelContext;
  35. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  36. use Symfony\Component\HttpFoundation\JsonResponse;
  37. use Symfony\Component\HttpFoundation\Request;
  38. use Symfony\Component\HttpFoundation\Response;
  39. use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
  40. use Symfony\Component\Routing\Annotation\Route;
  42. /**
  43.  * @RouteScope(scopes={"store-api"})
  44.  */
  45. class CatalogController
  46. {
  47.     private EntityRepositoryInterface $catalogPageRepository;
  48.     private TableOfContentsLoader $contentsLoader;
  49.     private EntityRepositoryInterface $catalogRepository;
  50.     private BookmarksTreeService $bookmarksTreeService;
  51.     private CatalogPageLoader $catalogPageLoader;
  52.     private CatalogCacheManager $cacheManager;
  53.     private FlatLoaderInterface $catalogFlatLoader;
  54.     private PdfMergeService $pdfMergeService;
  56.     public function __construct(EntityRepositoryInterface $catalogPageRepository,
  57.                                 TableOfContentsLoader $contentsLoader,
  58.                                 EntityRepositoryInterface $catalogRepository,
  59.                                 BookmarksTreeService $bookmarksTreeService,
  60.                                 CatalogPageLoader $catalogPageLoader,
  61.                                 CatalogCacheManager $cacheManager,
  62.                                 FlatLoaderInterface $catalogFlatLoader,
  63.                                 PdfMergeService $pdfMergeService)
  64.     {
  65.         $this->catalogPageRepository = $catalogPageRepository;
  66.         $this->contentsLoader = $contentsLoader;
  67.         $this->catalogRepository = $catalogRepository;
  68.         $this->bookmarksTreeService = $bookmarksTreeService;
  69.         $this->catalogPageLoader = $catalogPageLoader;
  70.         $this->cacheManager = $cacheManager;
  71.         $this->catalogFlatLoader = $catalogFlatLoader;
  72.         $this->pdfMergeService = $pdfMergeService;
  73.     }
  75.     /**
  76.      * @OA\Post(
  77.      *      path="/catalog/page",
  78.      *      description="Load a catalog",
  79.      *      operationId="readCatalogDetail",
  80.      *      tags={"Store API", "Catalog"},
  81.      * )
  82.      *
  83.      * @Route("/store-api/catalog/page", name="store-api.catalog.page", methods={"POST"})
  84.      */
  85.     public function page(Request $request, SalesChannelContext $context): StoreApiCatalogResponse
  86.     {
  87.         $pageId = $request->get('pageId', null);
  88.         if ($pageId === null) {
  89.             throw new NotFoundHttpException();
  90.         }
  92.         $cached = $this->cacheManager->getPage($pageId, $context);
  94.         if ($cached !== null) {
  95.             return new StoreApiCatalogResponse($cached);
  96.         }
  98.         $criteria = new Criteria([$pageId]);
  99.         $page = $this->catalogPageRepository->search($criteria, $context->getContext())->first();
  100.         if ($page === null) {
  101.             throw new NotFoundHttpException();
  102.         }
  104.         $this->cacheManager->savePage($page, $context);
  106.         return new StoreApiCatalogResponse($page);
  107.     }
  109.     /**
  110.      * @Route("/store-api/catalog/print-merge-prepare/{leftPdfId}/{rightPdfId}", name="store-api.catalog.print-merge-prepare", methods={"GET"})
  111.      */
  112.     public function printMergePrepare(string $leftPdfId, string $rightPdfId, SalesChannelContext $context): Response
  113.     {
  114.         $media = $this->pdfMergeService->getMedia($leftPdfId, $rightPdfId, $context);
  116.         return new JsonResponse(['success' => true, 'uuid' => $media->getId()]);
  117.     }
  119.     /**
  120.      * @Route("/store-api/catalog/flat", name="store-api.catalog.flat", methods={"POST"})
  121.      */
  122.     public function flat(Request $request, SalesChannelContext $context): CatalogFlatDataResponse
  123.     {
  124.         $catalogId = $request->get('catalogId', null);
  126.         if ($catalogId === null) {
  127.             throw new NotFoundHttpException();
  128.         }
  130.         $struct = $this->catalogFlatLoader->load($catalogId, $context);
  132.         return new CatalogFlatDataResponse($struct);
  133.     }
  135.     /**
  136.      * @Route("/store-api/catalog/basic", name="store-api.catalog.basic", methods={"POST"})
  137.      */
  138.     public function basic(Request $request, SalesChannelContext $context): Response
  139.     {
  140.         $catalogId = $request->get('catalogId', null);
  142.         if ($catalogId === null) {
  143.             throw new NotFoundHttpException();
  144.         }
  146. //        $cache = $this->cacheManager->getBasic($catalogId, $context);
  147. //
  148. //        if ($cache !== null) {
  149. //            return new CatalogBasicDataResponse($cache);
  150. //        }
  152.         $criteria = new Criteria([$catalogId]);
  153.         $criteria->addAssociation('productBoxImageMedia');
  154.         $catalog = $this->catalogRepository->search($criteria, $context->getContext())->first();
  156.         if ($catalog === null) {
  157.             throw new NotFoundHttpException();
  158.         }
  160.         $this->cacheManager->saveBasic($catalogId, $catalog, $context);
  161.         return new CatalogBasicDataResponse($catalog);
  162.     }
  164.     /**
  165.      * @Route("/store-api/catalog/tableOfContents", name="store-api.catalog.table-of-contents", methods={"POST"})
  166.      */
  167.     public function tableOfContents(Request $request, SalesChannelContext $context): TableOfContentsResponse
  168.     {
  169.         $catalogId = $request->get('catalogId', null);
  170.         if ($catalogId === null) {
  171.             throw new NotFoundHttpException();
  172.         }
  173.         $limit = (int) $request->get('limit', 50);
  174.         $offset = (int) $request->get('offset', 0);
  176.         $cached = $this->cacheManager->getTableOfContents($catalogId, $limit, $offset);
  178.         if ($cached !== null) {
  179.             return new TableOfContentsResponse($cached);
  180.         }
  182.         $contests = $this->contentsLoader->load($catalogId, $context, $offset, $limit);
  184.         $this->cacheManager->setTableOfContents($catalogId, $limit, $offset, $contests);
  186.         return new TableOfContentsResponse($contests);
  187.     }
  189.     /**
  190.      * @Route("/store-api/catalog/bookmark", name="store-api.catalog.bookmark", methods={"POST"})
  191.      */
  192.     public function bookmark(Request $request, SalesChannelContext $context)
  193.     {
  194.         $catalogId = $request->get('catalogId', null);
  196.         if ($catalogId === null) {
  197.             throw new NotFoundHttpException();
  198.         }
  200.         $cache = $this->cacheManager->getBookmark($catalogId, $context);
  202.         if ($cache !== null) {
  203.             return new BookmarksResponse($cache);
  204.         }
  206.         $tree = $this->bookmarksTreeService->getTree($catalogId, $context->getContext(), $context);
  208.         $this->cacheManager->saveBookmark($catalogId, $tree, $context);
  210.         return new BookmarksResponse($tree);
  211.     }
  213.     /**
  214.      * @Route("/store-api/catalog/products", name="store-api.catalog.products", methods={"POST"})
  215.      */
  216.     public function products(Request $request, SalesChannelContext $context)
  217.     {
  218.         $pageId = $request->get('pageId', null);
  219.         $catalogId = $request->get('catalogId', null);
  221.         if ($pageId === null || $catalogId === null) {
  222.             throw new NotFoundHttpException();
  223.         }
  225.         $cache = $this->cacheManager->getProduct($pageId, $context);
  226.         if ($cache !== null) {
  227.             return new JsonResponse($cache);
  228.         }
  230.         $products = $this->catalogPageLoader->getProducts($pageId);
  231.         $this->cacheManager->saveProduct($products, $pageId, $catalogId, $context);
  233.         return new JsonResponse($products);
  234.     }
  236.     /**
  237.      * @Route("/store-api/catalog/page-detail", name="store-api.catalog.page-detail", methods={"POST"})
  238.      */
  239.     public function pageDetail(Request $request, SalesChannelContext $context)
  240.     {
  241.         $pageId = $request->get('pageId', null);
  242.         $displayMode = (int) $request->get('displayMode', 1);
  243.         if ($pageId === null) {
  244.             throw new NotFoundHttpException();
  245.         }
  247. //        $cache = $this->cacheManager->getPageDetail($pageId, $displayMode, $context);
  248. //        if ($cache !== null) {
  249. //            return new CatalogPageDetailResponse($cache);
  250. //        }
  252.         $page = $this->catalogPageLoader->getPageDetail($pageId, $context, $displayMode);
  254.         $this->cacheManager->savePageDetail($pageId, $displayMode, $page, $context);
  255.         return new CatalogPageDetailResponse($page);
  256.     }
  258.     /**
  259.      * @Route("/store-api/catalog/file", name="store-api.catalog.file", methods={"POST"})
  260.      */
  261.     public function file(Request $request, SalesChannelContext $context) //TODO add cache
  262.     {
  263.         $catalogId = $request->get('catalogId', null);
  264.         if ($catalogId === null) {
  265.             throw new NotFoundHttpException();
  266.         }
  268.         $criteria = new Criteria([$catalogId]);
  269.         $criteria->addAssociation('pdf');
  271.         /** @var CatalogEntity $catalog */
  272.         $catalog = $this->catalogRepository->search($criteria, $context->getContext())->first();
  274.         return new CatalogFileResponse($catalog->getPdf());
  275.     }
  276. }