src/Controller/Admin/AdminProductsController.php line 155

Open in your IDE?
  1. <?php
  3. namespace Acme\SudcmsBundle\Controller\Admin;
  5. use Acme\SudcmsBundle\Controller\AdminEcommerce\Exception;
  6. use Acme\SudcmsBundle\Entity\EcoAttributes;
  7. use Acme\SudcmsBundle\Entity\EcoAttributesModels;
  8. use Acme\SudcmsBundle\Entity\EcoAttributesReferences;
  9. use Acme\SudcmsBundle\Entity\EcoCategories;
  10. use Acme\SudcmsBundle\Entity\EcoLabels;
  11. use Acme\SudcmsBundle\Entity\EcoMarks;
  12. use Acme\SudcmsBundle\Entity\EcoProducts;
  13. use Acme\SudcmsBundle\Entity\EcoProductsBlocks;
  14. use Acme\SudcmsBundle\Entity\EcoProductsBlocksMedias;
  15. use Acme\SudcmsBundle\Entity\EcoProductsBundle;
  16. use Acme\SudcmsBundle\Entity\EcoProductsCategories;
  17. use Acme\SudcmsBundle\Entity\EcoProductsCombination;
  18. use Acme\SudcmsBundle\Entity\EcoProductsLabels;
  19. use Acme\SudcmsBundle\Entity\EcoProductsMedias;
  20. use Acme\SudcmsBundle\Entity\EcoProductsReferences;
  21. use Acme\SudcmsBundle\Entity\EcoProviders;
  22. use Acme\SudcmsBundle\Entity\Site;
  23. use Acme\SudcmsBundle\Form\Ecommerce\ProductReferenceType;
  24. use Acme\SudcmsBundle\Form\Ecommerce\ProductType;
  25. use Acme\SudcmsBundle\Repository\EcoAttributesModelsRepository;
  26. use Acme\SudcmsBundle\Repository\EcoAttributesReferencesRepository;
  27. use Acme\SudcmsBundle\Repository\EcoAttributesRepository;
  28. use Acme\SudcmsBundle\Repository\EcoCategoriesRepository;
  29. use Acme\SudcmsBundle\Repository\EcoCustomersFavoritesProdRepository;
  30. use Acme\SudcmsBundle\Repository\EcoLabelsRepository;
  31. use Acme\SudcmsBundle\Repository\EcoMarksRepository;
  32. use Acme\SudcmsBundle\Repository\EcoOrdersRepository;
  33. use Acme\SudcmsBundle\Repository\EcoProductsBlocksMediasRepository;
  34. use Acme\SudcmsBundle\Repository\EcoProductsBlocksRepository;
  35. use Acme\SudcmsBundle\Repository\EcoProductsBundleRepository;
  36. use Acme\SudcmsBundle\Repository\EcoProductsCategoriesRepository;
  37. use Acme\SudcmsBundle\Repository\EcoProductsCombinationRepository;
  38. use Acme\SudcmsBundle\Repository\EcoProductsLabelsRepository;
  39. use Acme\SudcmsBundle\Repository\EcoProductsReferencesRepository;
  40. use Acme\SudcmsBundle\Repository\EcoProductsRepository;
  41. use Acme\SudcmsBundle\Repository\EcoProvidersRepository;
  42. use Acme\SudcmsBundle\Repository\EcoSettingsRepository;
  43. use Acme\SudcmsBundle\Repository\OptionsRepository;
  44. use Acme\SudcmsBundle\Service\ApiService;
  45. use Acme\SudcmsBundle\Service\FileService;
  46. use Acme\SudcmsBundle\Service\FlashNotificationAjax;
  47. use Acme\SudcmsBundle\Service\OtideaUtils;
  48. use Doctrine\ORM\EntityManagerInterface;
  49. use Knp\Component\Pager\PaginatorInterface;
  50. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  51. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  52. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  53. use Symfony\Component\Filesystem\Filesystem;
  54. use Symfony\Component\HttpFoundation\JsonResponse;
  55. use Symfony\Component\HttpFoundation\Request;
  56. use Symfony\Component\HttpFoundation\Response;
  57. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  58. use Symfony\Component\HttpFoundation\Session\Session;
  59. use Symfony\Component\HttpKernel\KernelInterface;
  60. use Symfony\Component\Routing\Annotation\Route;
  61. use Twig\Environment;
  63. class AdminProductsController extends AbstractController
  64. {
  65.     private $session;
  66.     private $entityManager;
  67.     private $filesystem;
  68.     private $postMaxSize;
  69.     private $autorizedImages = ['jpg', 'jpeg', 'png'];
  70.     private $autorizedFiles = ['jpg', 'jpeg', 'png', 'pdf', 'doc', 'docx', 'xls', 'xlsx', 'ppt', 'pptx'];
  71.     private $pathFiles = 'public/medias_front/products'; // chemin vers les fichiers uploadés
  72.     private $monthList = [
  73.         1 => 'Janvier',
  74.         2 => 'Février',
  75.         3 => 'Mars',
  76.         4 => 'Avril',
  77.         5 => 'Mai',
  78.         6 => 'Juin',
  79.         7 => 'Juillet',
  80.         8 => 'Août',
  81.         9 => 'Septembre',
  82.         10 => 'Octobre',
  83.         11 => 'Novembre',
  84.         12 => 'Décembre'
  85.     ];
  86.     private $maxFileSize; // taille fichier max - 30 * 1024 * 1024
  87.     private $twig = null;
  88.     private $fileService;
  90.     public function __construct(
  91.         private ApiService     $apiService,
  92.         EntityManagerInterface $entityManager,
  93.         KernelInterface        $appKernel,
  94.         OptionsRepository      $repoOpt,
  95.         Environment            $twig,
  96.         FileService            $fileService,
  97.         Filesystem             $filesystem
  98.     )
  99.     {
  100.         if (!IS_ECOMMERCE) {
  101.             header('Location: ' . WEBSITEROOT . '/admin');
  102.             exit;
  103.         }
  105.         $this->session = new Session();
  107.         $this->entityManager = $entityManager;
  109.         $site = $this->entityManager->getRepository(Site::class)->find($this->session->get('admin_site_uid'));
  110.         $this->pathFiles = $this->session->get('admin_site_uid') > 1 ? '../' . $site->getProjectDirectory() . '/public/medias_front/products' : 'public/medias_front/products';
  113.         $this->maxFileSize = substr(ini_get('post_max_size'), 0, -1) * 1024 * 1024;
  114.         $this->fileService = $fileService;
  115.         $this->filesystem = $filesystem;
  116.         $this->twig = $twig;
  118.         $this->postMaxSize = substr(ini_get('post_max_size'), 0, -1);
  119.         $this->moduleName = "admin_products";
  121.         $optionsModule = $repoOpt->findBy(['option_name' => $this->moduleName], ['option_order' => 'ASC']);
  122.         $this->twig->addGlobal("optionsModule", $optionsModule);
  124.         //Création des dossiers dossier pour l'upload des médias du module
  125.         $directory[] = $appKernel->getProjectDir() . '/' . $this->pathFiles . '/';
  126.         $directory[] = $appKernel->getProjectDir() . '/' . $this->pathFiles . '/tmpFiles';
  127.         foreach ($directory as $dir) {
  128.             if (!file_exists($dir)) {
  129.                 mkdir($dir, 755);
  130.             }
  131.         }
  132.     }
  134.     #[Route(path: '/admin/products/list', name: 'admin_products')]
  135.     public function index(
  136.         Request                         $request,
  137.         EcoProductsRepository           $repoProduct,
  138.         EcoCategoriesRepository         $repoCategs,
  139.         EcoProductsReferencesRepository $repoRef,
  140.         PaginatorInterface              $paginator,
  141.         EcoSettingsRepository           $ecoSettingsRepository
  142.     )
  143.     {
  144.         $ecoSettings = $ecoSettingsRepository->findOneBy(['siteId' => CURRENT_SITE_ID]);
  146.         $products = $repoProduct->findBy(
  147.             ['siteId' => $this->session->get('admin_site_uid')],
  148.             ['id' => 'DESC']
  149.         );
  151.         return $this->render('admin/admin_products/index.html.twig', [
  152.             'productsList' => $products,
  153.             'stockManagement' => $ecoSettings->getStockManagement(),
  154.             'referencesList' => $repoRef->findAll(),
  155.             'categsList' => $repoCategs->findByEcoCategories($this->session->get('admin_site_uid')),
  156.         ]);
  157.     }
  159.     #[Route(path: '/admin/product_editing/{prod_id}', name: 'admin_product_edit', defaults: ['prod_id' => 0])]
  160.     public function product_editing(
  161.         Request                         $request,
  162.         EcoProductsRepository           $repoProduct,
  163.         EcoCategoriesRepository         $repoCateg,
  164.         EcoMarksRepository              $repoMarks,
  165.         EcoProvidersRepository          $repoProviders,
  166.         EcoLabelsRepository             $repoLabels,
  167.         EcoProductsLabelsRepository     $repoProdLabels,
  168.         EcoProductsReferencesRepository $referencesRepository,
  169.                                         $prod_id
  170.     )
  171.     {
  172.         $categList = $repoCateg->findBy(['siteId' => $this->session->get('admin_site_uid')]);
  173.         $markList = $repoMarks->findBy(['siteId' => $this->session->get('admin_site_uid')]);
  174.         $labels = $repoLabels->findAll();
  175.         $productLabels = null;
  176.         $references = $this->entityManager->getRepository(EcoProductsReferences::class)->findBy(
  177.             ['product_id' => $prod_id],
  178.             ['ref_sequence' => 'ASC']
  179.         );
  182.         if ($categList == null || $markList == null) {
  183.             $this->addFlash('danger', "Il doit exister au moins une catégorie et une marque pour ajouter un produit.");
  184.             return $this->redirectToRoute('admin_products');
  185.         }
  187.         $product = new EcoProducts;
  188.         $picture = null;
  190.         if ($prod_id > 0) {
  191.             $product = $repoProduct->find($prod_id);
  192.             $picture = $product->getProdPicture();
  193.             $productLabels = $repoProdLabels->findBy(['product_id' => $prod_id]);
  194.         }
  196.         //Récupération du nombre de références du produit pour savoir si c'est un produit multiple ou single
  197.         $refProd = $referencesRepository->findBy(['product_id' => $product->getId()]);
  199.         $form = $this->createForm(ProductType::class, $product, [
  200.             'categoriesList' => $categList,
  201.             'marksList' => $markList,
  202.             'labels' => $labels,
  203.             'productLabels' => $productLabels,
  204.             'providersList' => $repoProviders->findBy(['siteId' => $this->session->get('admin_site_uid')]),
  205.         ]);
  207.         $form->handleRequest($request);
  209.         if ($form->isSubmitted() && $form->isValid()) {
  210.             if ($prod_id == 0) {
  211.                 $product->setProdCreationDate(new \DateTime());
  212.             }
  214.             $product->setSiteId($this->session->get('admin_site_uid'));
  216.             //Récupération des anciens labels du produit
  217.             $oldLabels = $repoProdLabels->findBy(['product_id' => $prod_id]);
  219.             //On supprime tous les anciens labels avant d'enregistrer les nouveaux
  220.             foreach ($oldLabels as $label) {
  221.                 $this->entityManager->remove($label);
  222.             }
  224.             //On enregistre les nouveaux labels si il y en a
  225.             if (isset($request->get('product')['label_id'])) {
  226.                 foreach ($request->get('product')['label_id'] as $labelGet) {
  227.                     $label = new EcoProductsLabels;
  228.                     $label->setLabelId($labelGet);
  229.                     $label->setProductId($prod_id);
  230.                     $this->entityManager->persist($label);
  231.                 }
  232.             }
  234.             if ($references) {
  235.                 if ($references[0]->getTypeOdyssee() == 'soin' && $product->getIsDeliverable() == 'sur-place') {
  236.                     $this->addFlash('danger', 'Un type de soin ne peut pas inclure le retrait sur place.');
  237.                     return $this->redirectToRoute('admin_product_edit', array('prod_id' => $product->getId()));
  238.                 }
  239.             }
  241.             foreach ($request->files->get('product')['prod_picture'] as $key => $file) {
  242.                 // upload du fichier
  243.                 if ($file !== null && $key < 4) {
  244.                     $upload = $this->fileService->startUpload(
  245.                         [
  246.                             "fileData" => $file,
  247.                             "oldFileName" => $picture,
  248.                             "fileDestination" => $this->getParameter(
  249.                                 "upload_products_" . $this->session->get('admin_site_uid')
  250.                             ),
  251.                             "autorizedExtensions" => $this->autorizedImages,
  252.                             "createWebp" => true
  253.                         ]
  254.                     );
  256.                     // upload OK
  257.                     if (isset($upload['state']) && $upload['state'] && isset($upload['filename']) && is_string(
  258.                             $upload['filename']
  259.                         )) {
  260.                         if ($key == 0) {
  261.                             $product->setProdPicture($upload['filename']);
  262.                         }
  263.                         $media = new EcoProductsMedias();
  264.                         $media->setMediaName($upload['filename']);
  265.                         $product->addMedia($media);
  266.                         $this->entityManager->persist($media);
  267.                         //$this->entityManager->flush();
  268.                     } // upload KO avec message perso
  269.                     elseif (isset($upload['error_msg'])) {
  270.                         $product->setProdPicture($picture);
  271.                         $errorMsg = $upload['error_msg'];
  272.                     } // upload KO avec message générique
  273.                     else {
  274.                         $product->setProdPicture($picture);
  275.                         $errorMsg = "Une erreur s'est produite lors de l'enregistrement du fichier";
  276.                     }
  277.                 }
  278.             }
  280.             //On récupère le radio PROD-TYPE qui a été rendu manuellement dans le template
  281.             //            $product->setProdType($request->request->get('prod_type'));
  282.             $product->setProdType('single');
  283.             $product->setProdPriceType('vente');
  285.             $product->setprovider($repoProviders->find($request->get('product')['provider_id']));
  287.             try {
  288.                 $this->entityManager->persist($product);
  289.                 $this->entityManager->flush();
  290.             } catch (Exception $e) {
  291.                 $errorMsg = "Une erreur s'est produite lors de l'enregistrement";
  292.             }
  294.             // il y a eu une erreur
  295.             if (isset($errorMsg)) {
  296.                 $this->addFlash('danger', $errorMsg);
  297.             } // pas d'erreur
  298.             else {
  299.                 $this->addFlash('success', "enregistré avec succès");
  300.             }
  302.             return $this->redirectToRoute('admin_product_edit', array('prod_id' => $product->getId()));
  303.         }
  305.         $this->checkOdysseePrice($product->getId());
  307.         return $this->render('admin/admin_products/product_editing.html.twig', [
  308.             'form' => $form->createView(),
  309.             'product' => $repoProduct->find($prod_id),
  310.             'product_id' => $prod_id,
  311.             'autorizedImages' => $this->autorizedImages,
  312.             'nbRefProd' => sizeof($refProd),
  313.             'typeProdut' => $product->getProdType(),
  314.             'referencesList' => $references
  315.         ]);
  316.     }
  318.     private function checkOdysseePrice($prodId): void
  319.     {
  320.         if ($prodId > 0) {
  321.             if ($this->apiService->testConnexion()) {
  322.                 $reference = $this->entityManager->getRepository(EcoProductsReferences::class)->findOneBy(
  323.                     ['product_id' => $prodId]
  324.                 );
  326.                 if ($reference) {
  327.                     $priceUpdated = false;
  329.                     if ($reference) {
  330.                         $priceUpdated = false;
  332.                         if ($reference->getTypeOdyssee() == 'soin') {
  333.                             $odysseeProduct = $this->apiService->rechSoinResaSpaParCodeProduit(
  334.                                 $reference->getRefReference()
  335.                             );
  337.                             if ($reference->getRefReferencePrice() != $odysseeProduct[0]->{'Prixttc_Produit_Soin'}) {
  338.                                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit_Soin'});
  339.                                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit_Soin'});
  340.                                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit_Soin'});
  341.                                 $priceUpdated = true;
  342.                             }
  343.                         } elseif ($reference->getTypeOdyssee() == 'produit') {
  344.                             $odysseeProduct = ODYSSEE_TYPE == 'CURE' ? $this->apiService->rechProduitResaCureParCode(
  345.                                 $reference->getRefReference()
  346.                             ) : $this->apiService->rechProduitResaSpaParCode($reference->getRefReference());
  347.                             if ($reference->getRefReferencePrice() != $odysseeProduct[0]->{'Prixttc_Produit'}) {
  348.                                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit'});
  349.                                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit'});
  350.                                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit'});
  351.                                 $priceUpdated = true;
  352.                             }
  353.                         } elseif ($reference->getTypeOdyssee() == 'bkdo') {
  354.                             $odysseeProduct = $this->apiService->rechProduitBkdoParCode($reference->getRefReference());
  355.                             if ($reference->getRefReferencePrice() != $odysseeProduct[0]->{'Prixttc_Produit'}) {
  356.                                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit'});
  357.                                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit'});
  358.                                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit'});
  359.                                 $priceUpdated = true;
  360.                             }
  361.                         }
  363.                         if ($priceUpdated) {
  364.                             try {
  365.                                 $prod = $this->entityManager->getRepository(EcoProducts::class)->find($prodId);
  366.                                 $prod->setProdSellingPrice($reference->getRefSellingPrice());
  367.                                 $prod->setProdReferencePrice($reference->getRefReferencePrice());
  368.                                 $reference->setRefLastupdateDate(new \DateTime());
  369.                                 $this->entityManager->persist($reference);
  370.                                 $this->entityManager->persist($prod);
  371.                                 $this->entityManager->flush();
  372.                                 $this->addFlash('success', "Le prix a été mis à jour avec Odyssée");
  373.                             } catch (Exception $e) {
  374.                                 $this->addFlash(
  375.                                     'danger',
  376.                                     "Une erreur s'est produite lors de la récupération du prix sur Odyssée"
  377.                                 );
  378.                             }
  379.                         }
  380.                     }
  381.                 } else {
  382.                     $this->addFlash('danger', 'Une erreur est survenue avec l\'API<br>Mise à jour avec Odyssée impossible');
  383.                 }
  384.             }
  385.         }
  386.     }
  388.     #[Route(path: '/admin/products/remove-picture/{id}', name: 'admin_product_remove_picture', defaults: ['id' => ''])]
  389.     public function removePicture($id)
  390.     {
  391.         if ($id > 0) {
  392.             try {
  393.                 $product = $this->entityManager->getRepository(EcoProducts::class)->find($id);
  394.                 $filename = $product->getProdPicture();
  395.                 $product->setProdPicture(null);
  397.                 $medias = $this->entityManager->getRepository(EcoProductsMedias::class)->findBy(['product' => $id]);
  399.                 foreach ($medias as $media) {
  400.                     $mediaName = $media->getMediaName();
  402.                     if ($mediaName != null && $mediaName != "" && is_string($mediaName) && $this->filesystem->exists(
  403.                             $file = $this->getParameter(
  404.                                     'upload_products_' . $this->session->get('admin_site_uid')
  405.                                 ) . "/" . $mediaName
  406.                         )) {
  407.                         $this->fileService->removeFile([
  408.                             "filePath" => $this->getParameter(
  409.                                 'upload_products_' . $this->session->get('admin_site_uid')
  410.                             ),
  411.                             "filename" => $mediaName,
  412.                         ]);
  413.                     }
  415.                     $product->removeMedia($media);
  416.                     $this->entityManager->persist($product);
  417.                 }
  419.                 $this->entityManager->persist($product);
  420.                 $this->entityManager->flush();
  422.                 if ($filename != null && $filename != "" && is_string($filename) && $this->filesystem->exists(
  423.                         $file = $this->getParameter(
  424.                                 'upload_products_' . $this->session->get('admin_site_uid')
  425.                             ) . "/" . $filename
  426.                     )) {
  427.                     $this->fileService->removeFile([
  428.                         "filePath" => $this->getParameter('upload_products_' . $this->session->get('admin_site_uid')),
  429.                         "filename" => $filename,
  430.                     ]);
  431.                 }
  433.                 $this->addFlash('success', "Les illustrations ont été supprimées avec succès");
  434.             } catch (Exception $e) {
  435.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression de l'illustration");
  436.             }
  437.         }
  439.         return $this->redirectToRoute('admin_product_edit', ['prod_id' => $id]);
  440.     }
  442.     #[Route(path: '/admin/products/axDisplayCategories', options: ['expose' => true])]
  443.     public function axDisplayCategories(
  444.         Request                         $request,
  445.         EcoCategoriesRepository         $repoCateg,
  446.         EcoProductsCategoriesRepository $repoLinkCateg,
  447.         EcoProductsRepository           $repoProduct
  448.     )
  449.     {
  450.         if ($request->isXmlHttpRequest()) {
  451.             $renderModale = $this->renderView('admin/admin_products/tpl_categories.html.twig', [
  452.                 'modalTitle' => "Sélection des catégories secondaires",
  453.                 'categList' => $repoCateg->findBy(['siteId' => $this->session->get('admin_site_uid')],
  454.                     ['categ_parent_id' => 'ASC', 'categ_sequence' => 'ASC']),
  455.                 'linkCategList' => $repoLinkCateg->findBy(['product_id' => $request->get('prod_id')]),
  456.                 'product' => $repoProduct->find($request->get('prod_id')),
  457.                 'prod_id' => $request->get('prod_id')
  458.             ]);
  460.             return new JsonResponse([
  461.                 'status' => true,
  462.                 'modal' => html_entity_decode($renderModale),
  463.             ]);
  464.         }
  466.         return new JsonResponse([
  467.             'status' => false,
  468.         ]);
  469.     }
  471.     #[Route(path: '/admin/products/axCheckCategory', options: ['expose' => true])]
  472.     public function axCheckCategory(Request $request, EcoProductsCategoriesRepository $repoLinkCateg)
  473.     {
  474.         if ($request->isXmlHttpRequest()) {
  475.             if ($request->get('prod_id') && $request->get('categ_id')) {
  476.                 $categ = $repoLinkCateg->findBy([
  477.                     'category_id' => $request->get('categ_id'),
  478.                     'product_id' => $request->get('prod_id')
  479.                 ]);
  481.                 if (isset($categ[0]) && $categ[0]->getId() !== null) {
  482.                     $this->entityManager->remove($categ[0]);
  483.                 } else {
  484.                     $categ = new EcoProductsCategories;
  485.                     $categ->setCategoryId($request->get('categ_id'));
  486.                     $categ->setProductId($request->get('prod_id'));
  487.                     $this->entityManager->persist($categ);
  488.                 }
  490.                 try {
  491.                     $this->entityManager->flush();
  492.                     return new JsonResponse([
  493.                         'status' => true,
  494.                     ]);
  495.                 } catch (Exception $e) {
  496.                     return new JsonResponse([
  497.                         'status' => false,
  498.                     ]);
  499.                 }
  500.             }
  501.         }
  503.         return new JsonResponse([
  504.             'status' => false,
  505.         ]);
  506.     }
  508.     #[Route(path: '/admin/product_references/{prod_id}', name: 'admin_product_references', defaults: ['prod_id' => 0])]
  509.     public function product_references(
  510.         Request                           $request,
  511.         EcoProductsRepository             $repoProduct,
  512.         EcoProductsReferencesRepository   $repoRef,
  513.         EcoAttributesRepository           $repoAttributes,
  514.         EcoAttributesModelsRepository     $repoModels,
  515.         EcoAttributesReferencesRepository $repoLink,
  516.                                           $prod_id
  517.     )
  518.     {
  519.         //Gestion des attributs
  520.         if ($request->get('attributs')) {
  521.             //Liste des combinaisons
  522.             $combinations = $this->getAttributesCombination($request->get('attributs'));
  523.             //Générer les références
  524.             $this->generateReferences(
  525.                 $prod_id,
  526.                 $combinations,
  527.                 $repoAttributes->findAll(),
  528.                 $repoLink->findByLinkAttributesByProduct($prod_id)
  529.             );
  530.         }
  532.         $this->checkOdysseePrice($prod_id);
  534.         return $this->render('admin/admin_products/product_references.html.twig', [
  535.             'product_id' => $prod_id,
  536.             'product' => $repoProduct->find($prod_id),
  537.             'referencesList' => $repoRef->findBy(['product_id' => $prod_id], ['ref_sequence' => 'ASC']),
  538.             'attributesList' => $repoAttributes->findAll(),
  539.             'attributesModelsList' => $repoModels->findAll(),
  540.         ]);
  541.     }
  543.     private function generateReferences($product_id, $combinationArray, $attributesList, $linkAttributesRef)
  544.     {
  545.         if (is_array($combinationArray) && sizeof($combinationArray) > 0) {
  546.             foreach ($combinationArray as $combinations) {
  547.                 //Sans combinaison
  548.                 if (!is_array($combinations)) {
  549.                     $this->setSimpleCombination($product_id, $combinations, $linkAttributesRef, $attributesList);
  550.                     //Combinaison d'attribut
  551.                 } else {
  552.                     $this->setMultipleCombination($product_id, $combinations, $linkAttributesRef, $attributesList);
  553.                 }
  554.             }
  555.         }
  556.     }
  558.     private function setMultipleCombination($product_id, $combinations, $linkAttributesRef, $attributesList)
  559.     {
  560.         foreach ($combinations as $combination) {
  561.             //Si la combinaison existe déjà on passe à la suivante
  562.             $validateDuplication = $this->validateDuplicateCombination($combination, $linkAttributesRef);
  563.             if (!$validateDuplication) {
  564.                 continue;
  565.             }
  567.             //Générer l'intitulé de la référence
  568.             $attributs = explode('-', $combination);
  569.             $entitled = $refReference = '';
  570.             foreach ($attributs as $attr_id) {
  571.                 foreach ($attributesList as $elmt) {
  572.                     if ($elmt->getId() == $attr_id) {
  573.                         $entitled .= $elmt->getAttribute() . ' ';
  574.                         $refReference .= $elmt->getAttribute() . '-';
  575.                     }
  576.                 }
  577.             }
  579.             //Création de la référence
  580.             $reference = new EcoProductsReferences;
  581.             $reference->setProductId($product_id);
  582.             $reference->setRefEntitled($entitled);
  583.             $reference->setRefReference(substr(uniqid() . '-' . $refReference, 0, -1));
  585.             $reference->setRefReferencePrice(0);
  586.             $reference->setRefBuyingPrice(0);
  587.             $reference->setRefSellingPrice(0);
  588.             $reference->setRefTva(1.20);
  589.             $reference->setIsReservable(false);
  590.             $reference->setRefOutOfOrder(false);
  591.             $reference->setRefLastupdateDate(new \DateTime());
  593.             $this->entityManager->persist($reference);
  594.             $this->entityManager->flush();
  596.             $prod = $this->entityManager->getRepository(EcoProducts::class)->find($reference->getProductId());
  597.             $nbRef = $this->entityManager->getRepository(EcoProductsReferences::class)->findBy(
  598.                 ['product_id' => $prod->getId()]
  599.             );
  601.             if (count($nbRef) <= 1) {
  602.                 $prod->setProdType('single');
  603.                 $this->entityManager->flush($prod);
  604.             } else {
  605.                 $prod->setProdType('multiple');
  606.                 $this->entityManager->flush($prod);
  607.             }
  609.             //liaisons des combinaisons d'attributs
  610.             $attributs = explode('-', $combination);
  611.             foreach ($attributs as $attr_id) {
  612.                 $link = new EcoAttributesReferences;
  613.                 $link->setAttributeId($attr_id);
  614.                 $link->setReferenceId($reference->getId());
  615.                 $this->entityManager->persist($link);
  616.             }
  618.             $this->entityManager->flush();
  619.         }
  620.     }
  622.     private function setSimpleCombination($product_id, $attr_id, $linkAttributesRef, $attributesList)
  623.     {
  624.         $validateDuplication = $this->validateDuplicateCombination($attr_id, $linkAttributesRef);
  625.         if ($validateDuplication) {
  626.             //Générer l'intitulé de la référence
  627.             $entitled = '';
  628.             foreach ($attributesList as $elmt) {
  629.                 if ($elmt->getId() == $attr_id) {
  630.                     $entitled = $elmt->getAttribute() . ' ';
  631.                 }
  632.             }
  634.             //Création de la référence
  635.             $reference = new EcoProductsReferences;
  636.             $reference->setProductId($product_id);
  637.             $reference->setRefEntitled($entitled);
  638.             $reference->setRefReference(substr(uniqid() . '-' . $entitled, 0, -1));
  640.             $reference->setRefReferencePrice(0);
  641.             $reference->setRefBuyingPrice(0);
  642.             $reference->setRefSellingPrice(0);
  643.             $reference->setRefTva(1.20);
  644.             $reference->setIsReservable(false);
  645.             $reference->setRefOutOfOrder(false);
  646.             $reference->setRefLastupdateDate(new \DateTime());
  648.             $this->entityManager->persist($reference);
  649.             $this->entityManager->flush();
  651.             $prod = $this->entityManager->getRepository(EcoProducts::class)->find($reference->getProductId());
  652.             $nbRef = $this->entityManager->getRepository(EcoProductsReferences::class)->findBy(
  653.                 ['product_id' => $prod->getId()]
  654.             );
  656.             if (count($nbRef) <= 1) {
  657.                 $prod->setProdType('single');
  658.                 $this->entityManager->flush($prod);
  659.             } else {
  660.                 $prod->setProdType('multiple');
  661.                 $this->entityManager->flush($prod);
  662.             }
  664.             //liaisons des combinaisons d'attributs
  665.             $link = new EcoAttributesReferences;
  666.             $link->setAttributeId($attr_id);
  667.             $link->setReferenceId($reference->getId());
  668.             $this->entityManager->persist($link);
  670.             $this->entityManager->flush();
  671.         }
  672.     }
  674.     /**
  675.      * Retourne vrai si la combinaison n'existe pas
  676.      * @param string $combination
  677.      * @param array $bdd
  678.      */
  679.     private function validateDuplicateCombination($combination, $bdd)
  680.     {
  681.         $attributes = explode('-', $combination);
  682.         $attributesCount = sizeof($attributes);
  683.         foreach ($bdd as $combinationBdd) {
  684.             $count = 0;
  685.             foreach ($combinationBdd as $attr_id) {
  686.                 if (in_array($attr_id, $attributes)) {
  687.                     $count++;
  688.                 }
  689.             }
  691.             if ($count == $attributesCount) {
  692.                 return false;
  693.             }
  694.         }
  696.         return true;
  697.     }
  699.     /**
  700.      * Retourne la liste des combinaisons à générer
  701.      * @param array $attributes
  702.      */
  703.     private function getAttributesCombination($attributes)
  704.     {
  705.         //Liste des modèles
  706.         $models = array();
  707.         foreach ($attributes as $attribut) {
  708.             list($model_id, $attribute_id) = explode('-', $attribut);
  709.             $models[] = $model_id;
  710.         }
  712.         //Liste des modèles uniques
  713.         $models_unique = array_unique($models);
  715.         $attributesModelsList = array();
  716.         $resultCombination = '';
  717.         $results = array();
  719.         //Tableau des attributs segmenté par modèle
  720.         foreach ($models_unique as $model_id) {
  721.             $attributesModelsList[] = $this->getAttributesSelectedByModel($model_id, $attributes);
  722.         }
  724.         $attrSize = sizeof($attributesModelsList);
  725.         foreach ($attributesModelsList[0] as $key => $attr_id) { //liste array
  727.             $resultCombination .= $attr_id;
  728.             for ($i = 1; $i < $attrSize; $i++) {
  729.                 $resultCombination = $this->recursiveAttributes($attributesModelsList[$i], $resultCombination);
  730.             }
  732.             $results[] = $resultCombination;
  733.             $resultCombination = '';
  734.         }
  736.         //        dd($attributes, $models_unique, $attributesModelsList, $results);
  737.         return $results;
  738.     }
  740.     /**
  741.      * Retourne les combinaisons d'attributs de façon récursice
  742.      * @param array $attributesList
  743.      * @param array $resultCombination
  744.      * @return array
  745.      */
  746.     private function recursiveAttributes($attributesList, $resultCombination)
  747.     {
  748.         $result = array();
  749.         if (is_array($resultCombination)) {
  750.             foreach ($resultCombination as $combinaison) {
  751.                 foreach ($attributesList as $attr2_id) {
  752.                     $result[] = $combinaison . '-' . $attr2_id;
  753.                 }
  754.             }
  755.         } else {
  756.             foreach ($attributesList as $attr2_id) {
  757.                 $result[] = $resultCombination . '-' . $attr2_id;
  758.             }
  759.         }
  761.         return $result;
  762.     }
  764.     /**
  765.      * Retourne la liste des attributs par modèle
  766.      * @param int $modelId
  767.      * @param array $attributs
  768.      * @return array
  769.      */
  770.     private function getAttributesSelectedByModel($modelId, $attributs)
  771.     {
  772.         $result = array();
  773.         foreach ($attributs as $attribut) {
  774.             list($model_id, $attribute_id) = explode('-', $attribut);
  775.             if ($model_id == $modelId) {
  776.                 $result[] = $attribute_id;
  777.             }
  778.         }
  779.         return $result;
  780.     }
  782.     #[Route(path: '/admin/product/reference_remove/{id}', name: 'admin_reference_remove', defaults: ['id' => 0])]
  783.     public function remove_reference(
  784.         Request                           $request,
  785.         EcoProductsReferencesRepository   $repoReference,
  786.         EcoAttributesReferencesRepository $ecoAttributesReferencesRepository,
  787.         EcoProductsRepository             $repoProduct,
  788.                                           $id
  789.     )
  790.     {
  791.         $reference = new EcoProductsReferences;
  793.         if ($id > 0) {
  794.             $reference = $repoReference->find($id);
  796.             try {
  797.                 $attrRef = $ecoAttributesReferencesRepository->findBy(['reference_id' => $reference->getId()]);
  799.                 foreach ($attrRef as $ref) {
  800.                     $this->entityManager->remove($ref);
  801.                 }
  803.                 $this->entityManager->remove($reference);
  804.                 $this->entityManager->flush();
  806.                 $prod = $repoProduct->find($reference->getProductId());
  807.                 $nbRef = $repoReference->findBy(['product_id' => $prod->getId()]);
  809.                 if (count($nbRef) <= 1) {
  810.                     $prod->setProdType('single');
  811.                     $this->entityManager->flush($prod);
  812.                 } else {
  813.                     $prod->setProdType('multiple');
  814.                     $this->entityManager->flush($prod);
  815.                 }
  817.                 $this->addFlash('success', "Suppression avec succès");
  818.             } catch (Exception $e) {
  819.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  820.             }
  821.         }
  823.         return $this->redirectToRoute('admin_product_references', array('prod_id' => $reference->getProductId()));
  824.     }
  826.     #[Route(path: '/admin/product_reference_type_odyssee/axRefOdyssee', name: 'admin_ax_ref_odyssee')]
  827.     public function axRefOdyssee(Request $request, ApiService $apiService): JsonResponse
  828.     {
  829.         if ($request->isXmlHttpRequest() && in_array($request->get('type'), ['produit', 'soin', 'bkdo', 'bkdovalue'])) {
  830.             $type = $request->get('type');
  831.             $result = [];
  833.             if (ODYSSEE_TYPE == 'CURE' || $type == 'produit') {
  834.                 if (ODYSSEE_TYPE == 'CURE') {
  835.                     $datas = $apiService->listerProduitResaCure();
  836.                 } else {
  837.                     $vente = $apiService->listerProduitVenteSpa();
  838.                     $resa = $apiService->listerProduitResaSpa();
  839.                     $datas = array_unique(array_merge($vente, $resa), SORT_REGULAR); // Elimine les doublons
  840.                 }
  842.                 foreach ($datas as $data) {
  843.                     $result[] = [
  844.                         'id' => $data->{'Code_Produit'},
  845.                         'name' => $data->{'Libelle_Produit'}
  846.                     ];
  847.                 }
  848.             } elseif ($type == 'soin') {
  849.                 $vente = $apiService->listerSoinVenteSpa();
  850.                 $resa = $apiService->listerSoinResaSpa();
  851.                 $datas = array_unique(array_merge($vente, $resa), SORT_REGULAR); // Elimine les doublons
  852.                 foreach ($datas as $data) {
  853.                     $result[] = [
  854.                         'id' => $data->{'Code_Produit_Soin'},
  855.                         'name' => $data->{'Libelle_Produit_Soin'}
  856.                     ];
  857.                 }
  858.             } elseif ($type == 'bkdo') {
  859.                 $datas = $apiService->listerProduitBkdo();
  860.                 foreach ($datas as $data) {
  861.                     $result[] = [
  862.                         'id' => $data->{'Code_Produit'},
  863.                         'name' => $data->{'Libelle_Produit'}
  864.                     ];
  865.                 }
  866.             } elseif ($type == 'bkdovalue') {
  867.                 $result = $type;
  868.             }
  870.             return new JsonResponse(
  871.                 [
  872.                     'status' => true,
  873.                     'result' => $result
  874.                 ]
  875.             );
  876.         }
  878.         return new JsonResponse(
  879.             [
  880.                 'status' => false
  881.             ]
  882.         );
  883.     }
  885.     #[Route(path: '/admin/product_reference_edit/{prod_id}/{ref_id}', name: 'admin_product_reference_edit', defaults: [
  886.         'prod_id' => 0,
  887.         'ref_id' => 0
  888.     ])]
  889.     public function product_reference_edit(
  890.         Request                         $request,
  891.         EcoProductsReferencesRepository $repoReference,
  892.         EcoProductsRepository           $repoProduct,
  893.         EcoSettingsRepository           $ecoSettingsRepository,
  894.                                         $prod_id = 0,
  895.                                         $ref_id = 0
  896.     )
  897.     {
  898.         $reference = new EcoProductsReferences;
  900.         if ($ref_id > 0) {
  901.             $reference = $repoReference->find($ref_id);
  902.         }
  904.         $ecoSettings = $ecoSettingsRepository->findOneBy(['siteId' => CURRENT_SITE_ID]);
  905.         $stockManagement = $ecoSettings->getStockManagement();
  907.         $prod = $repoProduct->find($prod_id);
  909.         $form = $this->createForm(ProductReferenceType::class, $reference, [
  910.             'stockManagement' => $stockManagement
  911.         ]);
  913.         $form->handleRequest($request);
  916.         if ($form->isSubmitted() && $form->isValid()) {
  917.             if ($ref_id == 0) {
  918.                 $reference->setProductId($prod_id);
  919.             }
  921.             // Récupère les informations de l'API Odyssée pour le prix et la TVA en fonction du type
  922.             if ($reference->getTypeOdyssee() == 'produit') {
  923.                 $odysseeProduct = ODYSSEE_TYPE == 'CURE' ? $this->apiService->rechProduitResaCureParCode(
  924.                     $request->request->get('reference')
  925.                 ) : $this->apiService->rechProduitResaSpaParCode($request->request->get('reference'));
  927.                 if (!$odysseeProduct) {
  928.                     $this->addFlash(
  929.                         'danger',
  930.                         "Un problème a été détecté sur ce produit. Veuillez vérifier dans Odyssée qu'aucun autre problème n'est présent."
  931.                     );
  932.                     return $this->redirectToRoute(
  933.                         'admin_product_reference_edit',
  934.                         array('prod_id' => $prod_id, 'ref_id' => $reference->getId())
  935.                     );
  936.                 }
  938.                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit'});
  939.                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit'});
  940.                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit'});
  941.                 $reference->setRefEntitled(
  942.                     $odysseeProduct[0]->{'Libelle_Produit'}
  943.                 ); // L'intitulé du produit de base est automatiquement repris
  944.                 $reference->setRefReference($request->request->get('reference')); // Récupère la référence Odyssée
  945.             } elseif ($reference->getTypeOdyssee() == 'soin') {
  946.                 $odysseeProduct = $this->apiService->rechSoinResaSpaParCodeProduit($request->request->get('reference'));
  948.                 if (!$odysseeProduct) {
  949.                     $this->addFlash(
  950.                         'danger',
  951.                         "Un problème a été détecté sur ce produit. Veuillez vérifier dans Odyssée qu'aucun autre problème n'est présent."
  952.                     );
  953.                     return $this->redirectToRoute(
  954.                         'admin_product_reference_edit',
  955.                         array('prod_id' => $prod_id, 'ref_id' => $reference->getId())
  956.                     );
  957.                 }
  959.                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit_Soin'});
  960.                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit_Soin'});
  961.                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit_Soin'});
  962.                 $reference->setRefEntitled(
  963.                     $odysseeProduct[0]->{'Libelle_Produit_Soin'}
  964.                 ); // L'intitulé du produit de base est automatiquement repris
  965.                 $reference->setRefReference($request->request->get('reference')); // Récupère la référence Odyssée
  966. //                $reference->setMaxByOrder(1);
  967.             } elseif ($reference->getTypeOdyssee() == 'bkdo') {
  968.                 $odysseeProduct = $this->apiService->rechProduitBkdoParCode($request->request->get('reference'));
  970.                 if (!$odysseeProduct) {
  971.                     $this->addFlash(
  972.                         'danger',
  973.                         "Un problème a été détecté sur ce produit. Veuillez vérifier dans Odyssée qu'aucun autre problème n'est présent."
  974.                     );
  975.                     return $this->redirectToRoute(
  976.                         'admin_product_reference_edit',
  977.                         array('prod_id' => $prod_id, 'ref_id' => $reference->getId())
  978.                     );
  979.                 }
  981.                 $reference->setRefReferencePrice($odysseeProduct[0]->{'Prixttc_Produit'});
  982.                 $reference->setRefSellingPrice($odysseeProduct[0]->{'Prixttc_Produit'});
  983.                 $reference->setRefTva($odysseeProduct[0]->{'Tva_Produit'});
  984.                 $reference->setRefEntitled(
  985.                     $odysseeProduct[0]->{'Libelle_Produit'}
  986.                 ); // L'intitulé du produit de base est automatiquement repris
  987.                 $reference->setRefReference($request->request->get('reference')); // Récupère la référence Odyssée
  988.             } elseif ($reference->getTypeOdyssee() == 'bkdovalue') {
  989.                 $reference->setRefReferencePrice(0);
  990.                 $reference->setRefSellingPrice(0);
  991.                 $reference->setRefTva(20);
  992.                 $reference->setRefEntitled('BON CADEAU VALEUR');
  993.                 $reference->setRefReference('bkdovalue'); // Récupère la référence Odyssée
  994. //                $reference->setMaxByOrder(1);
  995.                 $reference->setRefQuantity(null);
  996.             }
  998.             //            $referenceType = $this->getReferencePrice($reference->getRefSellingPrice(), $reference->getRefPromoPrice(),
  999.             //                                                      $reference->getRefSoldePrice());
  1000.             //            $reference->setRefReferencePrice($referenceType['reference_price']);
  1001.             //            $reference->setRefPriceType($referenceType['price_type']);
  1003.             $reference->setRefPriceType('vente');
  1005.             $reference->setRefLastupdateDate(new \DateTime());
  1007.             $reference->setRefOutOfOrder(false);
  1009.             if ($ecoSettings->getUnavailableProductNoStock() && ($form->get('ref_quantity')->getData() == 0 || $form->get('ref_quantity')->getData() == null)) {
  1010.                 $reference->setRefOutOfOrder(true);
  1011.             } else {
  1012.                 if ($ecoSettings->getUnavailableProductNoStock() && $form->get('ref_quantity')->getData() > 0) {
  1013.                     $reference->setRefOutOfOrder(false);
  1014.                 }
  1015.             }
  1017.             $prod->setProdSellingPrice($reference->getRefReferencePrice());
  1018.             $prod->setProdReferencePrice($reference->getRefReferencePrice());
  1020.             $ref = $reference->getTypeOdyssee() == 'bkdovalue' ? $reference->getTypeOdyssee() : $request->request->get(
  1021.                 'reference'
  1022.             );
  1024.             //Vérification sur la duplication de la référence
  1025.             $resultReferences = $repoReference->findBy(['ref_reference' => $ref]);
  1027.             // Si la référence précédemment enregistrée est contenue dans le tableau des références, on l'enlève
  1028.             if (is_array($resultReferences) && sizeof($resultReferences) >= 1 && in_array(
  1029.                     $reference,
  1030.                     $resultReferences
  1031.                 )) {
  1032.                 $key = array_search($reference, $resultReferences);
  1033.                 unset($resultReferences[$key]);
  1034.             }
  1036.             // Si la référence existe déjà sur un autre article, on affiche un message d'erreur
  1037.             if (is_array($resultReferences) && sizeof($resultReferences) >= 1 && $reference->getRefReference()) {
  1038.                 $product = $this->entityManager->getRepository(EcoProducts::class)->find(
  1039.                     $resultReferences[0]->getProductId()
  1040.                 );
  1041.                 if ($product && $product->getSiteId() == $this->session->get('admin_site_uid')) {
  1042.                     $this->addFlash('danger', "Cette référence existe déjà sur un autre article");
  1043.                     return $this->redirectToRoute(
  1044.                         'admin_product_reference_edit',
  1045.                         array('prod_id' => $prod_id, 'ref_id' => $reference->getId())
  1046.                     );
  1047.                 }
  1048.             }
  1050.             try {
  1051.                 $reference->setIsReservable(
  1052.                     $request->request->get('product_reference')['isReservable'] == '0' ? false : true
  1053.                 );
  1054.                 $this->entityManager->persist($reference);
  1055.                 $this->entityManager->persist($prod);
  1056.                 $this->entityManager->flush();
  1058.                 $nbRef = $repoReference->findBy(['product_id' => $prod_id]);
  1060.                 if (count($nbRef) <= 1) {
  1061.                     $prod->setProdType('single');
  1062.                 } else {
  1063.                     $prod->setProdType('multiple');
  1064.                 }
  1066.                 $this->entityManager->flush($prod);
  1068.                 //Enregistrement du tarif sur le produit
  1069.                 //                $this->setProductReferencesPrices($repoProduct, $prod_id,
  1070.                 //                                                  $repoReference->findByProductWithReferencesPrices($prod_id));
  1072.                 $this->addFlash('success', "enregistré avec succès");
  1073.             } catch (Exception $ex) {
  1074.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement");
  1075.             }
  1077.             return $this->redirectToRoute(
  1078.                 'admin_product_reference_edit',
  1079.                 array('prod_id' => $prod_id, 'ref_id' => $reference->getId())
  1080.             );
  1081.         }
  1083.         $this->checkOdysseePrice($prod_id);
  1085.         return $this->render('admin/admin_products/product_reference_edit.html.twig', [
  1086.             'stockManagement' => $stockManagement,
  1087.             'product_id' => $prod_id,
  1088.             'reference' => $repoReference->find($ref_id),
  1089.             'form' => $form->createView(),
  1090.             'product' => $prod,
  1091.             'referencesList' => [$reference]
  1092.         ]);
  1093.     }
  1095.     /**
  1096.      * Retourne le prix de vente réel
  1097.      * @param double $selling_price
  1098.      * @param double $promo_price
  1099.      * @param double $solde_price
  1100.      * @return array
  1101.      */
  1102.     private function getReferencePrice($selling_price, $promo_price, $solde_price)
  1103.     {
  1104.         if ($solde_price > 0) {
  1105.             return [
  1106.                 'reference_price' => $solde_price,
  1107.                 'price_type' => 'solde',
  1108.             ];
  1109.         } elseif ($promo_price > 0) {
  1110.             return [
  1111.                 'reference_price' => $promo_price,
  1112.                 'price_type' => 'promo',
  1113.             ];
  1114.         }
  1115.         return [
  1116.             'reference_price' => $selling_price,
  1117.             'price_type' => 'vente',
  1118.         ];
  1119.     }
  1121.     /**
  1122.      * Enregistre le prix d'un produit en fonction de ses références
  1123.      * @param array $references
  1124.      * @return array
  1125.      */
  1126.     private function setProductReferencesPrices($repoProduct, $prod_id, $references)
  1127.     {
  1128.         $product = $repoProduct->find($prod_id);
  1130.         $product->setProdPriceType($references['ref_price_type']);
  1131.         $product->setProdReferencePrice($references['ref_reference_price']);
  1132.         $product->setProdSellingPrice($references['ref_selling_price']);
  1134.         $this->entityManager->persist($product);
  1135.         $this->entityManager->flush();
  1136.     }
  1138.     #[Route(path: '/admin/products/categories/{parent_id}', name: 'admin_products_categories', defaults: ['parent_id' => 0])]
  1139.     public function categories(Request $request, EcoCategoriesRepository $repoCateg, $parent_id)
  1140.     {
  1141.         if ($request->get('categ_entitled')) {
  1142.             if ($request->get('categ_id') > 0) {
  1143.                 $categ = $repoCateg->find($request->get('categ_id'));
  1144.                 $oldBandeau = $categ->getCategHeadband();
  1145.             } else {
  1146.                 $oldBandeau = null;
  1147.                 $categ = new EcoCategories();
  1148.             }
  1150.             $categ->setCategEntitled($request->get('categ_entitled'));
  1151.             //            $categ->setCategParentId($request->get('categ_parent_id'));
  1152.             $categ->setCategParentId(0);
  1153.             $categ->setCategDescription($request->get('categ_description'));
  1154.             $categ->setCategSequence(0);
  1155.             //            $categ->setCategIsonline($request->get('categ_isonline'));
  1156.             $categ->setCategIsonline(true);
  1157.             $categ->setSiteId($this->session->get('admin_site_uid'));
  1160.             // upload du fichier
  1161.             if ($request->files->get("categ_headband") !== null) {
  1162.                 $upload = $this->fileService->startUpload(
  1163.                     [
  1164.                         "fileData" => $request->files->get("categ_headband"),
  1165.                         "oldFileName" => $oldBandeau,
  1166.                         "fileDestination" => $this->getParameter(
  1167.                             "upload_products_" . $this->session->get('admin_site_uid')
  1168.                         ),
  1169.                         "autorizedExtensions" => $this->autorizedImages,
  1170.                         "createWebp" => true
  1171.                     ]
  1172.                 );
  1174.                 // upload OK
  1175.                 if (isset($upload['state']) && $upload['state'] && isset($upload['filename']) && is_string(
  1176.                         $upload['filename']
  1177.                     )) {
  1178.                     $categ->setCategHeadband($upload['filename']);
  1179.                 } // upload KO avec message perso
  1180.                 elseif (isset($upload['error_msg'])) {
  1181.                     $categ->setCategHeadband($oldBandeau);
  1182.                     $errorMsg = $upload['error_msg'];
  1183.                 } // upload KO avec message générique
  1184.                 else {
  1185.                     $categ->setCategHeadband($oldBandeau);
  1186.                     $errorMsg = "Une erreur s'est produite lors de l'enregistrement du fichier";
  1187.                 }
  1188.             }
  1190.             try {
  1191.                 $this->entityManager->persist($categ);
  1192.                 $this->entityManager->flush();
  1193.             } catch (Exception $e) {
  1194.                 $errorMsg = "Une erreur s'est produite lors de l'enregistrement de la catégorie";
  1195.             }
  1197.             // il y a eu une erreur
  1198.             if (isset($errorMsg)) {
  1199.                 $this->addFlash('danger', $errorMsg);
  1200.             } // pas d'erreur
  1201.             else {
  1202.                 $this->addFlash('success', "La catégorie a bien été enregistrée");
  1203.             }
  1204.         }
  1206.         return $this->render('admin/admin_products/products_categories.html.twig', [
  1207.             'parent_id' => $parent_id,
  1208.             'mainCateg' => $repoCateg->find($parent_id),
  1209.             'categList' => $repoCateg->findBy([
  1210.                 'siteId' => $this->session->get('admin_site_uid'),
  1211.                 'categ_parent_id' => $parent_id
  1212.             ], ['categ_sequence' => 'ASC']),
  1213.             'allCategList' => $repoCateg->findBy(['siteId' => $this->session->get('admin_site_uid')])
  1214.         ]);
  1215.     }
  1217.     /**
  1218.      * @param Request $request
  1219.      */
  1220.     #[Route(path: '/admin/products/axDisplayFormCategory', options: ['expose' => true])]
  1221.     public function axDisplayFormCategory(Request $request, EcoCategoriesRepository $repoCateg)
  1222.     {
  1223.         if ($request->isXmlHttpRequest()) {
  1224.             $category = new EcoCategories;
  1225.             if ($request->get('categ_id') > 0) {
  1226.                 $category = $repoCateg->find($request->get('categ_id'));
  1227.             }
  1229.             $renderModale = $this->renderView('admin/admin_products/tpl_form_category.html.twig', [
  1230.                 'modalTitle' => 'Catégorie',
  1231.                 'categ_id' => $request->get('categ_id'),
  1232.                 'categ' => $category,
  1233.                 'categList' => $repoCateg->findBy([
  1234.                     'siteId' => $this->session->get('admin_site_uid'),
  1235.                     'categ_parent_id' => 0
  1236.                 ], ['categ_sequence' => 'ASC']),
  1237.                 'autorizedMedias' => $this->autorizedImages,
  1238.             ]);
  1240.             return new JsonResponse([
  1241.                 'status' => true,
  1242.                 'modal' => html_entity_decode($renderModale),
  1243.             ]);
  1244.         }
  1246.         return new JsonResponse([
  1247.             'status' => false,
  1248.         ]);
  1249.     }
  1251.     #[Route(path: '/admin/products/category/remove/{id}', name: 'admin_products_category_remove', defaults: ['id' => 0])]
  1252.     public function remove_category(
  1253.         Request                 $request,
  1254.         EcoCategoriesRepository $repoCateg,
  1255.         EcoProductsRepository   $ecoProductsRepository,
  1256.                                 $id
  1257.     )
  1258.     {
  1259.         $category = new EcoCategories;
  1261.         if ($id > 0) {
  1262.             $category = $repoCateg->find($id);
  1264.             $productInCateg = $ecoProductsRepository->findBy(['category_id' => $category->getId()]);
  1266.             if ($productInCateg != null) {
  1267.                 $this->addFlash('danger', "Impossible de supprimer une catégorie possédant des produits");
  1268.                 return $this->redirectToRoute('admin_products_categories');
  1269.             }
  1271.             try {
  1272.                 $this->entityManager->remove($category);
  1273.                 $this->entityManager->flush();
  1274.                 $this->addFlash('success', "Suppression avec succès");
  1275.             } catch (Exception $e) {
  1276.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  1277.             }
  1278.         }
  1280.         return $this->redirectToRoute('admin_products_categories');
  1281.     }
  1283.     #[Route(path: '/admin/products/axDisplayOrderCateg', options: ['expose' => true])]
  1284.     public function axDisplayOrderCateg(Request $request, EcoCategoriesRepository $repoCateg)
  1285.     {
  1286.         if ($request->isXmlHttpRequest()) {
  1287.             $renderModale = $this->renderView('admin/admin_products/tpl_reordonner_categories.html.twig', [
  1288.                 'modalTitle' => 'Ordonner les catégories',
  1289.                 'categ_parent' => $request->get('categ_parent'),
  1290.                 'categList' => $repoCateg->findBy([
  1291.                     'siteId' => $this->session->get('admin_site_uid'),
  1292.                     'categ_parent_id' => $request->get('categ_parent')
  1293.                 ],
  1294.                     ['categ_sequence' => 'ASC'])
  1295.             ]);
  1297.             $script = '';
  1298.             $script .= " initSortableCategories(); ";
  1300.             return new JsonResponse([
  1301.                 'status' => true,
  1302.                 'modal' => html_entity_decode($renderModale),
  1303.                 'script' => $script,
  1304.             ]);
  1305.         }
  1307.         return new JsonResponse([
  1308.             'status' => false,
  1309.         ]);
  1310.     }
  1312.     /**
  1313.      * @param Request $request
  1314.      */
  1315.     #[Route(path: '/admin/products/axUpdateOrderCategorie', options: ['expose' => true])]
  1316.     public function axUpdateOrderCategorie(Request $request)
  1317.     {
  1318.         if ($request->isXmlHttpRequest() && $request->get('sorted')) {
  1319.             $liste = explode('&', $request->get('sorted'));
  1320.             $i = 1;
  1322.             foreach ($liste as $ligne) {
  1323.                 $id = str_replace('sort=', '', $ligne);
  1324.                 $categ = $this->entityManager->getRepository(EcoCategories::class)->find($id);
  1325.                 $categ->setCategSequence($i);
  1326.                 $this->entityManager->flush();
  1327.                 $i++;
  1328.             }
  1330.             return new JsonResponse([
  1331.                 'status' => true,
  1332.             ]);
  1333.         }
  1335.         return new JsonResponse([
  1336.             'status' => false,
  1337.         ]);
  1338.     }
  1340.     /**
  1341.      * @param Request $request
  1342.      */
  1343.     #[Route(path: '/admin/products/axRemoveCategBandeau', options: ['expose' => true])]
  1344.     public function axRemoveCategBandeau(
  1345.         Request                 $request,
  1346.         EcoCategoriesRepository $repo,
  1347.         FlashNotificationAjax   $flash
  1348.     )
  1349.     {
  1350.         $script = "";
  1351.         if ($request->isXmlHttpRequest()) {
  1352.             $categ = new EcoCategories;
  1353.             if ($request->request->get("categ_id") > 0) {
  1354.                 $categ = $repo->find($request->request->get("categ_id"));
  1355.             }
  1357.             if ($categ->getId() > 0) {
  1358.                 $filename = $categ->getCategHeadband();
  1360.                 if ($filename != null && $filename != "" && is_string($filename) && $this->filesystem->exists(
  1361.                         $file = $this->getParameter(
  1362.                                 'upload_products_' . $this->session->get('admin_site_uid')
  1363.                             ) . "/" . $filename
  1364.                     )) {
  1365.                     $this->fileService->removeFile([
  1366.                         "filePath" => $this->getParameter('upload_products_' . $this->session->get('admin_site_uid')),
  1367.                         "filename" => $filename,
  1368.                     ]);
  1369.                     $categ->setCategHeadband(null);
  1370.                     try {
  1371.                         $this->entityManager->persist($categ);
  1372.                         $this->entityManager->flush();
  1373.                         $msg = "Le bandeau de la catégorie <b>" . $categ->getCategEntitled() . "</b> a été supprimé";
  1374.                         $type = "success";
  1375.                     } catch (Exception $e) {
  1376.                         $msg = "Le bandeau de la catégorie <b>" . $categ->getCategEntitled() . "</b> n'a pas été supprimé";
  1377.                         $type = "danger";
  1378.                     }
  1380.                     return new JsonResponse([
  1381.                         'status' => true,
  1382.                         'script' => $script,
  1383.                         'flashMessage' => $flash->notification($type, $msg),
  1384.                     ]);
  1385.                 }
  1386.             }
  1387.         }
  1389.         return new JsonResponse([
  1390.             'status' => false,
  1391.         ]);
  1392.     }
  1394.     #[Route(path: '/admin/products/attributes_models', name: 'admin_products_attributes_models')]
  1395.     public function attributes_models(Request $request, EcoAttributesModelsRepository $repoModel)
  1396.     {
  1397.         if ($request->get('model')) {
  1398.             if ($request->get('model_id') > 0) {
  1399.                 $model = $repoModel->find($request->get('model_id'));
  1400.             } else {
  1401.                 $model = new EcoAttributesModels();
  1402.             }
  1404.             $model->setModel($request->get('model'));
  1405.             $model->setModelType($request->get('model_type'));
  1407.             try {
  1408.                 $this->entityManager->persist($model);
  1409.                 $this->entityManager->flush();
  1410.                 $this->addFlash('success', "Le modèle d'attribut a bien été enregistrée");
  1411.             } catch (Exception $e) {
  1412.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement du modèle.");
  1413.             }
  1414.         }
  1416.         return $this->render('admin/admin_products/products_attributes_models.html.twig', [
  1417.             'modelsList' => $repoModel->findBy([], ['model' => 'ASC']),
  1418.         ]);
  1419.     }
  1421.     /**
  1422.      * @param Request $request
  1423.      */
  1424.     #[Route(path: '/admin/products/axDisplayFormAttributeModel', options: ['expose' => true])]
  1425.     public function axDisplayFormAttributeModel(Request $request, EcoAttributesModelsRepository $repoModel)
  1426.     {
  1427.         if ($request->isXmlHttpRequest()) {
  1428.             $model = new EcoAttributesModels;
  1429.             if ($request->get('model_id') > 0) {
  1430.                 $model = $repoModel->find($request->get('model_id'));
  1431.             }
  1433.             $renderModale = $this->renderView('admin/admin_products/tpl_form_attribute_model.html.twig', [
  1434.                 'modalTitle' => "Modèle d'attribut",
  1435.                 'model_id' => $request->get('model_id'),
  1436.                 'model' => $model,
  1437.             ]);
  1439.             return new JsonResponse([
  1440.                 'status' => true,
  1441.                 'modal' => html_entity_decode($renderModale),
  1442.             ]);
  1443.         }
  1445.         return new JsonResponse([
  1446.             'status' => false,
  1447.         ]);
  1448.     }
  1450.     /**
  1451.      * @param Request $request
  1452.      */
  1453.     #[Route(path: '/admin/products/axDisplayFormAttribute', options: ['expose' => true])]
  1454.     public function axDisplayFormAttribute(Request $request, EcoAttributesRepository $repoAttr)
  1455.     {
  1456.         if ($request->isXmlHttpRequest()) {
  1457.             $attribut = new EcoAttributesModels;
  1458.             if ($request->get('attr_id') > 0) {
  1459.                 $attribut = $repoAttr->find($request->get('attr_id'));
  1460.             }
  1462.             $renderModale = $this->renderView('admin/admin_products/tpl_form_attribute.html.twig', [
  1463.                 'modalTitle' => 'Attributs',
  1464.                 'attribut' => $attribut,
  1465.             ]);
  1467.             return new JsonResponse([
  1468.                 'status' => true,
  1469.                 'modal' => html_entity_decode($renderModale),
  1470.             ]);
  1471.         }
  1473.         return new JsonResponse([
  1474.             'status' => false,
  1475.         ]);
  1476.     }
  1478.     #[Route(path: '/admin/products/attribute_model/remove/{id}', name: 'admin_products_attribute_model_remove', defaults: ['id' => 0])]
  1479.     public function remove_model(
  1480.         Request                         $request,
  1481.         EcoAttributesModelsRepository   $repoModel,
  1482.         EcoProductsReferencesRepository $ecoProductsReferencesRepository,
  1483.         EcoAttributesRepository         $ecoAttributesRepository,
  1484.                                         $id
  1485.     )
  1486.     {
  1487.         $model = new EcoCategories;
  1489.         if ($id > 0) {
  1490.             $model = $repoModel->find($id);
  1492.             $productInModel = $ecoProductsReferencesRepository->findByProductsContainRef($model->getId());
  1494.             if ($productInModel != null) {
  1495.                 $this->addFlash('danger', "Impossible de supprimer un modèle possédant des produits");
  1496.                 return $this->redirectToRoute('admin_products_attributes_models');
  1497.             }
  1499.             try {
  1500.                 $attrOfModel = $ecoAttributesRepository->findBy(['model_id' => $model->getId()]);
  1502.                 foreach ($attrOfModel as $attribute) {
  1503.                     $this->entityManager->remove($attribute);
  1504.                 }
  1506.                 $this->entityManager->remove($model);
  1507.                 $this->entityManager->flush();
  1508.                 $this->addFlash('success', "Suppression avec succès");
  1509.             } catch (Exception $e) {
  1510.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  1511.             }
  1512.         }
  1514.         return $this->redirectToRoute('admin_products_attributes_models');
  1515.     }
  1517.     #[Route(path: '/admin/products/attributs/{model_id}', name: 'admin_products_attributes', defaults: ['model_id' => ''])]
  1518.     public function attributes(
  1519.         $model_id,
  1520.         Request $request,
  1521.         EcoAttributesModelsRepository $repoModel,
  1522.         EcoAttributesRepository $repoAttr
  1523.     )
  1524.     {
  1525.         if ($request->get('attributes')) {
  1526.             $attributs = explode(',', $request->get('attributes'));
  1527.             if (is_array($attributs) && sizeof($attributs) > 0) {
  1528.                 foreach ($attributs as $attribut) {
  1529.                     $attr = new EcoAttributes;
  1530.                     $attr->setModelId($model_id);
  1531.                     $attr->setAttribute($attribut);
  1532.                     $this->entityManager->persist($attr);
  1533.                 }
  1534.             }
  1536.             try {
  1537.                 $this->entityManager->flush();
  1538.                 $this->addFlash('success', "enregistré avec succès");
  1539.             } catch (Exception $e) {
  1540.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement");
  1541.             }
  1542.         }
  1544.         return $this->render('admin/admin_products/products_attributes.html.twig', [
  1545.             'model' => $repoModel->find($model_id),
  1546.             'attributesList' => $repoAttr->findBy(['model_id' => $model_id], ['attribute' => 'ASC']),
  1547.         ]);
  1548.     }
  1550.     #[Route(path: '/admin/products/attributes_remove/{id}', name: 'admin_products_attribute_remove', defaults: ['id' => 0])]
  1551.     public function remove_attributes(
  1552.         Request                         $request,
  1553.         EcoAttributesRepository         $repoAttr,
  1554.         EcoProductsReferencesRepository $ecoProductsReferencesRepository,
  1555.                                         $id
  1556.     )
  1557.     {
  1558.         $attr = new EcoAttributes;
  1560.         if ($id > 0) {
  1561.             $attr = $repoAttr->find($id);
  1563.             $productInModel = $ecoProductsReferencesRepository->findByProductsContainAttr($attr->getId());
  1565.             if ($productInModel != null) {
  1566.                 $this->addFlash('danger', "Impossible de supprimer un attribut associé à des produits");
  1567.                 return $this->redirectToRoute('admin_products_attributes', ['model_id' => $attr->getModelId()]);
  1568.             }
  1570.             try {
  1571.                 $this->entityManager->remove($attr);
  1572.                 $this->entityManager->flush();
  1573.                 $this->addFlash('success', "Suppression avec succès");
  1574.             } catch (Exception $e) {
  1575.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  1576.             }
  1577.         }
  1579.         return $this->redirectToRoute('admin_products_attributes', ['model_id' => $attr->getModelId()]);
  1580.     }
  1583.     #[Route(path: '/admin/products/save_attribute', name: 'admin_products_save_attribute')]
  1584.     public function save_attribute(Request $request, EcoAttributesRepository $repoAttr)
  1585.     {
  1586.         $attr = new EcoAttributes;
  1588.         if ($request->get('attr_id') > 0) {
  1589.             $attr = $repoAttr->find($request->get('attr_id'));
  1590.             $attr->setAttribute($request->get('attribute'));
  1592.             try {
  1593.                 $this->entityManager->persist($attr);
  1594.                 $this->entityManager->flush();
  1595.                 $this->addFlash('success', "enregistré avec succès");
  1596.             } catch (Exception $e) {
  1597.                 $this->addFlash('danger', "Une erreur s'est produite lors de l'enregistrement");
  1598.             }
  1599.         }
  1601.         return $this->redirectToRoute('admin_products_attributes', ['model_id' => $attr->getModelId()]);
  1602.     }
  1604.     #[Route(path: '/admin/product_presentation/{prod_id}', name: 'admin_product_presentation', defaults: ['prdo_id' => 0])]
  1605.     public function product_presentation(
  1606.         Request                 $request,
  1607.         EcoProductsRepository   $repoProduct,
  1608.         EcoCategoriesRepository $repoCateg,
  1609.         EcoMarksRepository      $repoMarks,
  1610.                                 $prod_id
  1611.     )
  1612.     {
  1613.         return $this->render('admin/admin_products/product_presentation.html.twig', [
  1614.             'product_id' => $prod_id,
  1615.             'product' => $repoProduct->find($prod_id),
  1616.             'referencesList' => $this->entityManager->getRepository(EcoProductsReferences::class)->findBy(
  1617.                 ['product_id' => $prod_id],
  1618.                 ['ref_sequence' => 'ASC']
  1619.             ),
  1620.         ]);
  1621.     }
  1623.     /**
  1624.      * @param Request $request
  1625.      */
  1626.     #[Route(path: '/admin/products/axAddBlock', options: ['expose' => true])]
  1627.     public function axAddBlock(Request $request)
  1628.     {
  1629.         if ($request->isXmlHttpRequest()) {
  1630.             //Insérer un bloc
  1631.             $bloc = new EcoProductsBlocks;
  1632.             $bloc->setProductId($request->get('prod_id'));
  1633.             $bloc->setProdBlockType($request->get('bloc_type'));
  1635.             $this->entityManager->persist($bloc);
  1636.             $this->entityManager->flush();
  1638.             if ($bloc->getId() > 0) {
  1639.                 $html = $this->renderView('admin/admin_products/bloc_' . $request->get('bloc_type') . '.html.twig', [
  1640.                     'bloc' => $bloc,
  1641.                 ]);
  1643.                 $script = '';
  1644.                 //Init éditeur de texte
  1645.                 if (in_array($bloc->getProdBlockType(), array('text', 'text_picture', 'text_slider'))) {
  1646.                     $script .= " startEditor('#editeur_texte" . $bloc->getId() . "'); ";
  1647.                 }
  1648.                 $script .= "addObserver(" . $bloc->getId() . ");";
  1649.                 $script .= " $('html, body').animate({ scrollTop:$('#env" . $bloc->getId() . "').offset().top }, 'slow'); ";
  1650.             }
  1652.             return new JsonResponse([
  1653.                 'status' => true,
  1654.                 'html' => html_entity_decode($html),
  1655.                 'script' => $script
  1656.             ]);
  1657.         }
  1659.         return new JsonResponse([
  1660.             'status' => false,
  1661.         ]);
  1662.     }
  1664.     /**
  1665.      * @param Request $request
  1666.      */
  1667.     #[Route(path: '/admin/products/axUpdateBlock', options: ['expose' => true])]
  1668.     public function axUpdateBlock(Request $request, FlashNotificationAjax $flash)
  1669.     {
  1670.         if ($request->isXmlHttpRequest() && $request->get('bloc_id')) {
  1671.             $entityManager = $this->getDoctrine()->getManager();
  1672.             $bloc = $entityManager->getRepository(EcoProductsBlocks::class)->find($request->get('bloc_id'));
  1674.             if (!$bloc) {
  1675.                 throw $this->createNotFoundException(
  1676.                     'Aucun bloc trouvé pour identifiant : ' . $request->get('bloc_id')
  1677.                 );
  1678.             }
  1680.             parse_str($request->get('data'), $datas);
  1682.             $bloc->setProdBlockTextPicture(
  1683.                 isset($datas['prod_block_text_picture']) ? $datas['prod_block_text_picture'] : null
  1684.             );
  1685.             $bloc->setProdBlockTitle(isset($datas['prod_block_title']) ? $datas['prod_block_title'] : null);
  1686.             $bloc->setProdBlockSubtitle(isset($datas['prod_block_subtitle']) ? $datas['prod_block_subtitle'] : null);
  1687.             $bloc->setProdBlockText(isset($datas['prod_block_text']) ? $datas['prod_block_text'] : null);
  1688.             $bloc->setProdBlockEmbed(isset($datas['prod_block_embed']) ? $datas['prod_block_embed'] : null);
  1689.             $bloc->setProdBlockMulticolumn(
  1690.                 isset($datas['prod_block_multicolumn']) ? $datas['prod_block_multicolumn'] : null
  1691.             );
  1692.             $bloc->setProdBlockAlignment(isset($datas['prod_block_alignment']) ? $datas['prod_block_alignment'] : null);
  1693.             $bloc->setProdBlockMarginTop(
  1694.                 isset($datas['prod_block_margin_top']) && $datas['prod_block_margin_top'] != "" ? $datas['prod_block_margin_top'] : null
  1695.             );
  1696.             $bloc->setProdBlockMarginBottom(
  1697.                 isset($datas['prod_block_margin_bottom']) && $datas['prod_block_margin_bottom'] != "" ? $datas['prod_block_margin_bottom'] : null
  1698.             );
  1700.             //Enregistrement du titre des médias
  1701.             if (isset($datas['media_ids']) && is_array($datas['media_ids'])) {
  1702.                 foreach ($datas['media_ids'] as $media_id) {
  1703.                     $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($media_id);
  1704.                     $media->setProdMediaAlt($datas['prod_media_alt' . $media_id]);
  1705.                 }
  1706.             }
  1708.             $entityManager->flush();
  1710.             return new JsonResponse([
  1711.                 'status' => true,
  1712.                 'flashMessage' => $flash->notification('success', 'enregistré avec succès'),
  1713.             ]);
  1714.         } else {
  1715.             return new JsonResponse([
  1716.                 'status' => false,
  1717.             ]);
  1718.         }
  1719.     }
  1721.     /**
  1722.      * @param Request $request
  1723.      */
  1724.     #[Route(path: '/admin/products/axDisplayBlocs', options: ['expose' => true])]
  1725.     public function axDisplayBlocs(Request $request)
  1726.     {
  1727.         if ($request->isXmlHttpRequest() && $request->get('prod_id') > 0) {
  1728.             $result = $this->displayBlocs($request->get('prod_id'));
  1729.             return new JsonResponse([
  1730.                 'status' => true,
  1731.                 'script' => $result['script'],
  1732.                 'renderBloc' => $result['html'],
  1733.             ]);
  1734.         }
  1736.         return new JsonResponse([
  1737.             'status' => false,
  1738.         ]);
  1739.     }
  1741.     private function displayBlocs($prod_id)
  1742.     {
  1743.         $repository = $this->getDoctrine()->getRepository(EcoProductsBlocks::class);
  1744.         $blocs = $repository->findBy(array('product_id' => $prod_id), array('prod_block_sequence' => 'ASC'));
  1746.         if (is_array($blocs) && sizeof($blocs) > 0) {
  1747.             $html = $script = "";
  1748.             $i = 0;
  1749.             foreach ($blocs as $bloc) {
  1750.                 $resultMedias = $this->displayMedias($bloc->getId(), $bloc->getProdBlockType());
  1752.                 $html .= $this->renderView('admin/admin_products/bloc_' . $bloc->getProdBlockType() . '.html.twig', [
  1753.                     'bloc' => $bloc,
  1754.                     'srcImage' => $resultMedias['srcImage'],
  1755.                     'listeImages' => $resultMedias['listeImages'],
  1756.                     'listeDocuments' => $resultMedias['listeDocuments'],
  1757.                     'imageRub' => $resultMedias['imageRub'],
  1758.                     'idImage' => $resultMedias['idImage']
  1759.                 ]);
  1761.                 $script .= " addObserver(" . $bloc->getId() . "); ";
  1763.                 if (in_array($bloc->getProdBlockType(), array('gallery'))) {
  1764.                     $script .= " initSortableImages('" . $bloc->getId() . "'); ";
  1765.                 }
  1767.                 //Init éditeur de texte
  1768.                 if (in_array($bloc->getProdBlockType(), array('text', 'text_picture', 'text_slider'))) {
  1769.                     $script .= " startEditor('#editeur_texte" . $bloc->getId() . "'); ";
  1770.                 }
  1772.                 $i++;
  1773.             }
  1775.             return [
  1776.                 'html' => $html,
  1777.                 'script' => $script,
  1778.             ];
  1779.         }
  1781.         return [
  1782.             'html' => null,
  1783.             'script' => null,
  1784.         ];
  1785.     }
  1787.     private function displayMedias($bloc_id, $bloc_type)
  1788.     {
  1789.         $srcImage = $listeImages = $listeDocuments = $imageRub = $idImage = null;
  1790.         $repository = $this->getDoctrine()->getRepository(EcoProductsBlocksMedias::class);
  1792.         if ($bloc_type == 'document') {
  1793.             $listeDocuments = $repository->findByMediasByBloc($bloc_id, 'file');
  1794.         } elseif (in_array($bloc_type, array('text_picture', 'picture'))) {
  1795.             $images = $repository->findByMediasByBloc($bloc_id, 'picture');
  1797.             if (isset($images[0]['prod_media_file'])) {
  1798.                 $imageRub = $images[0];
  1799.                 $srcImage = $images[0]['prod_media_file'];
  1800.                 $idImage = $images[0]['id'];
  1801.             }
  1802.         } elseif (in_array($bloc_type, array('gallery'))) {
  1803.             $images = $repository->findByMediasByBlocGalerie($bloc_id);
  1805.             if (is_array($images) && sizeof($images) > 0) {
  1806.                 $listeImages = $images;
  1807.             }
  1808.         } else {
  1809.             $images = $repository->findByMediasByBloc($bloc_id, 'picture');
  1811.             if (is_array($images) && sizeof($images) > 0) {
  1812.                 $listeImages = $images;
  1813.             }
  1814.         }
  1816.         return array(
  1817.             'srcImage' => $srcImage,
  1818.             'listeImages' => $listeImages,
  1819.             'listeDocuments' => $listeDocuments,
  1820.             'imageRub' => $imageRub,
  1821.             'idImage' => $idImage,
  1822.         );
  1823.     }
  1825.     #[Route(path: '/admin/products/upload-media', options: ['expose' => true])]
  1826.     public function uploadStreamMedias(Request $request, OtideaUtils $utils)
  1827.     {
  1828.         $output = 'ok';
  1830.         $bloc_id = $request->query->get('bloc_id');
  1831.         $fileName = $request->query->get('filename');
  1832.         $fileSize = $request->query->get('filesize');
  1834.         $infosFile = pathinfo($fileName);
  1835.         $typeMedias = $utils->getTypeMedia($infosFile["extension"], $isEnglishVersion = true);
  1837.         if ($typeMedias == null) {
  1838.             $output = 'extension';
  1839.         } elseif ($fileSize > $this->maxFileSize) {
  1840.             $output = 'size';
  1841.         } else {
  1842.             $this->currentFileName = date('his') . $utils->nettoyer_nom(urldecode($fileName));
  1843.             $this->idAuteur = $bloc_id > 0 ? $bloc_id : null;
  1845.             $tmpFilePath = $this->getParameter(
  1846.                     'kernel.project_dir'
  1847.                 ) . '/' . $this->pathFiles . '/tmpFiles/' . $fileName;
  1848.             $inputHandler = fopen('php://input', "r");
  1849.             // create a temp file where to save data from the input stream
  1850.             $fileHandler = fopen($tmpFilePath, "w+");
  1852.             // save data from the input stream
  1853.             while (true) {
  1854.                 $buffer = fgets($inputHandler, 4096);
  1856.                 if (strlen($buffer) == 0) {
  1857.                     fclose($inputHandler);
  1858.                     fclose($fileHandler);
  1859.                     break;
  1860.                 }
  1861.                 fwrite($fileHandler, $buffer);
  1862.             }
  1864.             rename(
  1865.                 $tmpFilePath,
  1866.                 $this->getParameter('kernel.project_dir') . '/' . $this->pathFiles . '/' . $this->currentFileName
  1867.             );
  1868.             //WEBP
  1869.             $this->fileService->saveWebP([
  1870.                 "fileDestination" => $this->getParameter('kernel.project_dir') . '/' . $this->pathFiles,
  1871.                 "filename" => $this->currentFileName
  1872.             ]);
  1874.             //SAUVEGARDE DU MEDIA
  1875.             $entityManager = $this->getDoctrine()->getManager();
  1876.             $bloc = $entityManager->getRepository(EcoProductsBlocks::class)->find($request->query->get('bloc_id'));
  1878.             //Dans le cas d'un bloc image on supprime l'ancienne image avant de mettre la nouvelle
  1879.             if (in_array($bloc->getProdBlockType(), array('picture', 'text_picture'))) {
  1880.                 $entityManager = $this->getDoctrine()->getManager();
  1881.                 $mediasDB = $this->getDoctrine()->getRepository(EcoProductsBlocksMedias::class);
  1882.                 $medias = $mediasDB->findBy(array('block_id' => $bloc_id));
  1884.                 if (is_array($medias) && sizeof($medias) > 0) {
  1885.                     foreach ($medias as $media) {
  1886.                         $this->fileService->removeFile([
  1887.                             "filePath" => $this->getParameter('kernel.project_dir') . '/' . $this->pathFiles,
  1888.                             "filename" => $media->getProdMediaFile(),
  1889.                         ]);
  1890.                         $entityManager->remove($media);
  1891.                     }
  1892.                 }
  1894.                 $entityManager->flush();
  1895.             }
  1897.             //Sauvegarder le media
  1898.             $this->saveMedia($bloc_id, $this->currentFileName, $typeMedias);
  1899.         }
  1901.         return new Response(
  1902.             $output, Response::HTTP_OK, ['content-type' => 'text/plain']
  1903.         );
  1904.     }
  1906.     private function saveMedia($bloc_id, $fileName, $typeMedias)
  1907.     {
  1908.         $entityManager = $this->getDoctrine()->getManager();
  1910.         $media = new EcoProductsBlocksMedias();
  1911.         $media->setBlockId($bloc_id);
  1912.         $media->setProdMediaAlt(null);
  1913.         $media->setProdMediaFile($fileName);
  1914.         $media->setProdMediaType($typeMedias);
  1915.         $media->setProdMediaSequence(
  1916.             $entityManager->getRepository(EcoProductsBlocksMedias::class)->findOneByMaxMediaOrdre(
  1917.                 $bloc_id
  1918.             )['mediaCount']
  1919.         );
  1920.         //        $media->setProdMediaLink('');
  1921.         //        $media->setProdMediaIsblank(0);
  1923.         $entityManager->persist($media);
  1924.         $entityManager->flush();
  1925.     }
  1927.     /**
  1928.      * @param Request $request
  1929.      */
  1930.     #[Route(path: '/admin/products/axDeleteBlock', options: ['expose' => true])]
  1931.     public function axDeleteBlock(Request $request)
  1932.     {
  1933.         if ($request->isXmlHttpRequest() && $request->get('bloc_id')) {
  1934.             $entityManager = $this->getDoctrine()->getManager();
  1935.             $bloc = $entityManager->getRepository(EcoProductsBlocks::class)->find($request->get('bloc_id'));
  1937.             $entityManager->remove($bloc);
  1938.             $entityManager->flush();
  1940.             //Suppression des médias
  1941.             $mediasDB = $this->getDoctrine()->getRepository(EcoProductsBlocksMedias::class);
  1942.             $medias = $mediasDB->findBy(array('block_id' => $request->get('bloc_id')));
  1944.             if (is_array($medias)) {
  1945.                 foreach ($medias as $media) {
  1946.                     $this->fileService->removeFile([
  1947.                         "filePath" => $this->getParameter('upload_products_' . $this->session->get('admin_site_uid')),
  1948.                         "filename" => $media->getProdMediaFile(),
  1949.                     ]);
  1950.                     $entityManager->remove($media);
  1951.                 }
  1952.             }
  1955.             $entityManager->flush();
  1957.             $script = '';
  1958.             $script .= " $('#env" . $request->get('bloc_id') . "').slideUp('slow', function(){ $('#env" . $request->get(
  1959.                     'bloc_id'
  1960.                 ) . "').remove(); }); ";
  1962.             return new JsonResponse([
  1963.                 'status' => true,
  1964.                 'bloc_id' => $request->get('bloc_id'),
  1965.                 'script' => $script
  1966.             ]);
  1967.         } else {
  1968.             return new JsonResponse([
  1969.                 'status' => false,
  1970.             ]);
  1971.         }
  1972.     }
  1974.     /**
  1975.      * @param Request $request
  1976.      */
  1977.     #[Route(path: '/admin/products/axDeletePhoto', options: ['expose' => true])]
  1978.     public function axDeletePhoto(Request $request)
  1979.     {
  1980.         if ($request->isXmlHttpRequest() && $request->get('media_id') > 0) {
  1981.             $fileName = '';
  1982.             $bloc_id = 0;
  1984.             try {
  1985.                 $entityManager = $this->getDoctrine()->getManager();
  1986.                 $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($request->get('media_id'));
  1987.                 $fileName = $media->getProdMediaFile();
  1988.                 $bloc_id = $media->getBlockId();
  1989.                 $entityManager->remove($media);
  1990.                 $entityManager->flush();
  1991.             } catch (Exception $ex) {
  1992.                 echo "Exception Found - " . $ex->getMessage() . "<br/>";
  1993.             }
  1995.             $pathFile = $this->getParameter('kernel.project_dir') . '/' . $this->pathFiles . '/' . $fileName;
  1996.             if (file_exists($pathFile)) {
  1997.                 $this->fileService->removeFile([
  1998.                     "filePath" => $this->getParameter('kernel.project_dir') . '/' . $this->pathFiles,
  1999.                     "filename" => $fileName,
  2000.                 ]);
  2001.             }
  2003.             $script = '';
  2004.             if (in_array($request->get('bloc_type'), array('document'))) {
  2005.                 $script .= " $('#file_" . $request->get('media_id') . "').remove(); ";
  2006.             } elseif (in_array($request->get('bloc_type'), array('picture', 'text_picture'))) {
  2007.                 $script .= " $('#img" . $bloc_id . "').attr('src','" . $request->getSchemeAndHttpHost() . "/medias_admin/upload-image.png'); ";
  2008.                 $script .= " $('#del" . $bloc_id . "').hide(); ";
  2009.                 $script .= " $('#lienGalerie" . $bloc_id . "').hide(); ";
  2010.             } else {
  2011.                 $script .= " $('#galerie-img-" . $request->get('media_id') . "').remove(); ";
  2012.             }
  2014.             return new JsonResponse([
  2015.                 'status' => true,
  2016.                 'script' => $script,
  2017.             ]);
  2018.         }
  2020.         return new JsonResponse([
  2021.             'status' => false,
  2022.         ]);
  2023.     }
  2025.     /**
  2026.      * @param Request $request
  2027.      */
  2028.     #[Route(path: '/admin/products/axDisplayMedias', options: ['expose' => true])]
  2029.     public function axDisplayMedias(Request $request)
  2030.     {
  2031.         if ($request->isXmlHttpRequest() && $request->get('bloc_id') > 0) {
  2032.             $script = '';
  2033.             $renderGalerie = $renderDocument = null;
  2035.             $entityManager = $this->getDoctrine()->getManager();
  2036.             $bloc = $entityManager->getRepository(EcoProductsBlocks::class)->find($request->get('bloc_id'));
  2038.             if ($bloc->getProdBlockType() == 'document') {
  2039.                 $documents = $entityManager->getRepository(EcoProductsBlocksMedias::class)->findByMediasByBloc(
  2040.                     $request->get('bloc_id'),
  2041.                     'file'
  2042.                 );
  2043.                 $blocArray['id'] = $request->get('bloc_id');
  2044.                 $blocArray['prodBlockType'] = $bloc->getProdBlockType();
  2046.                 $renderDocument = $this->renderView('admin/admin_products/tpl_document_liste.html.twig', [
  2047.                     'bloc' => $blocArray,
  2048.                     'listeDocuments' => $documents,
  2049.                 ]);
  2050.                 //Une seule image à afficher
  2051.             } elseif (in_array($bloc->getProdBlockType(), array('text_picture', 'picture'))) {
  2052.                 //                $images = $entityManager->getRepository(Pages::class)->findByImagesByBloc($request->get('bloc_id'));
  2053.                 $images = $entityManager->getRepository(EcoProductsBlocksMedias::class)->findBy(
  2054.                     [
  2055.                         'block_id' => $request->get('bloc_id'),
  2056.                         'prod_media_type' => 'picture'
  2057.                     ],
  2058.                     ['prod_media_sequence' => 'ASC']
  2059.                 );
  2061.                 $src = $request->getSchemeAndHttpHost() . '/medias_front/products/' . $images[0]->getProdMediaFile();
  2062.                 $script .= ' $("#img' . $bloc->getId() . '").attr("src","' . $src . '"); ';
  2064.                 $script .= " $('#del" . $bloc->getId() . "').attr('onclick','deletePhoto(" . $images[0]->getId() . ", \'" . $bloc->getProdBlockType() . "\');'); ";
  2065.                 $script .= " $('#del" . $bloc->getId() . "').show(); ";
  2066.                 $script .= " $('#lienGalerie" . $bloc->getId() . "').attr('onclick','displayModalMedia(" . $images[0]->getId() . ", \'" . $bloc->getProdBlockType() . "\');'); ";
  2067.                 $script .= " $('#lienGalerie" . $bloc->getId() . "').show(); ";
  2068.                 $script .= " $('.progress').width('0%'); ";
  2069.                 //Plusieurs images à afficher
  2070.             } elseif (in_array($bloc->getProdBlockType(), array('gallery'))) {
  2071.                 $images = $entityManager->getRepository(EcoProductsBlocksMedias::class)->findByMediasByBlocGalerie(
  2072.                     $request->get('bloc_id')
  2073.                 );
  2074.                 $blocArray['id'] = $request->get('bloc_id');
  2076.                 $renderGalerie = $this->renderView('admin/admin_products/tpl_galerie_images.html.twig', [
  2077.                     'bloc' => $blocArray,
  2078.                     'listeImages' => $images,
  2079.                 ]);
  2081.                 $script .= " initSortableImages('" . $request->get('bloc_id') . "'); ";
  2082.             } else {
  2083.                 $images = $entityManager->getRepository(EcoProductsBlocksMedias::class)->findByMediasByBloc(
  2084.                     $request->get('bloc_id'),
  2085.                     'picture'
  2086.                 );
  2087.                 $blocArray['id'] = $request->get('bloc_id');
  2089.                 $renderGalerie = $this->renderView('admin/admin_products/tpl_galerie_images.html.twig', [
  2090.                     'bloc' => $blocArray,
  2091.                     'listeImages' => $images,
  2092.                 ]);
  2094.                 $script .= " initSortableImages('" . $request->get('bloc_id') . "'); ";
  2095.             }
  2097.             $script .= ' $("#img' . $bloc->getId() . '").css("zIndex",2); ';
  2099.             return new JsonResponse([
  2100.                 'status' => true,
  2101.                 'script' => $script,
  2102.                 'renderGalerie' => $renderGalerie,
  2103.                 'renderDocument' => $renderDocument,
  2104.             ]);
  2105.         }
  2107.         return new JsonResponse([
  2108.             'status' => false,
  2109.         ]);
  2110.     }
  2112.     /**
  2113.      * @param Request $request
  2114.      */
  2115.     #[Route(path: '/admin/products/axEmbedGalerie', options: ['expose' => true])]
  2116.     public function axEmbedGalerie(Request $request)
  2117.     {
  2118.         if ($request->isXmlHttpRequest()) {
  2119.             $entityManager = $this->getDoctrine()->getManager();
  2120.             $ActualiteBlocsDB = $entityManager->getRepository(EcoProductsBlocks::class);
  2121.             //insert neoMedia type embed
  2122.             $entityManager = $this->getDoctrine()->getManager();
  2123.             $bloc_id = $request->get('id_bloc');
  2125.             $media = new EcoProductsBlocksMedias();
  2126.             $media->setBlockId($bloc_id);
  2127.             $media->setProdMediaAlt('');
  2128.             $media->setProdMediaFile('');
  2129.             $media->setProdMediaType('embed');
  2130.             $media->setProdMediaSequence(
  2131.                 $entityManager->getRepository(EcoProductsBlocksMedias::class)->findOneByMaxMediaOrdre(
  2132.                     $bloc_id
  2133.                 )['mediaCount']
  2134.             );
  2135.             $media->setProdMediaLink('');
  2136.             $media->setProdMediaIsblank(0);
  2138.             $entityManager->persist($media);
  2139.             $entityManager->flush();
  2142.             if ($media->getBlockId() > 0) {
  2143.                 $script = '';
  2144.                 $script .= "displayMedias(" . $bloc_id . ");";
  2145.                 return new JsonResponse([
  2146.                     'status' => true,
  2147.                     'script' => $script
  2148.                 ]);
  2149.             }
  2150.         } else {
  2151.             return new JsonResponse([
  2152.                 'status' => false,
  2153.             ]);
  2154.         }
  2155.     }
  2157.     /**
  2158.      * @param Request $request
  2159.      */
  2160.     #[Route(path: '/admin/products/axDisplayModalEmbed', options: ['expose' => true])]
  2161.     public function axDisplayModalEmbed(Request $request)
  2162.     {
  2163.         if ($request->isXmlHttpRequest()) {
  2164.             $entityManager = $this->getDoctrine()->getManager();
  2165.             $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($request->get('media_id'));
  2167.             $renderModale = $this->renderView('admin/admin_products/tpl_modal_media_embed.html.twig', [
  2168.                 'modalTitle' => 'Gestion embed',
  2169.                 'media_id' => $request->get('media_id'),
  2170.                 'media' => $media,
  2171.             ]);
  2172.         }
  2174.         return new JsonResponse([
  2175.             'status' => true,
  2176.             'modal' => html_entity_decode($renderModale),
  2177.         ]);
  2178.     }
  2180.     /**
  2181.      * @param Request $request
  2182.      */
  2183.     #[Route(path: '/admin/products/axSaveMediaAlt', options: ['expose' => true])]
  2184.     public function axSaveMediaAlt(Request $request, FlashNotificationAjax $flash)
  2185.     {
  2186.         if ($request->isXmlHttpRequest()) {
  2187.             $params = array();
  2188.             parse_str($request->get('form'), $params);
  2190.             try {
  2191.                 $entityManager = $this->getDoctrine()->getManager();
  2192.                 $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($params['media_id']);
  2193.                 $media->setProdMediaAlt($params['prod_media_alt']);
  2194.                 if ($params['prod_media_type'] == 'embed') {
  2195.                     $media->setProdMediaFile($params['prod_media_file']);
  2196.                 }
  2197.                 $media->setProdMediaDisplayAlt($params['prod_media_display_alt']);
  2198.                 $media->setProdMediaLink($params['prod_media_link']);
  2199.                 $media->setProdMediaIsblank($params['prod_media_isblank']);
  2201.                 $entityManager->flush();
  2202.                 $script = '';
  2203.                 $script .= "displayMedias(" . $params['block_id'] . ");";
  2204.                 return new JsonResponse([
  2205.                     'status' => true,
  2206.                     'script' => $script,
  2207.                     'flashMessage' => $flash->notification(
  2208.                         'success',
  2209.                         'enregistré avec succès'
  2210.                     ),
  2211.                 ]);
  2212.             } catch (Exception $e) {
  2213.                 return new JsonResponse([
  2214.                     'status' => false,
  2215.                     'flashMessage' => $flash->notification(
  2216.                         'danger',
  2217.                         "Une erreur s'est produite lors de l'enregistrement"
  2218.                     ),
  2219.                 ]);
  2220.             }
  2221.         }
  2223.         return new JsonResponse([
  2224.             'status' => false,
  2225.         ]);
  2226.     }
  2228.     /**
  2229.      * @param Request $request
  2230.      */
  2231.     #[Route(path: '/admin/products/axUpdateOrderMedias', options: ['expose' => true])]
  2232.     public function axUpdateOrderMedias(Request $request)
  2233.     {
  2234.         if ($request->isXmlHttpRequest() && $request->get('sorted')) {
  2235.             $liste = explode('&', $request->get('sorted'));
  2236.             $i = 1;
  2238.             $entityManager = $this->getDoctrine()->getManager();
  2240.             foreach ($liste as $ligne) {
  2241.                 $id = str_replace('sort=', '', $ligne);
  2242.                 $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($id);
  2243.                 $media->setProdMediaSequence($i);
  2244.                 $entityManager->flush();
  2245.                 $i++;
  2246.             }
  2248.             return new JsonResponse([
  2249.                 'status' => true,
  2250.             ]);
  2251.         }
  2253.         return new JsonResponse([
  2254.             'status' => false,
  2255.         ]);
  2256.     }
  2258.     /**
  2259.      * @param Request $request
  2260.      */
  2261.     #[Route(path: '/admin/products/axDisplayModalMedia', options: ['expose' => true])]
  2262.     public function axDisplayModalMedia(Request $request)
  2263.     {
  2264.         if ($request->isXmlHttpRequest()) {
  2265.             $entityManager = $this->getDoctrine()->getManager();
  2266.             $media = $entityManager->getRepository(EcoProductsBlocksMedias::class)->find($request->get('media_id'));
  2268.             $renderModale = $this->renderView('admin/admin_products/tpl_modal_media.html.twig', [
  2269.                 'modalTitle' => 'Texte alternatif',
  2270.                 'media_id' => $request->get('media_id'),
  2271.                 'media' => $media,
  2272.             ]);
  2273.         }
  2275.         return new JsonResponse([
  2276.             'status' => true,
  2277.             'modal' => html_entity_decode($renderModale),
  2278.         ]);
  2279.     }
  2281.     /**
  2282.      * @param Request $request
  2283.      */
  2284.     #[Route(path: '/admin/products/axDisplayReorderBlocs', options: ['expose' => true])]
  2285.     public function axDisplayReorderBlocs(Request $request)
  2286.     {
  2287.         if ($request->isXmlHttpRequest() && $request->get('prod_id')) {
  2288.             $entityManager = $this->getDoctrine()->getManager();
  2289.             $blocs = $entityManager->getRepository(EcoProductsBlocks::class)->findBy(
  2290.                 ['product_id' => $request->get('prod_id')],
  2291.                 ['prod_block_sequence' => 'ASC']
  2292.             );
  2294.             $renderModale = $this->renderView('admin/admin_products/tpl_reordonner_blocs.html.twig', [
  2295.                 'modalTitle' => 'Ordonner les blocs',
  2296.                 'prod_id' => $request->get('prod_id'),
  2297.                 'blocs' => $blocs
  2298.             ]);
  2300.             $script = '';
  2301.             $script .= " initSortableBlocs(); ";
  2303.             return new JsonResponse([
  2304.                 'status' => true,
  2305.                 'modal' => html_entity_decode($renderModale),
  2306.                 'script' => $script,
  2307.             ]);
  2308.         }
  2310.         return new JsonResponse([
  2311.             'status' => false,
  2312.         ]);
  2313.     }
  2315.     /**
  2316.      * @param Request $request
  2317.      */
  2318.     #[Route(path: '/admin/products/axUpdateOrderBlocs', options: ['expose' => true])]
  2319.     public function axUpdateOrderBlocs(Request $request)
  2320.     {
  2321.         if ($request->isXmlHttpRequest() && $request->get('sorted')) {
  2322.             $liste = explode('&', $request->get('sorted'));
  2323.             $i = 1;
  2325.             $entityManager = $this->getDoctrine()->getManager();
  2327.             foreach ($liste as $ligne) {
  2328.                 $uid = str_replace('sort=', '', $ligne);
  2329.                 $bloc = $entityManager->getRepository(EcoProductsBlocks::class)->find($uid);
  2330.                 $bloc->setProdBlockSequence($i);
  2331.                 $entityManager->flush();
  2332.                 $i++;
  2333.             }
  2335.             return new JsonResponse([
  2336.                 'status' => true,
  2337.             ]);
  2338.         }
  2340.         return new JsonResponse([
  2341.             'status' => false,
  2342.         ]);
  2343.     }
  2345.     /**
  2346.      * @param Request $request
  2347.      */
  2348.     #[Route(path: '/admin/products/axCloseReorderBlocs', options: ['expose' => true])]
  2349.     public function axCloseReorderBlocs(Request $request)
  2350.     {
  2351.         if ($request->isXmlHttpRequest()) {
  2352.             $script = '';
  2353.             $script .= " window.location = window.location; ";
  2355.             return new JsonResponse([
  2356.                 'status' => true,
  2357.                 'script' => $script,
  2358.             ]);
  2359.         }
  2360.     }
  2362.     /**
  2363.      * @param Request $request
  2364.      */
  2365.     #[Route(path: '/admin/products/axUpdateOrderReferences', options: ['expose' => true])]
  2366.     public function axUpdateOrderReferences(Request $request)
  2367.     {
  2368.         if ($request->isXmlHttpRequest() && $request->get('sorted')) {
  2369.             $liste = explode('&', $request->get('sorted'));
  2370.             $i = 1;
  2372.             $entityManager = $this->getDoctrine()->getManager();
  2374.             foreach ($liste as $ligne) {
  2375.                 $uid = str_replace('sort=', '', $ligne);
  2376.                 $bloc = $entityManager->getRepository(EcoProductsReferences::class)->find($uid);
  2377.                 $bloc->setRefSequence($i);
  2378.                 $entityManager->flush();
  2379.                 $i++;
  2380.             }
  2382.             return new JsonResponse([
  2383.                 'status' => true,
  2384.             ]);
  2385.         }
  2387.         return new JsonResponse([
  2388.             'status' => false,
  2389.         ]);
  2390.     }
  2392.     /**
  2393.      * @param Request $request
  2394.      */
  2395.     #[Route(path: '/admin/products/axRemoveProduct', options: ['expose' => true])]
  2396.     public function axRemoveProduct(
  2397.         Request                             $request,
  2398.         EcoProductsRepository               $repoProduct,
  2399.         EcoCustomersFavoritesProdRepository $repoFavProd,
  2400.         EcoProductsBlocksRepository         $repoProdBlock,
  2401.         EcoProductsBlocksMediasRepository   $repoProdBlockMedias,
  2402.         EcoProductsReferencesRepository     $repoReferences,
  2403.         EcoAttributesReferencesRepository   $repoAttr
  2404.     )
  2405.     {
  2406.         if ($request->isXmlHttpRequest()) {
  2407.             //SUPPRESSION BLOCS & MEDIAS
  2408.             $blocs = $repoProdBlock->findBy(['product_id' => $request->get('product_id')]);
  2409.             if (is_array($blocs) && sizeof($blocs) > 0) {
  2410.                 foreach ($blocs as $bloc) {
  2411.                     $medias = $repoProdBlockMedias->findBy(['block_id' => $bloc->getId()]);
  2412.                     $this->removeMedias($medias);
  2413.                 }
  2414.                 $this->entityManager->remove($bloc);
  2415.             }
  2417.             //SUPPRESSION REFERENCES
  2418.             $references = $repoReferences->findBy(['product_id' => $request->get('product_id')]);
  2419.             if (is_array($references) && sizeof($references) > 0) {
  2420.                 foreach ($references as $reference) {
  2421.                     //SUPPRESSION ATTRIBUTS
  2422.                     $attributesLinks = $repoAttr->findBy(['reference_id' => $reference->getId()]);
  2423.                     if (is_array($attributesLinks) && sizeof($attributesLinks) > 0) {
  2424.                         foreach ($attributesLinks as $link) {
  2425.                             $this->entityManager->remove($link);
  2426.                         }
  2427.                     }
  2428.                     $this->entityManager->remove($reference);
  2429.                 }
  2430.             }
  2432.             //SUPPRESION DES FAVORIS CLIENTS
  2433.             $favsProds = $repoFavProd->findBy(['productId' => $request->get('product_id')]);
  2435.             foreach ($favsProds as $favProd) {
  2436.                 $this->entityManager->remove($favProd);
  2437.             }
  2439.             //SUPPRESSION PRODUIT
  2440.             $product = $repoProduct->find($request->get('product_id'));
  2441.             $this->fileService->removeFile([
  2442.                 "filePath" => $this->getParameter('upload_products_' . $this->session->get('admin_site_uid')),
  2443.                 "filename" => $product->getProdPicture(),
  2444.             ]);
  2446.             $this->entityManager->remove($product);
  2448.             $this->entityManager->flush();
  2450.             $script = " $('#row" . $request->get('product_id') . "').remove(); ";
  2452.             return new JsonResponse([
  2453.                 'status' => true,
  2454.                 'script' => $script,
  2455.             ]);
  2456.         }
  2458.         return new JsonResponse([
  2459.             'status' => false,
  2460.         ]);
  2461.     }
  2463.     /**
  2464.      * Suppression des médias d'un bloc présentation
  2465.      * @param array $medias
  2466.      */
  2467.     private function removeMedias($medias)
  2468.     {
  2469.         if (is_array($medias)) {
  2470.             foreach ($medias as $media) {
  2471.                 $this->fileService->removeFile([
  2472.                     "filePath" => $this->getParameter('upload_products_' . $this->session->get('admin_site_uid')),
  2473.                     "filename" => $media->getProdMediaFile(),
  2474.                 ]);
  2475.                 $this->entityManager->remove($media);
  2476.             }
  2477.         }
  2478.         $this->entityManager->flush();
  2479.     }
  2481.     /**
  2482.      * @param Request $request
  2483.      * TUTORIEL : https://ourcodeworld.com/articles/read/798/how-to-create-an-excel-file-with-php-in-symfony-4
  2484.      */
  2485.     #[Route(path: '/admin/export-articles', name: 'admin_excel_export_products')]
  2486.     public function excelExportProducts(Request $request, EcoProductsRepository $repoProducts)
  2487.     {
  2488.         $products = $repoProducts->findByProducts();
  2489.         $spreadsheet = new Spreadsheet();
  2491.         $sheet = $spreadsheet->getActiveSheet();
  2492.         $headCols = [
  2493.             'Date de création',
  2494.             'Modèle',
  2495.             'Désignation',
  2496.             'Référence',
  2497.             'Référence perso',
  2498.             'Code barre',
  2499.             'Prix achat',
  2500.             'Prix de vente',
  2501.             'Prix promo',
  2502.             'Prix solde',
  2503.             'TVA',
  2504.             'Quantité'
  2505.         ];
  2507.         //1er ligne - Intitulé des colonnes
  2508.         $column = 'A';
  2509.         $row = 1;
  2510.         foreach ($headCols as $col) {
  2511.             $sheet->setCellValue($column . $row, $col);
  2512.             $column++;
  2513.         }
  2515.         //Données
  2516.         $row++;
  2517.         foreach ($products as $prod) {
  2518.             $column = 'A';
  2520.             $sheet->setCellValue($column . $row, date('d/m/Y', strtotime($prod['prod_creation_date'])));
  2521.             $column++;
  2522.             $sheet->setCellValue($column . $row, $prod['prod_model']);
  2523.             $column++;
  2524.             $sheet->setCellValue($column . $row, $prod['ref_entitled']);
  2525.             $column++;
  2526.             $sheet->setCellValue($column . $row, $prod['ref_reference']);
  2527.             $column++;
  2528.             $sheet->setCellValue($column . $row, $prod['ref_reference_perso']);
  2529.             $column++;
  2530.             $sheet->setCellValue($column . $row, $prod['ref_barcode']);
  2531.             $column++;
  2532.             $sheet->setCellValue($column . $row, $prod['ref_buying_price']);
  2533.             $column++;
  2534.             $sheet->setCellValue($column . $row, $prod['ref_selling_price']);
  2535.             $column++;
  2536.             $sheet->setCellValue($column . $row, $prod['ref_promo_price']);
  2537.             $column++;
  2538.             $sheet->setCellValue($column . $row, $prod['ref_solde_price']);
  2539.             $column++;
  2540.             $sheet->setCellValue($column . $row, (($prod['ref_tva'] * 100) - 100) . '%');
  2541.             $column++;
  2542.             $sheet->setCellValue($column . $row, $prod['ref_quantity'] > 0 ? $prod['ref_quantity'] : 0);
  2543.             $column++;
  2545.             $row++;
  2546.         }
  2549.         $sheet->setTitle("Export produits du " . date('d-m-Y'));
  2551.         $writer = new Xlsx($spreadsheet);
  2553.         $fileName = 'export-produits-' . date('dmY') . '.xlsx';
  2554.         $temp_file = tempnam(sys_get_temp_dir(), $fileName);
  2556.         // Create the file
  2557.         $writer->save($temp_file);
  2559.         return $this->file($temp_file, $fileName, ResponseHeaderBag::DISPOSITION_INLINE);
  2560.     }
  2563.     #[Route(path: '/admin/product-statistics/{prod_id}', name: 'admin_product_statistics', defaults: ['prod_id' => 0])]
  2564.     public function product_statistics(
  2565.         Request                         $request,
  2566.         EcoOrdersRepository             $repoOrders,
  2567.         EcoProductsReferencesRepository $repoProdRef,
  2568.         EcoProductsRepository           $repoProduct,
  2569.                                         $prod_id = 0
  2570.     )
  2571.     {
  2572.         $year = $request->get('year') ? $request->get('year') : date('Y');
  2575.         //Année de début
  2576.         $firstYear = $repoOrders->findByFirstYearProduct($prod_id);
  2577.         $firstYear = $firstYear > 0 ? $firstYear : date('Y');
  2578.         //Liste des années disponibles en fonction des commandes du site
  2579.         $yearOrderList = $this->getYearOrderList($firstYear);
  2581.         //Données de ventes
  2582.         $datas = [];
  2583.         $references = $repoProdRef->findBy(['product_id' => $prod_id]);
  2584.         foreach ($references as $key => $ref) {
  2585.             $stats = $repoOrders->findByReferenceOrderByMonth($year, $ref->getId());
  2586.             foreach ($this->monthList as $keyMonth => $month) {
  2587.                 $datas[$ref->getId()][$keyMonth] = 0;
  2588.                 foreach ($stats as $stat) {
  2589.                     if ($keyMonth == $stat['month']) {
  2590.                         $datas[$ref->getId()][$keyMonth] = $stat['nbSales'];
  2591.                     }
  2592.                 }
  2593.             }
  2595.             $references[$key]->rgb = $this->getRandomColors();
  2596.         }
  2598.         //        dd($references[0]->rgb);
  2600.         return $this->render('admin/admin_products/product_statistics.html.twig', [
  2601.             'product_id' => $prod_id,
  2602.             'product' => $repoProduct->find($prod_id),
  2603.             'yearOrderList' => $yearOrderList,
  2604.             'monthsList' => $this->monthList,
  2605.             'selectedYear' => $year,
  2606.             'references' => $references,
  2607.             'datasSales' => $datas,
  2608.         ]);
  2609.     }
  2611.     private function getRandomColors()
  2612.     {
  2613.         foreach (array('r', 'g', 'b') as $color) {
  2614.             $rgbColor[$color] = mt_rand(0, 255);
  2615.         }
  2617.         return $rgbColor;
  2618.     }
  2620.     private function getYearOrderList($firstYear)
  2621.     {
  2622.         $result = [];
  2623.         if (date('Y') - $firstYear > 0) {
  2624.             $diff = date('Y') - $firstYear;
  2625.             for ($i = 0; $i <= $diff; $i++) {
  2626.                 $result[] = $firstYear + $i;
  2627.             }
  2628.         } else {
  2629.             $result[] = $firstYear;
  2630.         }
  2632.         return $result;
  2633.     }
  2635.     #[Route(path: '/admin/products/marks', name: 'admin_products_marks')]
  2636.     public function marks(Request $request, EcoMarksRepository $repoMarks)
  2637.     {
  2638.         if ($request->get('mark')) {
  2639.             $mark = new EcoMarks;
  2640.             if ($request->get('mark_id') && $request->get('mark_id') > 0) {
  2641.                 $mark = $repoMarks->find($request->get('mark_id'));
  2642.             }
  2644.             $mark->setMark($request->get('mark'));
  2645.             $mark->setSiteId($this->session->get('admin_site_uid'));
  2646.             $this->entityManager->persist($mark);
  2647.             $this->entityManager->flush();
  2648.         }
  2650.         return $this->render('admin/admin_products/products_marks.html.twig', [
  2651.             'marks' => $repoMarks->findBy(['siteId' => $this->session->get('admin_site_uid')], ['mark' => 'ASC']),
  2652.         ]);
  2653.     }
  2655.     /**
  2656.      * @param Request $request
  2657.      */
  2658.     #[Route(path: '/admin/products/axDisplayFormMark', options: ['expose' => true])]
  2659.     public function axDisplayFormMark(Request $request, EcoMarksRepository $repoMark)
  2660.     {
  2661.         if ($request->isXmlHttpRequest()) {
  2662.             $mark = new EcoMarks;
  2663.             if ($request->get('mark_id') > 0) {
  2664.                 $mark = $repoMark->find($request->get('mark_id'));
  2665.             }
  2667.             $renderModale = $this->renderView('admin/admin_products/tpl_form_mark.html.twig', [
  2668.                 'modalTitle' => 'Marque',
  2669.                 'mark_id' => $request->get('mark_id'),
  2670.                 'mark' => $mark,
  2671.             ]);
  2673.             return new JsonResponse([
  2674.                 'status' => true,
  2675.                 'modal' => html_entity_decode($renderModale),
  2676.             ]);
  2677.         }
  2679.         return new JsonResponse([
  2680.             'status' => false,
  2681.         ]);
  2682.     }
  2684.     #[Route(path: '/admin/products/mark/remove/{id}', name: 'admin_products_mark_remove', defaults: ['id' => 0])]
  2685.     public function remove_mark(
  2686.         Request               $request,
  2687.         EcoMarksRepository    $repoMarks,
  2688.         EcoProductsRepository $ecoProductsRepository,
  2689.                               $id
  2690.     )
  2691.     {
  2692.         $mark = new EcoMarks;
  2694.         if ($id > 0) {
  2695.             $mark = $repoMarks->find($id);
  2697.             $productInMark = $ecoProductsRepository->findBy(['mark_id' => $mark->getId()]);
  2699.             if ($productInMark != null) {
  2700.                 $this->addFlash('danger', "Impossible de supprimer une marque possédant des produits");
  2701.                 return $this->redirectToRoute('admin_products_marks');
  2702.             }
  2704.             try {
  2705.                 $this->entityManager->remove($mark);
  2706.                 $this->entityManager->flush();
  2707.                 $this->addFlash('success', "Suppression avec succès");
  2708.             } catch (Exception $e) {
  2709.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  2710.             }
  2711.         }
  2713.         return $this->redirectToRoute('admin_products_marks');
  2714.     }
  2716.     #[Route(path: '/admin/products/providers', name: 'admin_products_providers')]
  2717.     public function providers(Request $request, EcoProvidersRepository $repoProviders)
  2718.     {
  2719.         if ($request->get('provider')) {
  2720.             $provider = new EcoProviders;
  2721.             if ($request->get('provider_id') && $request->get('provider_id') > 0) {
  2722.                 $provider = $repoProviders->find($request->get('provider_id'));
  2723.             }
  2725.             $provider->setProvider($request->get('provider'));
  2726.             $provider->setDescription($request->get('description'));
  2727.             $provider->setCity($request->get('city'));
  2728.             $provider->setPostalCode($request->get('postalCode'));
  2729.             $provider->setSiteId($this->session->get('admin_site_uid'));
  2731.             $this->entityManager->persist($provider);
  2732.             $this->entityManager->flush();
  2733.         }
  2735.         return $this->render('admin/admin_products/products_providers.html.twig', [
  2736.             'providers' => $repoProviders->findBy(['siteId' => $this->session->get('admin_site_uid')],
  2737.                 ['provider' => 'ASC']),
  2738.         ]);
  2739.     }
  2741.     /**
  2742.      * @param Request $request
  2743.      */
  2744.     #[Route(path: '/admin/products/axDisplayFormProvider', options: ['expose' => true])]
  2745.     public function axDisplayFormProvider(Request $request, EcoProvidersRepository $repoProvider)
  2746.     {
  2747.         if ($request->isXmlHttpRequest()) {
  2748.             $provider = new EcoProviders;
  2749.             if ($request->get('provider_id') > 0) {
  2750.                 $provider = $repoProvider->find($request->get('provider_id'));
  2751.             }
  2753.             $renderModale = $this->renderView('admin/admin_products/tpl_form_provider.html.twig', [
  2754.                 'modalTitle' => 'Fournisseur',
  2755.                 'mark_id' => $request->get('provider_id'),
  2756.                 'provider' => $provider,
  2757.             ]);
  2759.             return new JsonResponse([
  2760.                 'status' => true,
  2761.                 'modal' => html_entity_decode($renderModale),
  2762.             ]);
  2763.         }
  2765.         return new JsonResponse([
  2766.             'status' => false,
  2767.         ]);
  2768.     }
  2770.     #[Route(path: '/admin/products/provider/remove/{id}', name: 'admin_products_provider_remove', defaults: ['id' => 0])]
  2771.     public function remove_provider(
  2772.         Request                $request,
  2773.         EcoProvidersRepository $repoProviders,
  2774.         EcoProductsRepository  $ecoProductsRepository,
  2775.                                $id
  2776.     )
  2777.     {
  2778.         $provider = new EcoProviders;
  2780.         if ($id > 0) {
  2781.             $provider = $repoProviders->find($id);
  2783.             $productInProvider = $ecoProductsRepository->findBy(['provider_id' => $provider->getId()]);
  2785.             if ($productInProvider != null) {
  2786.                 $this->addFlash('danger', "Impossible de supprimer un fournisseur associé à des produits");
  2787.                 return $this->redirectToRoute('admin_products_providers');
  2788.             }
  2790.             try {
  2791.                 $this->entityManager->remove($provider);
  2792.                 $this->entityManager->flush();
  2793.                 $this->addFlash('success', "Suppression avec succès");
  2794.             } catch (Exception $e) {
  2795.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  2796.             }
  2797.         }
  2799.         return $this->redirectToRoute('admin_products_providers');
  2800.     }
  2803.     #[Route(path: '/admin/products/labels', name: 'admin_products_labels')]
  2804.     public function labels(Request $request, EcoLabelsRepository $labelsRepository)
  2805.     {
  2806.         if ($request->get('name')) {
  2807.             $label = new EcoLabels;
  2809.             $picture = null;
  2811.             if ($request->get('label_id') && $request->get('label_id') > 0) {
  2812.                 $label = $labelsRepository->find($request->get('label_id'));
  2813.                 $picture = $label->getLogo();
  2814.             }
  2816.             $label->setName($request->get('name'));
  2817.             //$label->setLogo($request->get('logo'));
  2819.             dump($request);
  2821.             // upload du fichier
  2822.             if ($request->files->get("logo") !== null) {
  2823.                 $upload = $this->fileService->startUpload(
  2824.                     [
  2825.                         "fileData" => $request->files->get("logo"),
  2826.                         "oldFileName" => $picture,
  2827.                         "fileDestination" => $this->getParameter(
  2828.                             "upload_labels_" . $this->session->get('admin_site_uid')
  2829.                         ),
  2830.                         "autorizedExtensions" => $this->autorizedImages,
  2831.                         "createWebp" => true
  2832.                     ]
  2833.                 );
  2835.                 // upload OK
  2836.                 if (isset($upload['state']) && $upload['state'] && isset($upload['filename']) && is_string(
  2837.                         $upload['filename']
  2838.                     )) {
  2839.                     $label->setLogo($upload['filename']);
  2840.                 } // upload KO avec message perso
  2841.                 elseif (isset($upload['error_msg'])) {
  2842.                     $label->setLogo($picture);
  2843.                     $errorMsg = $upload['error_msg'];
  2844.                 } // upload KO avec message générique
  2845.                 else {
  2846.                     $label->setLogo($picture);
  2847.                     $errorMsg = "Une erreur s'est produite lors de l'enregistrement du fichier";
  2848.                 }
  2849.             }
  2851.             try {
  2852.                 $this->entityManager->persist($label);
  2853.                 $this->entityManager->flush();
  2854.             } catch (Exception $e) {
  2855.                 $errorMsg = "Une erreur s'est produite lors de l'enregistrement";
  2856.             }
  2858.             // il y a eu une erreur
  2859.             if (isset($errorMsg)) {
  2860.                 $this->addFlash('danger', $errorMsg);
  2861.             } // pas d'erreur
  2862.             else {
  2863.                 $this->addFlash('success', "enregistré avec succès");
  2864.             }
  2865.         }
  2867.         return $this->render('admin/admin_products/products_labels.html.twig', [
  2868.             'labels' => $labelsRepository->findBy([], ['name' => 'ASC']),
  2869.         ]);
  2870.     }
  2872.     /**
  2873.      * @param Request $request
  2874.      */
  2875.     #[Route(path: '/admin/products/axDisplayFormLabel', options: ['expose' => true])]
  2876.     public function axDisplayFormlabel(Request $request, EcoLabelsRepository $labelsRepository)
  2877.     {
  2878.         if ($request->isXmlHttpRequest()) {
  2879.             $label = new EcoLabels;
  2881.             if ($request->get('label_id') > 0) {
  2882.                 $label = $labelsRepository->find($request->get('label_id'));
  2883.             }
  2885.             $renderModale = $this->renderView('admin/admin_products/tpl_form_label.html.twig', [
  2886.                 'modalTitle' => 'Label',
  2887.                 'label_id' => $request->get('label_id'),
  2888.                 'label' => $label,
  2889.                 'autorizedImages' => $this->autorizedImages,
  2890.             ]);
  2892.             return new JsonResponse([
  2893.                 'status' => true,
  2894.                 'modal' => html_entity_decode($renderModale),
  2895.             ]);
  2896.         }
  2898.         return new JsonResponse([
  2899.             'status' => false,
  2900.         ]);
  2901.     }
  2903.     #[Route(path: '/admin/products/label/remove/{id}', name: 'admin_products_label_remove', defaults: ['id' => 0])]
  2904.     public function remove_label(
  2905.         Request                     $request,
  2906.         EcoLabelsRepository         $labelsRepository,
  2907.         EcoProductsLabelsRepository $ecoProductsLabelsRepository,
  2908.                                     $id
  2909.     )
  2910.     {
  2911.         $label = new EcoProductsLabels();
  2913.         if ($id > 0) {
  2914.             $label = $labelsRepository->find($id);
  2916.             $productInLabel = $ecoProductsLabelsRepository->findBy(['label_id' => $label->getId()]);
  2918.             if ($productInLabel != null) {
  2919.                 $this->addFlash('danger', "Impossible de supprimer un label associé à des produits");
  2920.                 return $this->redirectToRoute('admin_products_labels');
  2921.             }
  2923.             try {
  2924.                 $this->entityManager->remove($label);
  2925.                 $this->entityManager->flush();
  2926.                 $this->addFlash('success', "Suppression avec succès");
  2927.             } catch (Exception $e) {
  2928.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression");
  2929.             }
  2930.         }
  2932.         return $this->redirectToRoute('admin_products_labels');
  2933.     }
  2935.     #[Route(path: '/admin/products/remove-picture-label/{id}', name: 'admin_product_remove_picture_label', defaults: ['id' => ''])]
  2936.     public function removePictureLabel($id)
  2937.     {
  2938.         if ($id > 0) {
  2939.             try {
  2940.                 $media = $this->entityManager->getRepository(EcoLabels::class)->find($id);
  2941.                 $filename = $media->getLogo();
  2942.                 $media->setLogo(null);
  2944.                 $this->entityManager->persist($media);
  2945.                 $this->entityManager->flush();
  2947.                 if ($filename != null && $filename != "" && is_string($filename) && $this->filesystem->exists(
  2948.                         $file = $this->getParameter(
  2949.                                 'upload_labels_' . $this->session->get('admin_site_uid')
  2950.                             ) . "/" . $filename
  2951.                     )) {
  2952.                     $this->fileService->removeFile([
  2953.                         "filePath" => $this->getParameter('upload_labels_' . $this->session->get('admin_site_uid')),
  2954.                         "filename" => $filename,
  2955.                     ]);
  2956.                 }
  2958.                 $this->addFlash('success', "L'illustration a été supprimée avec succès");
  2959.             } catch (Exception $e) {
  2960.                 $this->addFlash('danger', "Une erreur s'est produite lors de la suppression de l'illustration");
  2961.             }
  2962.         }
  2964.         return $this->redirectToRoute('admin_products_labels');
  2965.     }
  2967.     #[Route(path: '/admin/product-combination/{prod_id}', name: 'admin_product_combination', defaults: ['prod_id' => 0])]
  2968.     public function product_combination(Request $request, EcoProductsRepository $repoProduct, $prod_id = 0)
  2969.     {
  2970.         return $this->render('admin/admin_products/product_combination.html.twig', [
  2971.             'product_id' => $prod_id,
  2972.             'product' => $repoProduct->find($prod_id),
  2973.             'combinations' => $repoProduct->findByProductsCombination($prod_id),
  2974.         ]);
  2975.     }
  2977.     #[Route(path: '/admin/product-combination-remove/{prod_id}/{com_prod_id}', name: 'admin_combination_remove', defaults: [
  2978.         'prod_id' => 0,
  2979.         'com_prod_id' => ''
  2980.     ])]
  2981.     public function product_combination_remove(
  2982.         EcoProductsCombinationRepository $repoProductCombination,
  2983.                                          $com_prod_id,
  2984.                                          $prod_id = 0
  2985.     )
  2986.     {
  2987.         $combination = $repoProductCombination->findBy(['product_id' => $prod_id, 'com_product_id' => $com_prod_id]);
  2988.         foreach ($combination as $comb) {
  2989.             $this->entityManager->remove($comb);
  2990.         }
  2991.         $this->entityManager->flush();
  2993.         $this->addFlash('success', "Suppression avec succès");
  2995.         return $this->redirectToRoute('admin_product_combination', ['prod_id' => $prod_id]);
  2996.     }
  2998.     #[Route(path: '/admin/products/product-search', options: ['expose' => true])]
  2999.     public function searchProduct(Request $request, EcoProductsRepository $repoCustomers)
  3000.     {
  3001.         $customers = $repoCustomers->findBySearchProductsByFilter($request->get('search'));
  3002.         $datas = [];
  3003.         foreach ($customers as $key => $result) {
  3004.             $data = [
  3005.                 'label' => $result['prod_model'],
  3006.                 'value' => $result['prod_model'],
  3007.                 'id' => $result['prod_id'],
  3008.             ];
  3009.             $datas[] = $data;
  3010.         }
  3012.         return new JsonResponse([
  3013.             'datas' => json_encode($datas),
  3014.         ]);
  3015.     }
  3017.     #[Route(path: '/admin/insert-combination/{prod_id}', name: 'admin_insert_combination', defaults: ['prod_id' => 0])]
  3018.     public function insert_combination(
  3019.         Request                          $request,
  3020.         EcoProductsCombinationRepository $repoProductCombination,
  3021.                                          $prod_id = 0
  3022.     )
  3023.     {
  3024.         $result = $repoProductCombination->findBy([
  3025.             'product_id' => $prod_id,
  3026.             'com_product_id' => $request->get('product_id')
  3027.         ]);
  3028.         //Si pas de résultat on peut insérer la combinaison
  3029.         if ($result == null) {
  3030.             $combination = new EcoProductsCombination();
  3031.             $combination->setProductId($prod_id);
  3032.             $combination->setComProductId($request->get('product_id'));
  3033.             $this->entityManager->persist($combination);
  3034.             $this->entityManager->flush();
  3036.             $this->addFlash('success', "Ajout avec succès");
  3037.         } else {
  3038.             $this->addFlash('danger', "Cet article est déjà attribué.");
  3039.         }
  3041.         return $this->redirectToRoute('admin_product_combination', ['prod_id' => $prod_id]);
  3042.     }
  3045.     #[Route(path: '/admin/products/bundle/{prod_id}', name: 'admin_product_bundle', defaults: ['prod_id' => ''])]
  3046.     public function bundle(Request $request, EcoProductsRepository $repoProduct, $prod_id)
  3047.     {
  3048.         return $this->render('admin/admin_products/products_bundle.html.twig', [
  3049.             'product' => $repoProduct->find($prod_id),
  3050.             'product_id' => $prod_id,
  3051.             'bundles' => $repoProduct->findByProductsBundle($prod_id),
  3052.         ]);
  3053.     }
  3055.     #[Route(path: '/admin/products/reference-search', options: ['expose' => true])]
  3056.     public function searchReferenceProduct(Request $request, EcoProductsRepository $repoCustomers)
  3057.     {
  3058.         $customers = $repoCustomers->findBySearchReferencesByFilter($request->get('search'));
  3059.         $datas = [];
  3060.         foreach ($customers as $key => $result) {
  3061.             $data = [
  3062.                 'label' => $result['prod_model'] . ' - ' . $result['ref_entitled'] . ' (' . $result['ref_reference'] . ')',
  3063.                 'value' => $result['prod_model'] . ' ' . $result['ref_entitled'],
  3064.                 'id' => $result['ref_id'],
  3065.             ];
  3066.             $datas[] = $data;
  3067.         }
  3069.         return new JsonResponse([
  3070.             'datas' => json_encode($datas),
  3071.         ]);
  3072.     }
  3074.     #[Route(path: '/admin/insert-reference-bundle/{prod_id}', name: 'admin_insert_reference_bundle', defaults: ['prod_id' => 0])]
  3075.     public function insert_reference_bundle(
  3076.         Request                     $request,
  3077.         EcoProductsBundleRepository $repoProductBundle,
  3078.                                     $prod_id = 0
  3079.     )
  3080.     {
  3081.         $result = $repoProductBundle->findBy([
  3082.             'product_id' => $prod_id,
  3083.             'reference_id' => $request->get('reference_id')
  3084.         ]);
  3085.         //Si pas de résultat on peut insérer la combinaison
  3086.         if ($result == null) {
  3087.             $bundle = new EcoProductsBundle();
  3088.             $bundle->setProductId($prod_id);
  3089.             $bundle->setReferenceId($request->get('reference_id'));
  3090.             $bundle->setBundleQte(1);
  3091.             $this->entityManager->persist($bundle);
  3092.             $this->entityManager->flush();
  3094.             $this->addFlash('success', "Ajout avec succès");
  3095.         } else {
  3096.             $this->addFlash('danger', "Cet article est déjà attribué.");
  3097.         }
  3099.         return $this->redirectToRoute('admin_product_bundle', ['prod_id' => $prod_id]);
  3100.     }
  3102.     #[Route(path: '/admin/product-bundle-remove/{prod_id}/{reference_id}', name: 'admin_bundle_remove', defaults: [
  3103.         'prod_id' => 0,
  3104.         'reference_id' => ''
  3105.     ])]
  3106.     public function product_bundle_remove(EcoProductsBundleRepository $repoProductBundle, $reference_id, $prod_id = 0)
  3107.     {
  3108.         $bundles = $repoProductBundle->findBy(['product_id' => $prod_id, 'reference_id' => $reference_id]);
  3109.         foreach ($bundles as $bundle) {
  3110.             $this->entityManager->remove($bundle);
  3111.         }
  3112.         $this->entityManager->flush();
  3113.         $this->addFlash('success', "Suppression avec succès");
  3115.         return $this->redirectToRoute('admin_product_bundle', ['prod_id' => $prod_id]);
  3116.     }
  3118.     #[Route(path: '/admin/products/axUpdateProductQtePack')]
  3119.     public function axUpdateProductQtePack(
  3120.         Request                     $request,
  3121.         EcoProductsBundleRepository $repoBundle,
  3122.         FlashNotificationAjax       $flash
  3123.     )
  3124.     {
  3125.         if ($request->get('product_id') && $request->get('reference_id') && $request->get('qte') && $request->get(
  3126.                 'qte'
  3127.             ) > 0) {
  3128.             $prodPack = $repoBundle->findOneBy([
  3129.                 'product_id' => $request->get('product_id'),
  3130.                 'reference_id' => $request->get('reference_id')
  3131.             ]);
  3132.             if ($prodPack != null) {
  3133.                 $prodPack->setBundleQte($request->get('qte'));
  3134.                 $this->entityManager->persist($prodPack);
  3135.                 $this->entityManager->flush();
  3137.                 return new JsonResponse([
  3138.                     'status' => true,
  3139.                     'flashMessage' => $flash->notification(
  3140.                         'success',
  3141.                         'enregistré avec succès'
  3142.                     ),
  3143.                 ]);
  3144.             }
  3145.         }
  3147.         return new JsonResponse([
  3148.             'status' => false,
  3149.             'flashMessage' => $flash->notification(
  3150.                 'danger',
  3151.                 "Une erreur s'est produite lors de l'enregistrement"
  3152.             ),
  3153.         ]);
  3154.     }
  3157. }