src/Controller/ProductController.php line 340

Open in your IDE?
  1. <?php 
  3. namespace App\Controller;
  5. use App\Entity\AttributeItems;
  6. use App\Entity\Attributes;
  7. use App\Entity\Products;
  8. use App\Entity\Category;
  9. use App\Entity\MeasurmentUnit;
  10. use App\Entity\SiteProductsMedia;
  11. use App\Entity\MediaObject;
  12. use Doctrine\ORM\EntityManagerInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use Symfony\Component\HttpFoundation\Response;
  15. use Symfony\Component\Routing\Annotation\Route;
  16. use Symfony\Component\HttpKernel\Attribute\AsController;
  17. use Symfony\Component\HttpFoundation\JsonResponse;
  18. use App\Repository\ProductsRepository;
  19. use App\Repository\SiteProductsRepository;
  20. use App\Repository\ProductBalanceInStorageRepository;
  21. use App\Repository\MediaObjectsRepository;
  22. use Symfony\Component\HttpFoundation\StreamedResponse;
  23. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  24. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  25. use PhpOffice\PhpSpreadsheet\IOFactory;
  26. use App\Service\Translit;
  27. use Intervention\Image\ImageManager;
  28. use Symfony\Component\HttpKernel\KernelInterface; 
  29. use App\Service\ImageResize;
  35. #[AsController]
  36. class ProductController
  37. {
  38.     private $ProductsRepository;
  40.     private $entityManager;
  42.     private $kernel;
  46.     public function __construct(EntityManagerInterface $entityManager, ProductsRepository $ProductsRepository, KernelInterface $kernel  )
  47.     {
  48.         $this->entityManager = $entityManager;
  50.         $this->ProductsRepository = $ProductsRepository;
  52.         $this->kernel = $kernel;
  53.     }
  56.     #[Route(
  57.         name: 'product_filter', 
  58.         path: '/api/products/filter',
  59.         methods: ['GET'],
  60.     )]
  61.     public function __invoke(Request $request): Response
  62.     {
  63.         $_get = $request->query->all();
  64.         $query =$_get['search']; // Отримуємо параметр "query" з URL.
  65.         $t = $_get['type']; // Отримуємо параметр "query" з URL.
  66.         if($t == '1'){
  67.             $data = explode(' ', $query );
  68.             $products = $this->ProductsRepository->searchByNameSpecefycal($data, $query);
  69.         }else{
  70.             $products = $this->ProductsRepository->searchByNameOrBarcode($query);
  71.         }
  73.         if (empty($products)) {
  74.             return new JsonResponse([]);
  75.         }
  77.         return new JsonResponse($products, 200);
  78.     }
  81.     #[Route(
  82.         name: 'set_show_products', 
  83.         path: '/set-show-products',
  84.     )]
  85.     public function set_show_products(ProductBalanceInStorageRepository $ProductBalanceInStorageRepository, Request $request): Response
  86.     {
  87.         die;
  88.         $productsBlance = $ProductBalanceInStorageRepository->findAll();
  90.         if($productsBlance){
  91.             echo count($productsBlance) . "<br>";
  92.         }
  93.         $sumBalance = [];
  94.         foreach($productsBlance as $pb){
  95.             $id = $pb->getProduct()->getId();
  96.             if(!isset($sumBalance[$id]))
  97.                 $sumBalance[$id] = ['sum' => 0, 'product' => $pb->getProduct()];
  99.                 $sumBalance[$id]['sum'] += $pb->getCount();
  101.         }
  103.         $c = 0;
  104.         foreach($sumBalance as $sb){
  105.             
  106.             if($sb['sum'] >= 300){
  107.                $c++; 
  108.                $sb['product']->setShow(true);
  109.             }else{
  110.                 $sb['product']->setShow(false);
  111.             }
  112.             $this->entityManager->persist( $sb['product'] );
  113.         }
  116.         $this->entityManager->flush();
  119.         echo count($sumBalance) . "<br>";
  120.         echo $c;
  121.         
  122.         die;
  124.     }
  126.     #[Route(
  127.         name: 'set_site_product_img', 
  128.         path: '/set-site-product-img',
  129.     )]
  130.     public function set_site_product_img(SiteProductsRepository $SiteProductsRepository, Request $request): Response
  131.     {
  132.         $productsSite = $SiteProductsRepository->findAll();
  134.         foreach ( $productsSite as $ps){
  135.             $isMedia = false;
  136.             // echo '<pre>';
  137.             // echo count($ps->getSiteProductsMedia());
  138.             //print_r($ps->getSiteProductsMedia()); 
  139.             // die;
  140.             if(count($ps->getSiteProductsMedia()) == 0){
  141.                 if($ps->getProducts() != null){
  142.                     foreach($ps->getProducts() as $p){
  143.                         if( !$isMedia AND $p->getMedia() != null AND count($p->getMedia()) > 0){
  144.                             
  145.                             foreach($p->getMedia() as $m){
  146.                                 $spm = new SiteProductsMedia();
  147.                                 $spm->setSiteProduct($ps);
  148.                                 $spm->setMedia($m);
  149.                                 $spm->setMain($m->isMain());
  150.                                 $this->entityManager->persist($spm);
  151.                                 // $this->entityManager->flush();
  152.                                 if($p->getMainMedia() != null){
  153.                                     if($p->getMainMedia()->getId() == $m->getId()){
  154.                                         $ps->setMainSiteProductMedia($spm);
  155.                                         $this->entityManager->persist($spm);
  156.                                     }
  157.                                 }
  158.                                 $isMedia = true;
  159.                                 // $this->entityManager->flush();
  160.                             }
  161.                         }
  162.                     }
  163.                         
  164.                 }
  165.                 // var_dump($ps->getMainSiteProductMedia());
  166.             }
  167.         }
  168.         $this->entityManager->flush();
  169.         die;
  170.     }
  171.     #[Route(
  172.         name: 'get_product', 
  173.         path: '/get-product',
  174.     )]
  175.     public function get_product(SiteProductsRepository $SiteProductsRepository, Request $request): Response
  176.     {
  177.         die;
  178.         $find = $this->entityManager->getRepository(Products::class)->findAll();
  179.         foreach($find as $p){
  180.             if(empty($p->getPriceIncome()))
  181.                 continue;
  182.             $arr = [
  183.                 'gurt_1' => round($p->getPriceIncome() + ($p->getPriceIncome() * 0.05), 2),
  184.                 'gurt_2' => round($p->getPriceIncome() + ($p->getPriceIncome() * 0.07), 2),
  185.                 'gurt_3' => round($p->getPriceIncome() + ($p->getPriceIncome() * 0.09), 2),
  186.                 'gurt_4' => round($p->getPriceIncome() + ($p->getPriceIncome() * 0.1), 2),
  187.             ];
  189.             echo $p->getPriceIncome(). '---'.json_encode($arr).'<br>';
  191.             $p->setPriceCategory($arr);
  192.             $this->entityManager->persist($p);
  194.         }
  195.         $this->entityManager->flush();
  197.         // echo count( $find);
  198.         die;
  199.     }
  202.     #[Route(
  203.         name: 'export_form', 
  204.         path: '/api/export_csv',
  205.         methods: ['GET']
  206.     )]
  207.     public function export_csv( EntityManagerInterface $entityManager, Request $request): StreamedResponse
  208.     {
  209.             $products = $entityManager->getRepository(Products::class)->findAll();
  210.             $attributes = $entityManager->getRepository(Attributes::class)->findAll();
  211.             // echo count($products); die;
  212.             if( $products ){
  213.                 $header = [
  214.                     'name',
  215.                     'site_name',
  216.                     'article',
  217.                     'code',
  218.                     'all_category',
  219.                     'last_category',
  220.                     // 'attributes',
  221.                 ];
  222.                 $arrAttr = [];
  223.                 foreach($attributes as $attr){
  224.                     $arrAttr[$attr->getId()] = '';
  225.                     $header[] = $attr->getName();
  226.                 }
  227.                
  228.                 $response = new StreamedResponse(function () use ($arrAttr, $header, $products) {
  229.                     $csv = fopen('php://output', 'w+');
  230.                     fprintf($csv, "\xEF\xBB\xBF");
  231.                     fputcsv($csv, $header, ';');
  232.                     foreach($products as $prod){
  233.                         if(count($prod->getCategory()) > 0 OR count($prod->getAttributeItems()) > 0){
  234.                             $prodAttr = $arrAttr;
  235.                             $arr = [];
  236.                             $arr[] = $prod->getName();
  237.                             $siteName = '';
  238.                             if($prod->getSiteProduct())
  239.                                 $siteName = $prod->getSiteProduct()->getName();
  240.                             $arr[] = $siteName;
  241.                             $arr[] = $prod->getArticle();
  242.                             $arr[] = $prod->getCode1c();
  243.                             
  244.                             $category = '';
  245.                             foreach($prod->getCategory() as $cat){
  246.                                 // file_put_contents('Category.log', strpos($category, $cat->getName()) . "\n", FILE_APPEND);
  248.                                 // if($cat->isMain()){
  249.                                 
  250.                                 // }
  251.                                 if($cat->getParent()){
  252.                                     
  253.                                     if($cat->getParent()->getParent()){
  254.                                         $p = $cat->getParent()->getParent();
  255.                                         // if($p->isMain()){
  256.                                             if(!str_contains($category, $p->getName()."|"))
  257.                                                 $category .= $p->getName()."|";
  258.                                         // }
  259.                                     }
  260.                                     // if($cat->getParent()->isMain()){
  261.                                         if(!str_contains($category, $cat->getParent()->getName()."|"))
  262.                                             $category .= $cat->getParent()->getName()."|";
  263.                                     // }
  264.                                 }
  266.                                 if(!str_contains($category, $cat->getName()."|"))
  267.                                         $category .= $cat->getName()."|";
  268.                             }
  269.                             $arr[] = $category;
  270.                             $lastCategory = '';
  271.                             foreach($prod->getCategory() as $cat){
  272.                                 // if(count($prod->getCategory()) > 0)
  273.                                 $lastCategory .= $cat->getName(). " | ";
  274.                             }
  275.                             $arr[] = $lastCategory;
  277.                             if(count($prod->getAttributeItems()) > 0){
  278.                                 foreach($prod->getAttributeItems() as $attrItem){
  279.                                     if($attrItem->getAttribute() !=null)
  280.                                         $prodAttr[$attrItem->getAttribute()->getId()] = $attrItem->getName();
  281.                                 }
  282.                                 foreach($prodAttr as $v){
  283.                                 
  284.                                     $arr[] = $v;
  285.                                 }
  286.                             }
  287.                             
  288.                             fputcsv($csv, $arr, ';');
  289.                         }
  290.                     }
  292.  
  293.                     fclose($csv);
  294.                 });
  295.                 
  296.                 $response->headers->set('Content-Type', 'application/csv');
  297.                 $response->headers->set('Content-Encoding', 'UTF-8');
  298.                 $response->headers->set('Content-Disposition', 'attachment; filename="file.csv"');
  299.                 $response->headers->set('Cache-Control', 'no-store');
  300.             }
  301.         
  302.         return $response;
  304.     }
  306.     #[Route(
  307.         name: 'setMainImage', 
  308.         path: '/set-main-mage',
  309.     )]
  310.     public function setMainImage(Request $request): Response
  311.     {
  312.         // die;
  314.         $find = $this->entityManager->getRepository(Products::class)->findAll();
  315.         $i = 0;
  316.         foreach($find as $product){
  317.             if(count($product->getMedia()) > 0 && $product->getMainMedia() == null){
  318.                 $i++;
  319.                 // $product->setMainMedia($product->getMedia()[0]);
  320.                 // $this->entityManager->persist($product);
  321.             }
  322.             if($product->getSiteProduct() != null){
  323.                 // $product->setName($product->getSiteProduct()->getName());
  324.                 // $this->entityManager->persist($product);
  325.             }
  326.         }
  328.         $this->entityManager->flush();
  331.         echo $i;
  332.         // echo count( $find);
  333.         die;
  334.     }
  336.     #[Route(
  337.         name: 'getPrices', 
  338.         path: '/get-prices',
  339.     )]
  340.     public function getPrices( EntityManagerInterface $entityManager, Request $request): Response
  341.     {
  342.         // die;
  343.         $category = [];
  344.         // echo '<pre>';
  345.         // print_r($request->query->all());
  346.         // die;
  348.         $category = $request->query->get('category');
  349.         $products = $entityManager->getRepository(Products::class)->findBy(['show' => true]);
  350.         // if(!empty( $category_id)){
  351.         //     $query = $entityManager->getRepository(Category::class)->find($category_id);
  352.         //     $categories[] = $query;
  354.         // }else{
  355.         $categories = $entityManager->getRepository(Category::class)->findBy([], ['sort' => 'ASC']);
  356.         // }
  357.         $catArr = [];
  358.         foreach($categories as $cat){
  359.             if( !empty($category) ){
  360.                 if(in_array( $cat->getId(), $category) ){
  361.                     $catArr[$cat->getId()] = [
  362.                         'name' => $cat->getName(),
  363.                         'products' => []
  364.                     ];
  365.                 }
  366.             }else{
  367.                 $catArr[$cat->getId()] = [
  368.                     'name' => $cat->getName(),
  369.                     'products' => []
  370.                 ];
  371.             }
  372.                 
  373.         }
  374.         foreach($products as $prod){
  375.             foreach($prod->getCategory() as $prodCat){
  376.                 if(isset($catArr[$prodCat->getId()]))
  377.                     $catArr[$prodCat->getId()]['products'][] = $prod;
  378.             }
  379.         }
  381.         $spreadsheet = new Spreadsheet();
  382.         // Get active sheet - it is also possible to retrieve a specific sheet
  383.         $sheet = $spreadsheet->getActiveSheet();
  384.     
  385.         // Set cell name and merge cells
  386.         // $sheet->setCellValue('A1', 'Крамар ціни');
  387.         $sheet->getRowDimension(1)->setRowHeight(90);
  388.         $sheet->getColumnDimension('A')->setWidth(50);
  389.         $sheet->getColumnDimension('B')->setWidth(10);
  390.         $sheet->getColumnDimension('C')->setWidth(30);
  391.         $sheet->getColumnDimension('D')->setWidth(50);
  392.         $sheet->getColumnDimension('E')->setWidth(60);
  393.         $sheet->getColumnDimension('G')->setWidth(60);
  394.         // Set cell alignment and font weight
  395.         $styleArray = [
  396.             'alignment' => [
  397.                 'horizontal' => \PhpOffice\PhpSpreadsheet\Style\Alignment::HORIZONTAL_CENTER,
  398.                 'vertical' => \PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_CENTER,
  399.             ],
  400.             'font' => [
  401.                 'bold' => true,
  402.             ],
  403.         ];
  404.         $sheet->getStyle('B1')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  405.         $sheet->getStyle('C1')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  406.         $sheet->getStyle('A:A')->applyFromArray($styleArray)->getAlignment()->setVertical(\PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_CENTER);
  407.         $sheet->mergeCells('A1:B1');
  408.         // Add image to worksheet
  409.         $imgPath = 'logo.png';
  410.         $drawing = new \PhpOffice\PhpSpreadsheet\Worksheet\Drawing();
  411.         $drawing->setPath($imgPath);
  412.         $drawing->setCoordinates('A1'); // Set coordinates
  413.         $drawing->setWidth(200); // Set width
  414.         $drawing->setHeight(100); // Set height
  415.         $drawing->setWorksheet($sheet);
  417.         
  420.         $sheet->setCellValue('C1', 'https://felso.com.ua');
  421.         // $sheet->setCellValue('C1', '');
  422.         
  423.         $sheet->mergeCells('A2:G2');
  424.         $sheet->mergeCells('A3:G3');
  425.         $sheet->setCellValue('A2', 'Адреса компанії: м.Львів, вул.Манастирського 2 ');
  426.         $sheet->setCellValue('A3', 'Номер телефону   +38 (068) 844-11-44 +38 (073) 844-11-44');
  428.         // $sheet->setCellValue('D3', 'При замовленні від 0 до 100 кг. однієї позиції')->getStyle('D3')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  429.         // $sheet->setCellValue('E3', 'При замовленні від 100 до 500 кг. однієї позиції')->getStyle('E3')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  430.         // $sheet->setCellValue('F3', 'При замовленні від 500 до 1 тонни однієї позиції')->getStyle('F3')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  431.         // $sheet->setCellValue('G3', 'При замовленні від 1 тонни')->getStyle('G3')->applyFromArray($styleArray)->getAlignment()->setWrapText(true);
  432.     
  433.         // Set column names
  434.         $columnNames = [
  435.             'Назва',
  436.             'Артикул',
  437.             '',
  438.             'характеристики',
  439.             'комплектація',
  440.             'Ціна',
  441.             'Посилання',
  442.             // 'Гурт 2',
  443.             // 'Гурт 1',
  444.             // 'VIP',
  445.         ];
  446.         $columnLetter = 'A';
  447.         foreach ($columnNames as $columnName) {
  448.             // Allow to access AA column if needed and more
  449.             $sheet->setCellValue($columnLetter.'4', $columnName)->getStyle($columnLetter.'4')->applyFromArray($styleArray);
  450.             $columnLetter++;
  451.         }
  452.         $row = 5;
  453.         foreach($catArr as $key => $category){
  454.             $sheet->setCellValue("A{$row}", $category['name'])->mergeCells("A{$row}:G{$row}");
  455.             $sheet->getStyle("A{$row}")->applyFromArray($styleArray);
  456.             $row++;
  457.             if(count($category['products']) > 0)
  458.                 foreach ($category['products'] as $product) {
  460.                     /** Характеристики */
  461.                     $params = '';
  462.                     foreach($product->getAttributeItems() as $attributeItems){
  463.                         $params .= $attributeItems->getAttribute()->getName() . ' - ' . $attributeItems->getName() . "\n";
  464.                     }
  465.                     /** Комплектація */
  466.                     $productComplact = '';
  467.                     foreach($product->getProductInfos() as $productInfos){
  468.                         $productComplact .= $productInfos->getName() . "\n";
  469.                     }
  472.                     $columnLetter++;
  473.                     
  474.                     $sheet->getRowDimension($row)->setRowHeight(100*0.75); // переведення 100px в пункти
  476.                     $sheet->setCellValue('A'.$row, $product->getName());
  477.                     $sheet->getStyle('A' . $row)->getAlignment()->setWrapText(true);
  478.                     $sheet->setCellValue('B'.$row, $product->getArticle());
  479.                     $sheet->getStyle('B' . $row)->getAlignment()->setWrapText(true); // Вмикає перенесення тексту
  480.                     // $sheet->setCellValue('C'.$row, $product->getPrice());
  481.                     /** Характеристики */
  482.                     $sheet->setCellValue('D'.$row, strip_tags($params) );
  483.                     $sheet->getStyle('D' . $row)->getAlignment()->setWrapText(true); // Вмикає перенесення тексту
  484.                     
  485.                     $sheet->setCellValue('E'.$row, $productComplact);
  486.                     $sheet->getStyle('E' . $row)->getAlignment()->setWrapText(true); // Вмикає перенесення тексту
  487.                     $sheet->setCellValue('F'.$row, $product->getPrice());
  488.                     $sheet->setCellValue('G'.$row, 'https://felso.com.ua/product/' . $product->getId());
  489.                     // $sheet->getStyle('C' . $row)->getAlignment()->setWrapText(true); // Вмикає перенесення тексту
  490.                     // $sheet->getRowDimension($row)->setRowHeight(-1); // Автоматична висота рядка
  492.                     if($product->getMainMedia() != null){
  493.                         
  494.                         // Отримуємо рік і місяць із дати завантаження
  495.                         $uploadDate = $product->getMainMedia()->getUploadTimestamp();
  496.                         $year = $uploadDate->format('Y');
  497.                         $month = $uploadDate->format('m');
  498.                     
  499.                         // Формуємо повний шлях до зображення
  500.                         $imgPath = $_SERVER["DOCUMENT_ROOT"] . '/media/' . $year . '/' . $month . '/90_px_' . $product->getMainMedia()->filePath;
  501.                         if(file_exists($imgPath)){
  502.                         // $ = 'logo.png';
  503.                             $drawing = new \PhpOffice\PhpSpreadsheet\Worksheet\Drawing();
  504.                             $drawing->setPath($imgPath);
  505.                             $drawing->setCoordinates('C'.$row); // Set coordinates
  506.                             $drawing->setWidth(150); // Set width
  507.                             $drawing->setHeight(100); // Set height
  508.                             $drawing->setWorksheet($sheet);
  509.                         }
  510.                     
  511.                     }
  513.                     $row++;
  514.                 }
  515.         }
  517.         
  519.         $writer = new Xlsx($spreadsheet);
  520.         $fileName = 'products_' . date('YmdHis') . '.xlsx';
  521.         $writer->save($fileName);
  522.         // Вивантаження файлу
  523.         // Set the content-type:
  524.         header('Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
  525.         header('Content-Length: ' . filesize($fileName));
  526.         readfile($fileName); // send file
  527.         unlink($fileName); // delete file
  529.         return new Response();
  530.     }
  532.     #[Route(
  533.         name: 'addAttrCategory', 
  534.         path: '/add-attr-category',
  535.     )]
  536.     public function addAttrCategory( EntityManagerInterface $entityManager ){
  538.         $products = $entityManager->getRepository(Products::class)->findBy(['show' => true]);
  541.         foreach( $products as $product ){
  543.             if(count($product->getAttributeItems())  > 0 ){
  544.                 foreach($product->getAttributeItems() as $attrItem){
  545.                     $attibute = $attrItem->getAttribute();
  546.                     foreach($product->getCategory() as $category){
  547.                         $attrItem->addCategory($category);
  548.                         $attibute->addCategory($category);
  549.                         $entityManager->persist($attrItem);
  550.                         $entityManager->persist($attibute);
  551.                     }
  552.                 }
  553.             }
  554.             
  555.         }
  556.         $entityManager->flush();
  557.         echo 1111;
  558.         die;
  559.     }   
  562.     #[Route(
  563.         name: 'getDublicate', 
  564.         path: '/get-dublicate',
  565.     )]
  566.     public function getDublicate( EntityManagerInterface $entityManager, Request $request): Response
  567.     {
  568.         set_time_limit(0);
  569.         $duplicates = $entityManager->createQueryBuilder()
  570.         ->select('p.article')
  571.         ->from(Products::class, 'p')
  572.         ->where('p.deleted = FALSE')
  573.         ->groupBy('p.article')
  574.         ->having('COUNT(p.article) > 1')
  575.         ->getQuery()
  576.         ->getResult();
  577.         $i  = 0;
  578.         foreach ($duplicates as $duplicate) {
  579.             // echo $duplicate['article'] . "<br>";
  580.             $products = $entityManager->getRepository(Products::class)
  581.                 ->findBy(['article' => $duplicate['article'], 'deleted' => false]);
  582.             
  583.             // Keep the first product and remove the rest
  584.             $deleted = true;
  585.             $isDeleted = false;
  586.             foreach ($products as $product) {
  587.                 echo $product->getArticle();
  589.                 if(count($product->getOrderProducts()) > 0){
  590.                     $deleted = false;
  591.                     echo ' - - false';
  592.                 }elseif(count( $product->getCategory()) > 0 OR count( $product->getAttributeItems()) > 0){
  593.                     $deleted = false;
  594.                     echo '- false';
  596.                 }else{
  597.                     $deleted = true;
  598.                     echo ' - true';
  599.                 }
  600.                 if($deleted AND !$isDeleted){
  601.                     $i++;
  602.                     $isDeleted = true;
  603.                     $product->setDeleted(true);
  604.                     $product->setDescription('delete dublicate product ' . date('Y-m-d H:i:s'));
  605.                     $entityManager->persist( $product );
  606.                 }
  607.                 
  608.                 
  609.                 echo '<br>';
  610.             }
  611.             if($i === 200){
  613.                 $entityManager->flush();
  614.                 $i=0;
  615.             }
  616.         }
  617.         $entityManager->flush();
  618.         die;
  619.     }
  622.     #[Route(
  623.         name: 'importProductFromExcel', 
  624.         path: '/product/import-from-excel',
  625.     )]
  627.     function importProductFromExcel(EntityManagerInterface $entityManager, Translit $translit){
  628.         echo '<pre>';
  629.         $inputFileName = 'products.xlsx';
  630.         $spreadsheet = IOFactory::load($inputFileName);
  631.         $sheet = $spreadsheet->getActiveSheet();
  632.         $i = 0;
  633.         $category = [];
  634.         $attributes = [];
  635.         $products = [];  
  637.         // $url = $sheet->getDrawingCollection();
  639.         // $sheet->getCell('C1')->getValue()
  640.         // echo '<pre>';
  641.         // print_r($url);
  642.         // var_dump($url); die;
  643.         // die;
  644.         foreach ($sheet->getRowIterator() as $row) {
  645.             $cellIterator = $row->getCellIterator();
  646.             $cellIterator->setIterateOnlyExistingCells(FALSE);
  648.             $data = [];
  649.             foreach ($cellIterator as $cell) {
  650.             //     echo '<pre>';   
  651.             // print_r($cell->getWorksheet()->getDrawingCollection());
  652.                 $value = $cell->getValue();
  653.                 // $drawing = $cell->getWorksheet()->getDrawingCollection();
  654.                 // $hyperlink = $cell->getHyperlink();
  655.                 // if ($hyperlink) {
  656.                 //     $value = $hyperlink->getUrl();
  657.                 // }
  658.                 $data[] = $value;
  659.             }
  661.             // Assuming your Excel file has columns: id, name, price
  662.             // echo '<pre>';
  663.             if($i==0){
  664.                 foreach($data as $k => $d){
  665.                     if($k >= 5 AND !empty($d)){
  666.                         $n = str_replace(':', '', $d);
  667.                         $attributes[$k] = [
  668.                             'name' => trim($n),
  669.                             'slug' => $translit->convert(trim($n)),
  670.                             'items' => []
  671.                         ];
  672.                     }
  673.                 }
  674.                 // print_r($data);
  675.                 $i++;
  676.                 continue;
  677.             }
  678.             
  679.             foreach($data as $k => $d){
  680.                 if($k >= 5 AND !empty($d)){
  681.                     $attributes[$k]['items'][$translit->convert(trim($d))] = trim($d);
  682.                 }
  683.             }
  684.             if(!empty($data[3]))
  685.                 $category[ $translit->convert(trim( $data[4] )) ] = trim( $data[4] );
  687.       
  688.             $products[$i]['data'] = $data;
  689.            
  690.             $i++;
  691.         }
  693.         // print_r($category);
  694.         // print_r($attributes);
  695.         // die;
  698.         // die;
  699.         $findCategory = $entityManager->getRepository(Category::class)->findAll();
  700.         $findAttributes = $entityManager->getRepository(Attributes::class)->findAll();
  702.         foreach($category as $slug =>  $c){
  703.             $find = false;
  704.             foreach($findCategory as $fCat){
  705.                 if($fCat->getName() == $c){
  706.                     $find = true;
  707.                 }
  708.             }
  710.             if(!$find){
  711.                 $entityCat = new Category();
  712.                 $entityCat->setName($c);
  713.                 $entityCat->setSlug($slug);
  714.                 $entityCat->setMain(true);
  715.                 $entityCat->setType('category');
  717.                 $entityManager->persist( $entityCat );
  718.                 
  719.             }
  720.         }
  722.         // echo '<pre>';
  723.         // print_r($attributes); die;
  724.         foreach($attributes as $name => $attrs){
  725.             $attr = false;
  726.             $entityAttr = '';
  727.             foreach($findAttributes as $fAttr){
  728.                 if($fAttr->getName() == $attrs['name']){
  729.                     $entityAttr = $fAttr;
  730.                     $attr = true;
  731.                     foreach($attrs['items'] as $i => $a){
  732.                         foreach($fAttr->getAttributeItems() as $f_a_i){
  733.                             if($f_a_i->getName() == $a){
  734.                                 unset($attrs['items'][$i]);
  735.                             }
  736.                         }
  737.                     }
  738.                 }
  739.             }
  740.              
  741.             if(!$attr){
  742.                 $entityAttr = new Attributes();
  743.                 $entityAttr->setName($attrs['name']);
  744.                 $entityAttr->setSlug($attrs['slug']);
  745.                 $entityManager->persist( $entityAttr );
  746.             }
  748.             if(count($attrs['items']) > 0){
  749.                 foreach($attrs['items'] as $i => $a){
  750.                     $entityAttrItem = new AttributeItems();
  751.                     $entityAttrItem->setName($a);
  752.                     $entityAttrItem->setSlug($i);
  753.                     $entityAttrItem->setAttribute($entityAttr);
  754.                     $entityManager->persist( $entityAttrItem );
  755.                 }
  756.             }
  757.             
  758.         }
  759.         // die;
  760.         $entityManager->flush();
  761.         // die;
  762.         $findCategory = $entityManager->getRepository(Category::class)->findAll();
  763.         $findAttributes = $entityManager->getRepository(Attributes::class)->findAll();
  764.         $findAttributesItems = $entityManager->getRepository(AttributeItems::class)->findAll();
  765.         $findProducts = $entityManager->getRepository(Products::class)->findAll();
  766.         $measurmentUnit = $entityManager->getRepository(MeasurmentUnit::class)->findOneBy(['name' => 'Штука']);
  768.         // print_r($products); die;    
  770.         foreach($products as $product){
  771.             $search = false;
  772.             $findProduct = '';
  773.             foreach($findProducts  as $f_p){
  774.                 if($f_p->getArticle() == $product['data'][1]){
  775.                     $search = true;
  776.                     $findProduct = $f_p;
  777.                 }
  778.             }
  780.             $price = floatval(trim(str_replace('грн', '' , $product['data'][2])));
  782.             if(!$search and !empty($product['data'][0])){
  783.                 $newProduct = new Products();
  784.                 $newProduct->setName($product['data'][0]);
  785.                 $newProduct->setArticle($product['data'][1]);
  786.                 $newProduct->setPrice($price);
  787.                 $newProduct->setShow(true);
  788.                 $findProduct->setBalance(1);
  789.                 // $newProduct->setPackingType($product['data'][7] . ' | ' . $product['data'][7]);
  790.                 $newProduct->getMeasurementUnit($measurmentUnit);
  791.                 foreach($product['data'] as $k => $d){
  792.                     if($k >= 5 AND !empty($d)){
  793.                         foreach($findAttributesItems as $ati){
  794.                             if($ati->getName() == trim($d)){
  795.                                 $newProduct->addAttributeItem($ati);
  796.                             }
  797.                         }
  798.                     }
  799.                     if($k == 4 AND !empty($d)){
  800.                         foreach ($findCategory as $f_c){
  801.                             if($f_c->getName() == trim($d)){
  802.                                 $newProduct->addCategory($f_c);
  803.                             }
  804.                         }
  805.                     }
  806.                 }
  808.                 $entityManager->persist( $newProduct );
  811.             }else{
  812.                 echo $findProduct->getName() . "<br>";
  813.                 $findProduct->setPrice($price);
  814.                 $findProduct->setShow(true);
  815.                 $findProduct->setBalance(1);
  816.                 foreach($product['data'] as $k => $d){
  817.                     $searvhAttr = false;
  818.                     if($k >= 5 AND !empty($d)){
  819.                         foreach( $findProduct->getAttributeItems() as $productAttrItem){
  820.                             if( $productAttrItem->getName() ==  $d){
  821.                                 $searvhAttr = true;
  822.                             }
  823.                         }
  825.                         if(!$searvhAttr){
  826.                             foreach($findAttributesItems as $ati){
  827.                                 if($ati->getName() == trim($d)){
  828.                                     $findProduct->addAttributeItem($ati);
  829.                                 }
  830.                             }
  832.                             $entityManager->persist( $findProduct );
  833.                         }
  834.                     }
  835.                 }
  836.                 // if(empty( $findProduct->getCategory() )){
  837.                     foreach($product['data'] as $k => $d){
  838.                         if($k == 4 AND !empty($d)){
  839.                             foreach ($findCategory as $f_c){
  840.                                 if($f_c->getName() == trim($d)){
  841.                                     echo  $f_c->getName(). "<br>";
  842.                                     $findProduct->addCategory($f_c);
  843.                                 }
  844.                             }
  845.                         }
  846.                     }
  847.                 // }
  848.                 
  852.                 $entityManager->persist( $findProduct );
  853.                 
  854.             }
  856.         }
  857.         $entityManager->flush();
  860.         // $findProducts = $entityManager->getRepository(Products::class)->findAll();
  863.         // foreach ($sheet->getDrawingCollection() as $in =>  $drawing) {
  864.         //         // print_r($drawing->getCoordinates());
  865.         //         $c = str_replace('E', '', $drawing->getCoordinates() );
  866.         //         // print_r($sheet->getCell( "B$c" )->getValue());
  867.         //         // echo "<br>";
  869.         //         foreach($findProducts  as $f_p){
  870.         //             if($f_p->getArticle() == $sheet->getCell( "B$c" )->getValue()){
  871.         //                 $zipReader = fopen($drawing->getPath(),'r');
  872.         //                 $imageContents = '';
  874.         //                 while (!feof($zipReader)) {
  875.         //                     $imageContents .= fread($zipReader,1024);
  876.         //                 }
  877.         //                 fclose($zipReader);
  878.         //                 $extension = $drawing->getExtension();
  880.         //                 $imageBase64 = base64_encode($imageContents);
  882.         //                 $url = 'https://api-felso-brand.inneti.net/api/media_objects?product=' .  $f_p->getId();
  883.         //                 $imageFile = new \CURLFile($imageBase64, 'image/' . $extension, 'image.' . $extension);
  884.         //                 echo  $url; echo '<br>';
  885.         //                 // Set up the cURL request
  886.         //         // Ініціалізуємо cURL-сесію
  887.         //                 $ch = curl_init();
  889.         //                 // Встановлюємо параметри запиту
  890.         //                 curl_setopt($ch, CURLOPT_URL, $url);
  891.         //                 curl_setopt($ch, CURLOPT_POST, 1);
  892.         //                 curl_setopt($ch, CURLOPT_POSTFIELDS, ['image' => $imageFile]);
  893.         //                 // curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  895.         //                 // Execute the cURL request
  896.         //               // Виконуємо запит
  897.         //                 $response = curl_exec($ch);
  898.         //                 // $json = json_decode($response);
  900.         //                 // Перевіряємо наявність помилок
  901.         //                 if (curl_errno($ch)) {
  902.         //                     echo 'Error:' . curl_error($ch);
  903.         //                 }
  905.         //                 // Закриваємо cURL-сесію
  906.         //                 curl_close($ch);
  907.         //                 die;
  908.             
  909.         //             }
  910.         //         }
  911.        
  912.             
  913.         //         // $zipReader = fopen($drawing->getPath(),'r');
  914.         //         // $imageContents = '';
  915.         
  916.         //         // while (!feof($zipReader)) {
  917.         //         //     $imageContents .= fread($zipReader,1024);
  918.         //         // }
  919.         //         // fclose($zipReader);
  920.         //         // $extension = $drawing->getExtension();
  922.         //         // $imageBase64 = base64_encode($imageContents);
  924.         //         // $url = 'https://api-felso-brand.inneti.net/api/media_objects?product=' .  $entity->getId();
  925.         //         // $imageFile = new CURLFile($imageBase64, 'image/' . $extension, 'image.' . $extension);
  927.         //         // // Set up the cURL request
  928.         //         // $ch = curl_init();
  929.         //         // curl_setopt($ch, CURLOPT_URL, $url);
  930.         //         // curl_setopt($ch, CURLOPT_POST, 1);
  931.         //         // curl_setopt($ch, CURLOPT_POSTFIELDS, ['image' => $imageFile]);
  932.         //         // curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
  933.             
  934.         //         // // Execute the cURL request
  935.         //         // $response = curl_exec($ch);
  936.             
  937.         //         // // Close cURL resource
  938.         //         // curl_close($ch);
  939.             
  940.         //     // }
  941.         //     // $myFileName = '00_Image_'.++$i.'.'.$extension;
  942.         //     // file_put_contents($myFileName,$imageContents);
  943.         // }
  945.         // $entityManager->flush();
  946.             echo 111;
  947.         die;
  948.         // return $this->redirectToRoute('app_homepage');
  949.     }
  952.     public function imgCurl($entity, $imgUrl, $type='img'){
  955.                 // continue;
  956.                 // $img = file_get_contents($imgUrl);
  957.                 $url = 'https://api-felso.inneti.net/api/media_objects';
  959.                 if( $type == 'img' )
  960.                     $url .= '?product=' .  $entity->getId();
  961.                 // echo " $url<br><br>";
  962.                 // Файл, який ви хочете відправити
  963.                 $file_path = $imgUrl;
  965.                 // Ініціалізуємо cURL-сесію
  966.                 $ch = curl_init();
  968.                 // Встановлюємо параметри запиту
  969.                 curl_setopt($ch, CURLOPT_URL, $url);
  970.                 curl_setopt($ch, CURLOPT_POST, 1);
  971.                 curl_setopt($ch, CURLOPT_POSTFIELDS, [
  972.                     'file' => new \CURLFile($file_path)
  973.                 ]); 
  975.                 echo '----';
  977.                 // Виконуємо запит
  978.                 $response = curl_exec($ch);
  979.                 echo '|||';
  981.                 // $json = json_decode($response);
  983.                 // Перевіряємо наявність помилок
  984.                 if (curl_errno($ch)) {
  985.                     echo '2Error:' . curl_error($ch); die;
  986.                 }
  988.                 // Закриваємо cURL-сесію
  989.                 curl_close($ch);
  991.                 return $response;
  992.     }
  995.     public function newImg($findProducts,  $pathProductsDir, $pathNew, ){
  997.         echo $findProducts->getName() . "+++<br>"; 
  998.         $uploadTimestamp = new  \DateTime();
  999.         $mediaObject = new MediaObject();
  1000.         // $mediaObject->file = $uploadedFile;
  1001.         $mediaObject->uploadTimestamp = $uploadTimestamp;
  1002.         $mediaObject->filePath = $findProducts->getId().$pathProductsDir;
  1003.         $mediaObject->setName('product_img');
  1004.         $mediaObject->setProduct($findProducts);
  1005.         $this->entityManager->persist( $mediaObject );
  1006.         $this->entityManager->flush();
  1007.         $year = date('Y');
  1008.         $month = date('m');
  1009.         $documentRoot = $this->kernel->getProjectDir() . '/public/media';
  1010.         $path = $documentRoot . "/$year/$month/";
  1011.         $sizes = [90, 230, 700, 1200];
  1012.         $manager = new ImageManager(
  1013.             new \Intervention\Image\Drivers\Gd\Driver() 
  1014.         );
  1015.         foreach($sizes as $s){
  1016.             $image = $manager->read($pathNew);
  1017.             $image->scale(width: $s);
  1018.             $newName = "{$s}_px_" .  $findProducts->getId().$pathProductsDir;
  1019.             $image->save($path . $newName );
  1021.             $newMedia = new MediaObject();
  1022.             $newMedia->filePath = $newName;
  1023.             $newMedia->setName("resize-$s");
  1024.             $newMedia->setSize($s);
  1025.             $newMedia->setResizeImgParent($mediaObject);
  1026.             $this->entityManager->persist($newMedia);
  1027.             $this->entityManager->flush();
  1029.         
  1030.         }
  1031.         $findProducts = null;
  1033.         return $mediaObject;
  1034.     }
  1037.     #[Route(
  1038.         name: 'importProductImg', 
  1039.         path: '/product/import-img',
  1040.     )]
  1042.     function importProductImg(EntityManagerInterface $entityManager, Translit $translit, MediaObjectsRepository $mediaObjectsRepository, ?\DateTimeInterface $uploadTimestamp){
  1043.         echo '<pre>';
  1044.         $path = 'products_img';
  1045.         $nextPaths = scandir($path);
  1046.         print_r($nextPaths);
  1047.         foreach($nextPaths as $nextPath){
  1048.             if($nextPath == '.' OR $nextPath == '..')
  1049.                 continue;
  1051.             $pathCat = "$path/$nextPath";
  1052.             $pathCatDirs = scandir($pathCat);
  1053.             
  1054.             foreach($pathCatDirs as $pathCatDir){
  1055.                 if($pathCatDir == '.' OR $pathCatDir == '..')
  1056.                     continue;
  1057.                 // if($pathCatDir == 'ID1250')
  1058.                 //     die;
  1060.                 // print_r($pathCatDir); die;
  1062.                 file_put_contents('import-img.log', $pathCatDir . "\n", FILE_APPEND);
  1063.                 $pathProducts = "$pathCat/$pathCatDir";
  1064.                 $pathProductsDirs = scandir($pathProducts);
  1065.                 echo "<b>$pathCatDir</b><br>";
  1066.                 $findProducts = $entityManager->getRepository(Products::class)->findOneBy(['article' => $pathCatDir]);
  1067.                 
  1068.                 if($findProducts ){
  1069.                     echo "<b>" . $findProducts->getName() . "</b><br>";
  1070.                     foreach($findProducts->getMedia() as $m){
  1071.                         echo $m->getId() . "<br>";
  1072.                         $findProducts->removeMedium($m);
  1073.                     }
  1075.                     $mainMedia = $findProducts->getMainMedia();
  1076.                     if($mainMedia){
  1077.                         echo "main - " . $mainMedia->getId() . "<br>";
  1078.                         $mainMedia->removeMainProduct($findProducts);
  1079.                         $entityManager->persist( $findProducts );
  1080.                     }
  1081.                     $MainMediaHover = $findProducts->getMainMediaHover();
  1082.                     if($MainMediaHover){
  1083.                         echo "hover - main - " . $MainMediaHover->getId() . "<br>";
  1084.                         $MainMediaHover->removeProductsHover($findProducts);
  1085.                         $entityManager->persist( $MainMediaHover );
  1087.                     }
  1088.                     $entityManager->persist( $findProducts );
  1090.                     $entityManager->flush();
  1092.                    
  1093.                 }else{
  1094.                     continue;
  1095.                 }
  1097.                 // echo $findProducts->getName();
  1098.                 echo "<br>";
  1100.                 foreach($pathProductsDirs as $pathProductsDir){
  1101.                     if($pathProductsDir == '.' OR $pathProductsDir == '..')
  1102.                         continue;
  1104.                     $pathImg =  $this->kernel->getProjectDir() . "/public/$pathProducts/$pathProductsDir";
  1105.                     $pathNew = $this->kernel->getProjectDir() . "/public/media/" . date('Y') . "/" . date('m') . "/".$findProducts->getId()."$pathProductsDir";
  1106.                     echo $pathImg . "---<br>";
  1107.                     echo $pathNew . "---<br>";
  1109.                     
  1110.                     if($pathProductsDir == '1_0.png'){
  1111.                         if(copy($pathImg, $pathNew)){
  1112.                             $mediaObject = $this->newImg($findProducts, $pathProductsDir, $pathNew);
  1113.                             $findProducts->setMainMedia($mediaObject);
  1114.                             $entityManager->persist( $findProducts );
  1115.                            
  1116.                         }
  1117.                     }elseif($pathProductsDir == '1_1.png'){
  1118.                         if(copy($pathImg, $pathNew)){
  1119.                             $mediaObject = $this->newImg($findProducts, $pathProductsDir, $pathNew);
  1120.                             $findProducts->setMainMediaHover($mediaObject);
  1121.                             $entityManager->persist( $findProducts );
  1122.                         }
  1123.                        
  1124.                     }else{
  1125.                         if(copy($pathImg, $pathNew)){
  1126.                             $mediaObject = $this->newImg($findProducts, $pathProductsDir, $pathNew);
  1127.                             // $findProducts->setMainMediaHover($mediaObject);
  1128.                             $entityManager->persist( $findProducts );
  1129.                         } 
  1130.                     }
  1131.                         
  1132.                 }
  1133.                 $entityManager->flush();
  1134.                 $entityManager->clear();
  1135.                 $findProducts = '';
  1136.                 // die;
  1138.             }
  1139.             
  1140.         }
  1141.         // print_r($nextPaths);
  1147.         die;
  1148.         
  1149.     }
  1151.     #[Route('/products/export-xml', name: 'export_xml')]
  1152.     public function exportXml(EntityManagerInterface $entityManager, Request $request): Response
  1153.     {
  1155.         $_get = $request->query->all();
  1156.         $categoryId = isset($_get['category']) && !empty($_get['category']) ? $_get['category'] : null;
  1158.         // echo '<pre>';
  1159.         // var_dump($categoryId);
  1160.         // die;
  1162.         $categories = $entityManager->getRepository(Category::class)->findAll();
  1163.      
  1164.         $products = $entityManager->getRepository(Products::class)->findAll();
  1166.         $xml = new \SimpleXMLElement('<yml_catalog/>');
  1167.         $xml->addAttribute('date', date('Y-m-d H:i'));
  1169.         $shop = $xml->addChild('shop');
  1170.         $shop->addChild('name', '2PR');
  1171.         $shop->addChild('company', '2PR');
  1172.         $shop->addChild('url', 'https://felso.inneti.net/');
  1173.         $shop->addChild('phone', '068-844-11-44');
  1174.         $shop->addChild('platform', 'Store');
  1175.         $shop->addChild('version', '2.1.0.1');
  1176.         // $currencies = $shop->addChild('currencies');
  1177.         // $currencies->addChild('currency')->addAttribute('id', 'UAH')->addAttribute('rate', '1');
  1178.         // Додаємо категорії
  1179.         $categoriesXml = $shop->addChild('categories');
  1180.         foreach ($categories as $category) {
  1181.             if($categoryId !== null AND !in_array($category->getId(), $categoryId)){
  1182.                 continue;
  1183.             }
  1184.             $categoryXml = $categoriesXml->addChild('category', $category->getName());
  1185.             $categoryXml->addAttribute('id', $category->getId());
  1186.             if ($category->getParent()) {
  1187.                 $categoryXml->addAttribute('parentId', $category->getParent()->getId());
  1188.             }
  1189.         }
  1192.                 // Додаємо продукти
  1193.                 $offers = $shop->addChild('offers');
  1194.                 foreach ($products as $product) {
  1196.                     if($categoryId !== null){
  1197.                         $search = false;
  1198.                         foreach($product->getCategory() as $cat){
  1199.                             if( in_array($cat->getId() , $categoryId) )
  1200.                                 $search = true;
  1201.                         }
  1202.                         if(!$search)
  1203.                             continue;
  1204.                     }
  1206.                     $cat = '';
  1207.                     if($product->getCategory() != null AND count($product->getCategory()) > 0)
  1208.                         $cat =  $product->getCategory()[0]->getId();
  1209.                     $img = '';
  1210.                     if($product->getMainMedia() != null){
  1211.                         
  1212.                             // Отримуємо рік і місяць із дати завантаження
  1213.                             $uploadDate = $product->getMainMedia()->getUploadTimestamp();
  1214.                             $year = $uploadDate->format('Y');
  1215.                             $month = $uploadDate->format('m');
  1216.                         
  1217.                             // Формуємо повний шлях до зображення
  1218.                             $img = 'https://api-felso-brand.inneti.net/media/' . $year . '/' . $month . '/' . $product->getMainMedia()->filePath;
  1219.                         
  1220.                     }
  1221.                         // $img = 
  1223.                     $offer = $offers->addChild('offer');
  1224.                     $offer->addAttribute('id', $product->getId());
  1225.                     $offer->addAttribute('available', $product->isShow() ? 'true' : 'false');
  1226.                     $offer->addChild('url', 'https://felso.inneti.net/product/' . $product->getId());
  1227.                     $offer->addChild('price', $product->getPrice());
  1228.                     $offer->addChild('currencyId', 'UAH');
  1229.                     $offer->addChild('categoryId',  $cat );
  1230.                     $offer->addChild('picture', $img);
  1231.                     // $offer->addChild('vendor', $product->getVendor());
  1232.                     $offer->addChild('vendorCode', $product->getArticle());
  1233.                     $offer->addChild('name', $product->getName());
  1234.                     $offer->addChild('description', htmlspecialchars($product->getDescription()));
  1235.                 }
  1236.         
  1237.                 // Конвертація у XML
  1238.                 $response = new Response($xml->asXML());
  1239.                 $response->headers->set('Content-Type', 'application/xml');
  1240.         
  1241.                 return $response;
  1245.     }
  1247. }