src/Controller/Api/ProductController.php line 362

Open in your IDE?
  1. <?php
  3. namespace App\Controller\Api;
  5. use App\Entity\Attribut;
  6. use App\Entity\AttributValue;
  7. use App\Entity\Category;
  8. use App\Entity\Creation;
  9. use App\Entity\FeatureFamily;
  10. use App\Entity\Folder;
  11. use App\Entity\Matrix;
  12. use App\Entity\Model;
  13. use App\Entity\ModelCategory;
  14. use App\Entity\Product;
  15. use App\Entity\ProductFeatureValue;
  16. use App\Entity\ProductMenuMaker;
  17. use App\Entity\ProductPrice;
  18. use App\Entity\ProductPriceMockup;
  19. use App\Service\ProductService;
  20. use App\Service\Rsa;
  21. use App\Service\SerializeService;
  22. use App\Service\Tools;
  23. use App\Service\TranslationService;
  24. use App\Repository\MatrixRepository;
  25. use App\Repository\ModelCategoryRepository;
  26. use Doctrine\Common\Collections\ArrayCollection;
  27. use Doctrine\ORM\EntityManagerInterface;
  28. use Exception;
  29. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  30. use Symfony\Component\HttpFoundation\JsonResponse;
  31. use Symfony\Component\HttpFoundation\Request;
  32. use Symfony\Component\Routing\Annotation\Route;
  33. use Symfony\Contracts\Translation\TranslatorInterface;
  35. /**
  36.  * Class AppController
  37.  * @package App\Controller\Api
  38.  * @Route(path="/api/product", name="api_product")
  39.  */
  40. class ProductController extends AbstractController
  41. {
  42.     private EntityManagerInterface $em;
  43.     private SerializeService $serializeService;
  44.     private TranslationService $translationService;
  45.     private ProductService $productService;
  46.     private Rsa $rsa;
  47.     private TranslatorInterface $translator;
  49.     public function __construct(
  50.         EntityManagerInterface $em,
  51.         SerializeService $serializeService,
  52.         TranslationService $translationService,
  53.         ProductService $productService,
  54.         Rsa $rsa,
  55.         TranslatorInterface $translator
  56.     ) {
  57.         $this->em = $em;
  58.         $this->serializeService = $serializeService;
  59.         $this->translationService = $translationService;
  60.         $this->productService = $productService;
  61.         $this->rsa = $rsa;
  62.         $this->translator = $translator;
  63.     }
  65.     /**
  66.      * @param Product $product
  67.      * @param Request $request
  68.      * @return JsonResponse
  69.      * @throws Exception
  70.      * @Route("/{product}", name="", requirements={"product"="\d+"})
  71.      */
  72.     public function find(Product $product, Request $request): JsonResponse
  73.     {
  74.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  75.             return new JsonResponse([
  76.                 'success' => false,
  77.                 'message' => $this->translator->trans('global.invalidToken'),
  78.             ]);
  79.         }
  81.         if ($product->isCommandable()) {
  82.             return new JsonResponse([
  83.                 'success' => true,
  84.                 'product' => $this->serializeService->serializeProduct($product),
  85.             ]);
  86.         }
  88.         return new JsonResponse([
  89.             'success' => false,
  90.         ]);
  91.     }
  93.     /**
  94.      * @param Request $request
  95.      * @return JsonResponse
  96.      * @throws Exception
  97.      * @Route("/find-by-const-name", name="_findbyconstname")
  98.      */
  99.     public function findByConstName(Request $request): JsonResponse
  100.     {
  101.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  102.             return new JsonResponse([
  103.                 'success' => false,
  104.                 'message' => $this->translator->trans('global.invalidToken'),
  105.             ]);
  106.         }
  108.         $data = Tools::getRequestData($request);
  110.         /** @var Product $product */
  111.         $product = $this->em->getRepository(Product::class)->findBy(array('constName' => $data['productConstName']));
  113.         if (!is_null($product)) {
  114.             if ($product[0]->isCommandable()) {
  115.                 return new JsonResponse([
  116.                     'success' => true,
  117.                     'product' => $this->serializeService->serializeProduct($product[0]),
  118.                 ]);
  119.             }
  120.         }
  122.         return new JsonResponse([
  123.             'success' => false,
  124.         ]);
  125.     }
  127.     /**
  128.      * @param Request $request
  129.      * @return JsonResponse
  130.      * @Route("/category", name="_category")
  131.      * @throws Exception
  132.      */
  133.     public function findProductCategories(Request $request): JsonResponse
  134.     {
  135.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  136.             return new JsonResponse([
  137.                 'success' => false,
  138.                 'message' => $this->translator->trans('global.invalidToken'),
  139.             ]);
  140.         }
  142.         /** @var Category[] $productCategories */
  143.         $productCategories = $this->em->getRepository(Category::class)->findBy([], ['position' => 'ASC']);
  145.         $data = [];
  147.         foreach ($productCategories as $productCategory) {
  148.             if ($productCategory->isActive()) {
  149.                 $products = [];
  151.                 /** @var Product $product */
  152.                 foreach ($productCategory->getProducts() as $product) {
  153.                     if ($product->isCommandable()) {
  154.                         $products[] = $this->serializeService->serializeProduct($product);
  155.                     }
  156.                 }
  158.                 if (count($products) > 0) {
  159.                     $data[] = [
  160.                         'id' => $productCategory->getId(),
  161.                         'name' => $this->translationService->translate($productCategory->getCategoryTranslations())->getName(),
  162.                         'position' => $productCategory->getId(),
  163.                         'active' => $productCategory->getId(),
  164.                         'products' => $products,
  165.                     ];
  166.                 }
  167.             }
  168.         }
  170.         return new JsonResponse([
  171.             'success' => true,
  172.             'productCategories' => $data,
  173.         ]);
  174.     }
  176.     /**
  177.      * @param Product $product
  178.      * @param Request $request
  179.      * @return JsonResponse
  180.      * @Route("/{product}/model-category", name="_model_category", requirements={"product"="\d+"})
  181.      */
  182.     public function findModelCategories(Product $product, Request $request): JsonResponse
  183.     {
  184.         if ($request->headers->get('Authorization')) {
  185.             $apiKey = substr($request->headers->get('Authorization'), 6);
  186.         } else {
  187.             $apiKey = $request->request->get('apiKey');
  188.         }
  190.         if (!$this->rsa->isValidToken($apiKey)) {
  191.             return new JsonResponse([
  192.                 'success' => false,
  193.                 'message' => $this->translator->trans('global.invalidToken'),
  194.             ]);
  195.         }
  197.         $data = Tools::getRequestData($request);
  199.         $productMenuMaker = null;
  200.         $matrixes = [];
  202.         if (array_key_exists('currentFeatureValueIds', $data)) {
  203.             $productFeatureValues = new ArrayCollection();
  204.             foreach ($data['currentFeatureValueIds'] as $currentFeatureValueId) {
  205.                 $productFeatureValues->add($this->em->getRepository(ProductFeatureValue::class)->find($currentFeatureValueId));
  206.             }
  208.             if ($productFeatureValues->count() > 0) {
  209.                 /** @var ProductMenuMaker $productMenuMaker */
  210.                 $productMenuMaker = $this->em->getRepository(ProductMenuMaker::class)->findByProductFeatureValues($productFeatureValues);
  211.             }
  212.         }
  214.         $format = $request->query->get('format', '21x30-1v');
  216.         $modelCategories = [];
  218.         /** @var ModelCategory $modelCategory */
  219.         foreach ($product->getModelCategories() as $modelCategory) {
  220.             $models = [];
  222.             /** @var Model $model */
  223.             foreach ($modelCategory->getModels() as $model) {
  224.                 if ($model->isActive()) {
  225.                     $models[] = $this->serializeService->serializeModel($model, $format);
  226.                 }
  227.             }
  229.             if (!is_null($productMenuMaker)) {
  230.                 /** @var Matrix $matrixActive */
  231.                 foreach ($productMenuMaker->getMatrixActives() as $matrixActive) {
  232.                     if (!is_null($matrixActive->getMatrixSet()) && $matrixActive->getMatrixSet()->getModelCategory()->getId() === $modelCategory->getId()) {
  233.                         $matrixes[] = $this->serializeService->serializeMatrix($matrixActive);
  234.                     }
  235.                 }
  236.             }
  238.             $modelCategories[] = [
  239.                 'id' => $modelCategory->getId(),
  240.                 'name' => $this->translationService->translate($modelCategory->getModelCategoryTranslations())->getName(),
  241.                 'reference' => $modelCategory->getReference(),
  242.                 'position' => $modelCategory->getPosition(),
  243.                 'models' => $models,
  244.                 'matrixes' => $matrixes,
  245.             ];
  246.         }
  248.         usort($modelCategories, function ($a, $b) {
  249.             return $a['position'] <=> $b['position'];
  250.         });
  252.         return new JsonResponse([
  253.             'success' => true,
  254.             'modelCategories' => $modelCategories,
  255.         ]);
  256.     }
  258.     /**
  259.      * @param Product $product
  260.      * @param Request $request
  261.      * @return JsonResponse
  262.      * @Route("/{product}/model-category-without-model", name="_model_category_whithout_model", requirements={"product"="\d+"})
  263.      */
  264.     public function findModelCategoriesWithoutModels(Product $product, Request $request): JsonResponse
  265.     {
  266.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  267.             return new JsonResponse([
  268.                 'success' => false,
  269.                 'message' => $this->translator->trans('global.invalidToken'),
  270.             ]);
  271.         }
  273.         $modelCategories = [];
  275.         /** @var ModelCategory $modelCategory */
  276.         foreach ($product->getModelCategories() as $modelCategory) {
  277.             $modelCategories[] = [
  278.                 'id' => $modelCategory->getId(),
  279.                 'name' => $this->translationService->translate($modelCategory->getModelCategoryTranslations())->getName(),
  280.                 'reference' => $modelCategory->getReference(),
  281.                 'position' => $modelCategory->getPosition(),
  282.             ];
  283.         }
  285.         return new JsonResponse([
  286.             'success' => true,
  287.             'modelCategories' => $modelCategories,
  288.         ]);
  289.     }
  291.     /**
  292.      * @param Product $product
  293.      * @param Request $request
  294.      * @return JsonResponse
  295.      * @Route("/{product}/models", name="_models", requirements={"product"="\d+"})
  296.      */
  297.     public function findModels(Product $product, Request $request): JsonResponse
  298.     {
  299.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  300.             return new JsonResponse([
  301.                 'success' => false,
  302.                 'message' => $this->translator->trans('global.invalidToken'),
  303.             ]);
  304.         }
  306.         $data = Tools::getRequestData($request);
  308.         $format = $request->query->get('format', '21x30-1v');
  309.         $productMenuMaker = null;
  310.         $models = [];
  312.         if (array_key_exists('currentFeatureValueIds', $data)) {
  313.             $productFeatureValues = new ArrayCollection();
  314.             foreach ($data['currentFeatureValueIds'] as $currentFeatureValueId) {
  315.                 $productFeatureValues->add($this->em->getRepository(ProductFeatureValue::class)->find($currentFeatureValueId));
  316.             }
  318.             if ($productFeatureValues->count() > 0) {
  319.                 /** @var ProductMenuMaker $productMenuMaker */
  320.                 $productMenuMaker = $this->em->getRepository(ProductMenuMaker::class)->findByProductFeatureValues($productFeatureValues);
  321.             }
  322.         }
  324.         /** @var ModelCategory $modelCategory */
  325.         foreach ($product->getModelCategories() as $modelCategory) {
  326.             /** @var Model $model */
  327.             foreach ($modelCategory->getModels() as $model) {
  328.                 if ($model->isActive()) {
  329.                     $models[] = $this->serializeService->serializeModel($model, $format);
  330.                 }
  331.             }
  333.             if (!is_null($productMenuMaker)) {
  334.                 /** @var Matrix $matrixActive */
  335.                 foreach ($productMenuMaker->getMatrixActives() as $matrixActive) {
  336.                     if (!is_null($matrixActive->getMatrixSet()) && $matrixActive->getMatrixSet()->getModelCategory()->getId() === $modelCategory->getId()) {
  337.                         $matrix = $this->serializeService->serializeMatrix($matrixActive);
  338.                         $matrix['category'] = $modelCategory->getId(); // Change to the model category id instead of the matrix one
  339.                         $models[] = $matrix;
  340.                     }
  341.                 }
  342.             }
  343.         }
  345.         usort($models, function ($a, $b) {
  346.             return $a['position'] <=> $b['position'];
  347.         });
  349.         return new JsonResponse([
  350.             'success' => true,
  351.             'models' => $models,
  352.         ]);
  353.     }
  355.     /**
  356.      * @param Product $product
  357.      * @param Request $request
  358.      * @param ModelCategoryRepository $modelCategoryRepository
  359.      * @return JsonResponse
  360.      * @Route("/{product}/has-models", name="_has_models", requirements={"product"="\d+"})
  361.      */
  362.     public function hasModels(Product $product, Request $request, ModelCategoryRepository $modelCategoryRepository): JsonResponse
  363.     {
  364.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  365.             return new JsonResponse([
  366.                 'success' => false,
  367.                 'message' => $this->translator->trans('global.invalidToken'),
  368.             ]);
  369.         }
  371.         $hasModels = $modelCategoryRepository->hasAtLeastOneModelInCategories($product);
  373.         return new JsonResponse([
  374.             'success' => true,
  375.             'hasModels' => $hasModels,
  376.         ]);
  377.     }
  379.     /**
  380.      * @param Product $product
  381.      * @param Request $request
  382.      * @return JsonResponse
  383.      * @Route("/{product}/feature", name="_feature", requirements={"product"="\d+"})
  384.      */
  385.     public function findFeatures(Product $product, Request $request): JsonResponse
  386.     {
  387.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  388.             return new JsonResponse([
  389.                 'success' => false,
  390.                 'message' => $this->translator->trans('global.invalidToken'),
  391.             ]);
  392.         }
  394.         if (!$product->isCommandable()) {
  395.             return new JsonResponse([
  396.                 'success' => false,
  397.                 'url' => $this->generateUrl('app_index'),
  398.             ]);
  399.         }
  401.         $features = [];
  402.         foreach ($product->getProductFeatures() as $productFeature) {
  403.             $features[] = [
  404.                 'id' => $productFeature->getFeature()->getId(),
  405.                 'name' => $this->translationService->translate($productFeature->getFeature()->getFeatureTranslations())->getName(),
  406.                 'isCustomizable' => ($productFeature->getFeature()->getFeatureFamily()->getConstName() === FeatureFamily::CUSTOMIZABLE),
  407.                 'isPrintable' => ($productFeature->getFeature()->getFeatureFamily()->getConstName() === FeatureFamily::PRINTABLE),
  408.                 'isClassic' => ($productFeature->getFeature()->getFeatureFamily()->getConstName() === FeatureFamily::CLASSIC),
  409.                 'constName' => $productFeature->getFeature()->getConstName(),
  410.                 'printComConstName' => $productFeature->getFeature()->getPrintComConstName(),
  411.             ];
  412.         }
  414.         return new JsonResponse([
  415.             'success' => true,
  416.             'features' => $features,
  417.         ]);
  418.     }
  420.     /**
  421.      * @param Product $product
  422.      * @param Request $request
  423.      * @return JsonResponse
  424.      * @Route("/{product}/feature-value", name="_feature_value", requirements={"product"="\d+"})
  425.      * @throws Exception
  426.      */
  427.     public function findFeatureValues(Product $product, Request $request): JsonResponse
  428.     {
  429.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  430.             return new JsonResponse([
  431.                 'success' => false,
  432.                 'message' => $this->translator->trans('global.invalidToken'),
  433.             ]);
  434.         }
  436.         if (!$product->isCommandable()) {
  437.             return new JsonResponse([
  438.                 'success' => false,
  439.                 'url' => $this->generateUrl('app_index'),
  440.             ]);
  441.         }
  443.         //On envoie les features values commandables (prix + menumaker)
  444.         $featureValues = $this->productService->getProductFeatureValuesByProduct($product);
  446.         uasort($featureValues, function ($a, $b) {
  447.             return $a['position'] - $b['position'];
  448.         });
  450.         return new JsonResponse([
  451.             'success' => true,
  452.             'featureValues' => $featureValues,
  453.         ]);
  454.     }
  456.     /**
  457.      * @param Product $product
  458.      * @param Request $request
  459.      * @return JsonResponse
  460.      * @Route("/{product}/matrix-category", name="_matrix_category", requirements={"product"="\d+"})
  461.      */
  462.     public function findMatrixCategories(Product $product, Request $request): JsonResponse
  463.     {
  464.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  465.             return new JsonResponse([
  466.                 'success' => false,
  467.                 'message' => $this->translator->trans('global.invalidToken'),
  468.             ]);
  469.         }
  471.         $data = Tools::getRequestData($request);
  473.         $productFeatureValues = new ArrayCollection();
  474.         foreach ($data['currentFeatureValueIds'] as $currentFeatureValueId) {
  475.             $productFeatureValues->add($this->em->getRepository(ProductFeatureValue::class)->find($currentFeatureValueId));
  476.         }
  478.         $matrixCategories = [];
  480.         if ($productFeatureValues->count() > 0) {
  481.             /** @var ProductMenuMaker $productMenuMaker */
  482.             $productMenuMaker = $this->em->getRepository(ProductMenuMaker::class)->findByProductFeatureValues($productFeatureValues);
  484.             if (!is_null($productMenuMaker)) {
  485.                 /** @var Matrix $matrixActive */
  486.                 foreach ($productMenuMaker->getMatrixActives() as $matrixActive) {
  487.                     if (is_null($matrixActive->getMatrixSet())) {
  488.                         if (!isset($matrixCategories[$matrixActive->getMatrixCategory()->getId()])) {
  489.                             $matrixCategories[$matrixActive->getMatrixCategory()->getId()] = [
  490.                                 'id' => $matrixActive->getMatrixCategory()->getId(),
  491.                                 'reference' => $matrixActive->getMatrixCategory()->getReference(),
  492.                                 'name' => $this->translationService->translate($matrixActive->getMatrixCategory()->getMatrixCategoryTranslations())->getName(),
  493.                                 'matrixes' => [],
  494.                             ];
  495.                         }
  497.                         $matrixCategories[$matrixActive->getMatrixCategory()->getId()]['matrixes'][] = $this->serializeService->serializeMatrix($matrixActive, false);
  498.                     }
  499.                 }
  501.                 $matrixCategories = array_values($matrixCategories);
  502.             }
  503.         }
  505.         return new JsonResponse([
  506.             'success' => true,
  507.             'matrixCategories' => $matrixCategories,
  508.         ]);
  509.     }
  511.     /**
  512.      * @param Request $request
  513.      * @return JsonResponse
  514.      * @Route("/matrix-category-without-matrix", name="_matrix_category_without_matrix")
  515.      */
  516.     public function findMatrixCategoriesWithoutMatrices(Request $request): JsonResponse
  517.     {
  518.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  519.             return new JsonResponse([
  520.                 'success' => false,
  521.                 'message' => $this->translator->trans('global.invalidToken'),
  522.             ]);
  523.         }
  525.         $data = Tools::getRequestData($request);
  527.         $productFeatureValues = new ArrayCollection();
  528.         foreach ($data['currentFeatureValueIds'] as $currentFeatureValueId) {
  529.             $productFeatureValues->add($this->em->getRepository(ProductFeatureValue::class)->find($currentFeatureValueId));
  530.         }
  532.         $matrixCategories = [];
  534.         if ($productFeatureValues->count() > 0) {
  535.             /** @var ProductMenuMaker $productMenuMaker */
  536.             $productMenuMaker = $this->em->getRepository(ProductMenuMaker::class)->findByProductFeatureValues($productFeatureValues);
  538.             if (!is_null($productMenuMaker)) {
  539.                 /** @var Matrix $matrixActive */
  540.                 foreach ($productMenuMaker->getMatrixActives() as $matrixActive) {
  541.                     if (is_null($matrixActive->getMatrixSet())) {
  542.                         $categoryId = $matrixActive->getMatrixCategory()->getId();
  544.                         if (!isset($matrixCategories[$categoryId])) {
  545.                             $matrixCategories[$categoryId] = [
  546.                                 'id' => $categoryId,
  547.                                 'reference' => $matrixActive->getMatrixCategory()->getReference(),
  548.                                 'name' => $this->translationService->translate($matrixActive->getMatrixCategory()->getMatrixCategoryTranslations())->getName(),
  549.                             ];
  550.                         }
  551.                     }
  552.                 }
  554.                 $matrixCategories = array_values($matrixCategories);
  555.             }
  556.         }
  558.         return new JsonResponse([
  559.             'success' => true,
  560.             'matrixCategories' => $matrixCategories,
  561.         ]);
  562.     }
  564.     /**
  565.      * @param Request $request
  566.      * @return JsonResponse
  567.      * @Route("/matrices", name="_matrices")
  568.      */
  569.     public function findMatrices(Request $request): JsonResponse
  570.     {
  571.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  572.             return new JsonResponse([
  573.                 'success' => false,
  574.                 'message' => $this->translator->trans('global.invalidToken'),
  575.             ]);
  576.         }
  578.         $data = Tools::getRequestData($request);
  580.         $productFeatureValues = new ArrayCollection();
  581.         foreach ($data['currentFeatureValueIds'] as $currentFeatureValueId) {
  582.             $productFeatureValues->add($this->em->getRepository(ProductFeatureValue::class)->find($currentFeatureValueId));
  583.         }
  585.         $matrices = [];
  587.         if ($productFeatureValues->count() > 0) {
  588.             /** @var ProductMenuMaker $productMenuMaker */
  589.             $productMenuMaker = $this->em->getRepository(ProductMenuMaker::class)->findByProductFeatureValues($productFeatureValues);
  591.             if (!is_null($productMenuMaker)) {
  592.                 /** @var Matrix $matrixActive */
  593.                 foreach ($productMenuMaker->getMatrixActives() as $matrixActive) {
  594.                     if (is_null($matrixActive->getMatrixSet())) {
  595.                         $matrices[] = $this->serializeService->serializeMatrix($matrixActive, false);
  596.                     }
  597.                 }
  599.                 $matrices = array_values($matrices);
  600.             }
  601.         }
  603.         usort($matrices, function ($a, $b) {
  604.             return $a['position'] <=> $b['position'];
  605.         });
  607.         return new JsonResponse([
  608.             'success' => true,
  609.             'matrices' => $matrices,
  610.         ]);
  611.     }
  613.     /**
  614.      * @param Request $request
  615.      * @param MatrixRepository $matrixRepository
  616.      * @return JsonResponse
  617.      * @Route("/has-matrices", name="_has_matrices")
  618.      */
  619.     public function hasMatrices(Request $request, MatrixRepository $matrixRepository): JsonResponse
  620.     {
  621.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  622.             return new JsonResponse([
  623.                 'success' => false,
  624.                 'message' => $this->translator->trans('global.invalidToken'),
  625.             ]);
  626.         }
  628.         $data = Tools::getRequestData($request);
  629.         $featureValueIds = $data['currentFeatureValueIds'] ?? [];
  631.         $hasMatrices = $matrixRepository->hasAtLeastOneMatrixWithoutSet($featureValueIds);
  633.         return new JsonResponse([
  634.             'success' => true,
  635.             'hasMatrices' => $hasMatrices,
  636.         ]);
  637.     }
  639.     /**
  640.      * @param Product $product
  641.      * @param Request $request
  642.      * @return JsonResponse
  643.      * @Route("/{product}/attribut", name="_attribut", requirements={"product"="\d+"})
  644.      */
  645.     public function findAttributs(Product $product, Request $request): JsonResponse
  646.     {
  647.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  648.             return new JsonResponse([
  649.                 'success' => false,
  650.                 'message' => $this->translator->trans('global.invalidToken'),
  651.             ]);
  652.         }
  654.         if (!$product->isCommandable()) {
  655.             return new JsonResponse([
  656.                 'success' => false,
  657.                 'url' => $this->generateUrl('app_index'),
  658.             ]);
  659.         }
  661.         $data = Tools::getRequestData($request);
  663.         $attributs = [];
  665.         /** @var Attribut $attribut */
  666.         foreach ($product->getAttributValids() as $attribut) {
  667.             $attributValues = [];
  669.             /** @var AttributValue $attributValue */
  670.             foreach ($attribut->getAttributValueActives() as $attributValue) {
  671.                 $attributValuePriceHt = $attributValue->getPriceHt();
  673.                 if (isset($data['featureValueFormat'])) {
  674.                     if ($attributValue->getAttribut()->getConstName() === Attribut::MAKING) {
  675.                         /** @var ProductPriceMockup $productPriceMockup */
  676.                         $productPriceMockup = $this->em->getRepository(ProductPriceMockup::class)->findOneBy([
  677.                             'product' => $product,
  678.                             'productFeatureValue' => $data['featureValueFormat'],
  679.                         ]);
  681.                         $attributValuePriceHt = $productPriceMockup->getPriceHt();
  682.                     }
  683.                 }
  685.                 $attributValueSerialized = $this->serializeService->serializeAttributValue($attributValue);
  686.                 $attributValueSerialized['priceHt'] = $attributValuePriceHt;
  687.                 $attributValues[] = $attributValueSerialized;
  688.             }
  690.             $attributSerialized = $this->serializeService->serializeAttribut($attribut);
  691.             $attributSerialized['attributValues'] = $attributValues;
  692.             $attributs[] = $attributSerialized;
  693.         }
  695.         return new JsonResponse([
  696.             'success' => true,
  697.             'attributs' => $attributs,
  698.         ]);
  699.     }
  701.     /**
  702.      * @param Product $product
  703.      * @param Request $request
  704.      * @return JsonResponse
  705.      * @Route("/{product}/price", name="_price", requirements={"product"="\d+"})
  706.      * @throws Exception
  707.      */
  708.     public function findPrices(Product $product, Request $request): JsonResponse
  709.     {
  710.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  711.             return new JsonResponse([
  712.                 'success' => false,
  713.                 'message' => $this->translator->trans('global.invalidToken'),
  714.             ]);
  715.         }
  717.         if (!$product->isCommandable()) {
  718.             return new JsonResponse([
  719.                 'success' => false,
  720.                 'url' => $this->generateUrl('app_index'),
  721.             ]);
  722.         }
  724.         $data = Tools::getRequestData($request);
  726.         $quantities = [];
  728.         $isMockup = (array_key_exists('isMockup', $data) ? $data['isMockup'] : false);
  730.         if ($isMockup) {
  731.             if (array_key_exists('creation', $data)) {
  732.                 /** @var Creation $creation */
  733.                 $creation = $this->em->getRepository(Creation::class)->find($data['creation']);
  735.                 if (!is_null($creation->getProductFeatureValueFormat())) {
  736.                     /** @var ProductPriceMockup $productPriceMockup */
  737.                     $productPriceMockup = $this->em->getRepository(ProductPriceMockup::class)->findOneBy([
  738.                         'product' => $product,
  739.                         'productFeatureValue' => $creation->getProductFeatureValueFormat(),
  740.                     ]);
  742.                     if (!is_null($productPriceMockup)) {
  743.                         $quantities[] = $productPriceMockup->getPriceHt();
  744.                     } else {
  745.                         return new JsonResponse([
  746.                             'success' => false,
  747.                         ]);
  748.                     }
  749.                 } else {
  750.                     return new JsonResponse([
  751.                         'success' => false,
  752.                     ]);
  753.                 }
  754.             } else {
  755.                 $productFeatureValueFormat = (array_key_exists('productFeatureValueFormat', $data) ? $data['productFeatureValueFormat'] : null);
  757.                 if (!is_null($productFeatureValueFormat)) {
  758.                     /** @var ProductFeatureValue $productFeatureValueFormat */
  759.                     $productFeatureValueFormat = $this->em->getRepository(ProductFeatureValue::class)->find($productFeatureValueFormat);
  761.                     /** @var ProductPriceMockup $productPriceMockup */
  762.                     $productPriceMockup = $this->em->getRepository(ProductPriceMockup::class)->findOneBy([
  763.                         'product' => $product,
  764.                         'productFeatureValue' => $productFeatureValueFormat,
  765.                     ]);
  767.                     if (!is_null($productPriceMockup)) {
  768.                         $quantities[] = $productPriceMockup->getPriceHt();
  769.                     } else {
  770.                         return new JsonResponse([
  771.                             'success' => false,
  772.                         ]);
  773.                     }
  774.                 } else {
  775.                     return new JsonResponse([
  776.                         'success' => false,
  777.                     ]);
  778.                 }
  779.             }
  780.         } else {
  781.             $productFeatureValues = (array_key_exists('productFeatureValues', $data) ? $data['productFeatureValues'] : []);
  782.             $attributValues = (array_key_exists('attributValues', $data) ? $data['attributValues'] : []);
  784.             $creation = null;
  785.             $isFormatVariable = false;
  786.             $width = 0;
  787.             $height = 0;
  789.             if (array_key_exists('creation', $data)) {
  790.                 /** @var Creation $creation */
  791.                 $creation = $this->em->getRepository(Creation::class)->find($data['creation']);
  793.                 $isFormatVariable = $creation->hasFormatVariable();
  794.                 $width = $creation->getWidth();
  795.                 $height = $creation->getHeight();
  796.             }
  798.             // On récupère les productPrice en fonctions des featuresValues
  799.             $productPrices = $this->productService->getProductPricesByFeatureValues($data['allProductFeatureValues'], $productFeatureValues, $product);
  801.             foreach ($productPrices as $productPrice) {
  802.                 // Calcul du prix des attributs
  803.                 $attributValuePriceHtTotal = 0;
  805.                 if ($attributValues) {
  806.                     foreach ($attributValues as $value) {
  807.                         /** @var AttributValue $attributValue */
  808.                         $attributValue = $this->em->getRepository(AttributValue::class)->find($value);
  810.                         if ($attributValue) {
  811.                             $attributValuePriceHt = $attributValue->getPriceHt();
  813.                             if (!is_null($creation)) {
  814.                                 if ($attributValue->getAttribut()->getConstName() === Attribut::MAKING) {
  815.                                     /** @var ProductPriceMockup $productPriceMockup */
  816.                                     $productPriceMockup = $this->em->getRepository(ProductPriceMockup::class)->findOneBy([
  817.                                         'product' => $product,
  818.                                         'productFeatureValue' => $creation->getProductFeatureValueFormat(),
  819.                                     ]);
  821.                                     $attributValuePriceHt = $productPriceMockup->getPriceHt();
  822.                                 }
  823.                             }
  825.                             if ($attributValue->getAttribut()->isMultiplyByQuantity()) {
  826.                                 $attributValuePriceHtTotal += $attributValuePriceHt * $productPrice['step'];
  827.                             } else {
  828.                                 $attributValuePriceHtTotal += $attributValuePriceHt;
  829.                             }
  830.                         }
  831.                     }
  832.                 }
  834.                 if ($isFormatVariable) {
  835.                     $squareMeter = round(($width * $height / 10000), 2);
  837.                     $quantities[] = [
  838.                         'quantity' => $productPrice['step'],
  839.                         'priceHt' => (($productPrice['priceHt'] * $squareMeter) * $productPrice['step']) + $attributValuePriceHtTotal,
  840.                     ];
  841.                 } else {
  842.                     $quantities[] = [
  843.                         'quantity' => $productPrice['step'],
  844.                         'priceHt' => $productPrice['priceHt'] + $attributValuePriceHtTotal,
  845.                     ];
  846.                 }
  847.             }
  848.         }
  850.         return new JsonResponse([
  851.             'success' => true,
  852.             'prices' => $quantities,
  853.         ]);
  854.     }
  856.     /**
  857.      * @param Product $product
  858.      * @return JsonResponse
  859.      * @Route("/{product}/folder", name="_folder", requirements={"product"="\d+"})
  860.      */
  861.     public function findFolders(Product $product): JsonResponse
  862.     {
  863.         $folders = [];
  865.         /** @var Folder $folder */
  866.         foreach ($product->getFolders() as $folder) {
  867.             $folders[] = [
  868.                 'id' => $folder->getId(),
  869.                 'name' => $folder->getName(),
  870.             ];
  871.         }
  873.         return new JsonResponse([
  874.             'success' => true,
  875.             'folders' => $folders,
  876.         ]);
  877.     }
  879.     /**
  880.      * @param Product $product
  881.      * @param Request $request
  882.      * @return JsonResponse
  883.      * @throws Exception
  884.      * @Route("/{product}/associated-products", name="_associated_products", requirements={"product"="\d+"})
  885.      */
  886.     public function findAssociatedProducts(Product $product, Request $request): JsonResponse
  887.     {
  888.         if (!$this->rsa->isValidToken($request->request->get('apiKey'))) {
  889.             return new JsonResponse([
  890.                 'success' => false,
  891.                 'message' => $this->translator->trans('global.invalidToken'),
  892.             ]);
  893.         }
  895.         $associatedProducts = $product->getAssociatedProducts();
  897.         $serializedProducts = [];
  899.         foreach ($associatedProducts as $associatedProduct) {
  900.             $serializedProducts[] = $this->serializeService->serializeProduct($associatedProduct->getAssociatedProduct());
  901.         }
  903.         return new JsonResponse([
  904.             'success' => true,
  905.             'products' => $serializedProducts,
  906.         ]);
  907.     }
  908. }