src/Controller/DefaultController.php line 49

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Entity\HomeSlider;
  6. use App\Entity\Order;
  7. use App\Entity\OrderProduct;
  8. use App\Entity\Product;
  9. use App\Repository\HomePageRepository;
  10. use App\Repository\HomeSliderRepository;
  11. use App\Repository\OrderRepository;
  12. use App\Repository\ProductRepository;
  13. use App\Repository\SonataUserUserRepository;
  14. use App\Services\ApiConsumer;
  15. use App\Twig\Extension\MediaExtension;
  16. use App\Utils\EAS256CBC;
  17. use App\Utils\SeoUtils;
  18. use DateTime;
  19. use Doctrine\ORM\EntityManagerInterface;
  20. use PhpOffice\PhpSpreadsheet\IOFactory;
  21. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  22. use PhpOffice\PhpSpreadsheet\Shared\Date as ExcelDate;
  23. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  24. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  25. use Symfony\Component\HttpFoundation\JsonResponse;
  26. use Symfony\Component\HttpFoundation\Request;
  27. use Symfony\Component\HttpFoundation\Response;
  28. use Symfony\Component\HttpFoundation\StreamedResponse;
  29. use Symfony\Component\Routing\Annotation\Route;
  31. class DefaultController extends AbstractController
  32. {
  33.     protected readonly SeoUtils $seoUtils;
  35.     protected ApiConsumer            $apiConsumer;
  36.     protected EntityManagerInterface $em;
  37.     private static string            $default_task = '5178';
  39.     public function __construct(SeoUtils $seoUtils, ApiConsumer $apiConsumer, EntityManagerInterface $em)
  40.     {
  41.         $this->seoUtils    = $seoUtils;
  42.         $this->apiConsumer = $apiConsumer;
  43.         $this->em          = $em;
  44.     }
  46.     /**
  47.      * @Route("/{reactRouting}", name="homepage", requirements={"reactRouting"=".+"}, defaults={"reactRouting": null}, priority=-10)
  48.      */
  49.     public function indexAction(Request $request): Response
  50.     {
  51.         return $this->render('default/index.html.twig');
  52.     }
  55.     /**
  56.      * @Route("/data/Initial.json", name="data_home2")
  57.      */
  58.     public function dataHomeAction(Request $request, HomePageRepository $homePageRepository, MediaExtension $media): \Symfony\Component\HttpFoundation\JsonResponse
  59.     {
  60.         $page = $homePageRepository->findOneBy([]);
  62.         $data[] = [
  63.             'bannerPrimary' => [
  64.                 'id'         => 1,
  65.                 'imgDesktop' => $media->media($page->getBannerPrimaryDesktop()),
  66.                 'imgMobile'  => $media->media($page->getBannerPrimaryMobile()),
  67.                 'link'       => $page->getBannerPrimaryLink(),
  68.             ],
  69.             'bannerSecondary' => [
  70.                 'id'         => 2,
  71.                 'imgDesktop' => $media->media($page->getBannerSecondaryDesktop()),
  72.                 'imgMobile'  => $media->media($page->getBannerSecondaryMobile()),
  73.                 'link'       => $page->getBannerSecondaryLink(),
  74.             ],
  75.             'bannerTertiary' => [
  76.                 'id'         => 3,
  77.                 'imgDesktop' => $media->media($page->getBannerTertiaryDesktop()),
  78.                 'imgMobile'  => $media->media($page->getBannerTertiaryMobile()),
  79.                 'link'       => $page->getBannerTertiaryLink(),
  80.             ],
  81.             'slides' => array_values(array_map(
  82.                                          fn(HomeSlider $item) => [
  83.                                              'id'        => $item->getId(),
  84.                                              'imgDesktop' => $media->media($item->getSlideDesktop()),
  85.                                              'imgMobile'  => $media->media($item->getBannerMobile()),
  86.                                              'link'       => $item->getLink(),
  88.                                          ],
  89.                                          array_filter(iterator_to_array($page->getSliders()), fn($item) => $item->isPublic())
  90.                                      )),
  92.         ];
  95.         return $this->json($data);
  96.     }
  97.     /**
  98.      * @Route("/data/batch.json", name="data_batch")
  99.      * @Route("/data/batch_json", name="data_batch2")
  100.      */
  101.     public function dataBatchAction(Request $request, OrderRepository $orderRepository): \Symfony\Component\HttpFoundation\JsonResponse
  102.     {
  103.         $id = $request->query->get('id');
  105.         $session = $request->getSession();
  107.         $order = $orderRepository->findOneBy(['ws_id' => (int)$id]);
  109.         $tracking = $this->apiConsumer->getImportsTasksTracking($order->getId(), $order->getWsId(), $session->get('user_password_hash'));
  111.         $data[] =
  112.             [
  113.                 "id"              => $order->getId(),
  114.                 "idWeb"           => $order->getId(),
  115.                 "batchId"         => $order->getWsId(),
  116.                 "Cliente"         => '',
  117.                 "Estado"          => $tracking->estado,
  118.                 "detalleDeCarga"  => '0000',
  119.                 "FechaDeCarga"    => $tracking->start_process,
  120.                 "FechaDeProceso"  => $tracking->end_process,
  121.                 "FechaFinProceso" => $tracking->end_process,
  122.                 "detalle"         => $id,
  124.             ];
  127.         return $this->json($data);
  128.     }
  131.     /**
  132.      * @Route("/data/homeWork.json", name="data_homeWork")
  133.      * @Route("/data/homeWork_json", name="data_homeWork2")
  134.      */
  135.     public function dataHomeWorkAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  136.     {
  137.         $id = $request->query->get('id');
  139.         $session = $request->getSession();
  141.         $tasks_ws = $this->getTasksFormat($request, $id);
  143.         $fields = [];
  145.         foreach ($tasks_ws as $tasks_w) {
  146.             $fields[] = $this->correctWorks($tasks_w, true);
  147.         }
  150.         $field_last = array_pop($fields);
  152.         $data = [];
  154.         $data[] =
  155.             [
  156.                 "id"             => $id,
  157.                 "IdWork"         => $id,
  158.                 "name"           => '',
  159.                 "modalContent"   => "Para armar el archivo de texto, crea filas con los datos separados por tabuladores y cada registro en una nueva línea, en el siguiente orden: " . implode(", ", $fields) . ' y ' . $field_last,
  160.                 "exampleFile"    => $id ? $this->generateUrl('download_example', ['task_id' => $id]) : '',
  161.                 "exampleFileXls" => $id ? $this->generateUrl('download_example_xls', ['task_id' => $id]) : '',
  162.                 "example"        => [],
  163.             ];
  166.         return $this->json($data);
  167.     }
  169.     private function correctWorks($word, $ucfirst = false): string
  170.     {
  171.         $result = match ($word) {
  172.             'lot' => 'lote',
  173.             'hold' => 'Tratamiento',
  174.             default => $word,
  175.         };
  177.         return $ucfirst ? ucfirst($result) : $result;
  178.     }
  181.     /**
  182.      * @Route("/data/fileTranfer.json", name="data_file_tranfer")
  183.      * @Route("/data/fileTranfer_json", name="data_file_tranfer2")
  184.      */
  185.     public function dataFileTransferAction(Request $request, OrderRepository $orderRepository): \Symfony\Component\HttpFoundation\JsonResponse
  186.     {
  187.         $id = $request->query->get('id');
  189.         $session = $request->getSession();
  191.         $works_ws  = $this->apiConsumer->getImportsTasksList($id, $session->get('user_password_hash'));
  192.         $orders_ws = $this->apiConsumer->getPedidoSeguimiento($id, $session->get('user_password_hash'));
  195.         $orders  = [];
  196.         $statuss = [];
  197.         foreach ($orders_ws as $order_ws) {
  199.             $order = $orderRepository->findOneBy(['ws_id' => $order_ws->ob_oid]);
  201.             if ($order != null) {
  202.                 $data_merge = [
  203.                     'web_id'    => $order->getId(),
  204.                     'create_at' => $order->getCreateAt()->format('Y-m-d H:i:s'),
  205.                     'file'      => $order->getFileName() ?? '',
  206.                     'user'      => $order->getUser()->getUsername(),
  207.                     'client'    => $order->getUser()->getUsername(),
  208.                 ];
  209.                 $orders[]   = array_merge((array)$order_ws, $data_merge);
  210.                 $statuss[]  = [
  211.                     'id'   => $order->getId(),
  212.                     'name' => $order_ws->Estado
  213.                 ];
  214.             }
  215.         }
  218.         $works = [];
  219.         foreach ($works_ws as $work) {
  220.             $works[] = [
  221.                 'id'     => $work->Id_Tarea,
  222.                 'IdWork' => $work->Id_Tarea,
  223.                 'name'   => $work->Descripcion,
  224.             ];
  225.         }
  227.         $order_list = [];
  228.         foreach ($orders as $order) {
  229.             $order        = (object)$order;
  230.             $order_list[] =
  231.                 [
  232.                     "id"             => $order->web_id,
  233.                     "idWeb"          => $order->web_id,
  234.                     "BatchId"        => $order->ob_oid,
  235.                     "Carga"          => $order->create_at,
  236.                     "Archivo"        => $order->file,
  237.                     "Usuario"        => $order->user,
  238.                     "Cliente"        => $order->client,
  239.                     "Estado"         => $order->Estado,
  240.                     "detalleDeCarga" => $order->Cita,
  241.                     "FechaDeCarga"   => $order->Fecha_Cita,
  242.                     "FechaDeProceso" => $order->Fecha_Cita,
  243.                     "detalle"        => 'None',
  244.                 ];
  245.         }
  247.         $data = [
  248.             [
  249.                 'stateList' => $statuss,
  250.                 'orderList' => $order_list,
  251.                 'homework'  => $works,
  252.             ]
  253.         ];
  256.         return $this->json($data);
  257.     }
  260.     /**
  261.      * @param Request                  $request
  262.      * @param ProductRepository        $productRepository
  263.      * @param SonataUserUserRepository $userRepository
  264.      * @param OrderRepository          $orderRepository
  265.      * @return JsonResponse
  266.      * @Route("/intranet/process_order", name="process_order")
  267.      */
  268.     public function processOrdenAction(Request $request, ProductRepository $productRepository, SonataUserUserRepository $userRepository, OrderRepository $orderRepository)
  269.     {
  270.         $session        = $request->getSession();
  271.         $p              = $request->request;
  272.         $data           = json_decode($p->get('orderData'));
  273.         $data           = $data->data ?? null;
  274.         $user_pass_hash = $session->get('user_password_hash');
  277.         $response = [
  278.             "status"  => 'error',
  279.             "message" => 'No se pudo procesar el pedido',
  281.         ];
  283.         $user = $userRepository->findOneBy(['user_pass_hash' => $user_pass_hash]);
  285.         if ($data) {
  287.             $order = new Order();
  288.             $order->setUser($user);
  289.             $order->setAccountId($data->accountId);
  290.             $order->setTasks(self::$default_task);
  292.             $errors = [];
  294.             if (!$data->info->name) {
  295.                 $errors['name'] = 'El nombre es obligatorio';
  296.             }
  297.             if (!$data->info->phone) {
  298.                 $errors['phone'] = 'El teléfono es obligatorio';
  299.             }
  300.             if (!$data->info->address) {
  301.                 $errors['phone'] = 'La dirección es obligatoria';
  302.             }
  303.             if (!$data->info->city) {
  304.                 $errors['city'] = 'La ciudad es obligatoria';
  305.             }
  307.             if (count($errors) < 0) {
  308.                 $response = [
  309.                     "status"  => 'error',
  310.                     "message" => 'Debes completar todos los campos obligatorios',
  311.                     "errors"  => $errors,
  312.                 ];
  313.                 return $this->json($response);
  314.             }
  316.             $order->setContactName($data->info->name);
  317.             $order->setContactPhone($data->info->phone);
  318.             $order->setContactAddress($data->info->address);
  319.             $order->setContactCity($data->info->city);
  321.             $this->em->persist($order);
  322.             $this->em->flush();
  325.             foreach ($data->list as $item) {
  327.                 $product = $productRepository->findOneBy(['product_id' => $item->id]);
  328.                 if (!$product) {
  329.                     $product = new Product();
  330.                     $product->setProductId($item->id);
  331.                     $product->setName($item->name);
  332.                     $product->setPackaging($item->packagingType);
  333.                     $this->em->persist($product);
  334.                     $this->em->flush();
  335.                 }
  337.                 $order_prod = new OrderProduct();
  338.                 $order_prod->setOrder($order);
  339.                 $order_prod->setProduct($product);
  340.                 $order_prod->setBatch($item->selectBatch);
  341.                 $order_prod->setQuantity($item->total);
  342.                 $this->em->persist($order_prod);
  343.                 $this->em->flush();
  344.             }
  346.             $send = $this->sendFileBase64($request, $order, false);
  348.             if ($send) {
  349.                 $response = [
  350.                     "status"  => 'success',
  351.                     "message" => 'Pedido recibido correctamente',
  353.                 ];
  354.             }
  357.         }
  359.         return $this->json($response);
  360.     }
  362.     /**
  363.      * @param Request $request
  364.      * @return JsonResponse
  365.      * @Route("/intranet/process_order_file", name="process_order_file")
  366.      */
  367.     public function processOrdenFileAction(Request $request, ProductRepository $productRepository, SonataUserUserRepository $userRepository, OrderRepository $orderRepository)
  368.     {
  369.         $session        = $request->getSession();
  370.         $user_pass_hash = $session->get('user_password_hash');
  371.         $account_id     = $request->request->get('accountId');
  372.         $id_home_work   = $request->request->get('idHomeWork');
  373.         
  375.         $file = $request->files->get('file');
  377. //        $products = $this->apiConsumer->getclientInv($account_id, $session->get('user_password_hash'));
  379.         $allowedMimeTypes = [
  380.             'text/plain',                 // .txt
  381.             'application/vnd.ms-excel',   // .xls (antiguo formato de Excel)
  382.             'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet', // .xlsx
  383.         ];
  385.         $mimeType = $file->getMimeType();
  387.         if (!in_array($mimeType, $allowedMimeTypes)) {
  388.             $response = [
  389.                 "status"  => 'error',
  390.                 "message" => 'El archivo debe ser en formato TXT o Excel',
  391.             ];
  392.             return $this->json($response);
  393.         }
  395.         if ($mimeType == 'text/plain') {
  396.             $lines = file($file, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
  397.         } else {
  398.             $spreadsheet = IOFactory::load($file->getPathname());
  399.             $sheet       = $spreadsheet->getActiveSheet();
  400.             $lines       = [];
  402.             // --- Rango de fechas dinámico: 5 años antes y 5 después de hoy ---
  403.             $today = new \DateTime();
  404.             $startDate = (clone $today)->modify('-5 years');
  405.             $endDate = (clone $today)->modify('+5 years');
  407.             $startSerial = \PhpOffice\PhpSpreadsheet\Shared\Date::PHPToExcel($startDate);
  408.             $endSerial = \PhpOffice\PhpSpreadsheet\Shared\Date::PHPToExcel($endDate);
  409.             // --- Fin del rango dinámico ---
  411.             foreach ($sheet->getRowIterator() as $row) {
  412.                 $rowData = [];
  413.                 foreach ($row->getCellIterator() as $cell) {
  414.                     $value = $cell->getValue();
  416.                     // Heurística para detectar y convertir fechas probables en el rango dinámico
  417.                     if (is_numeric($value) && $value >= $startSerial && $value <= $endSerial) {
  418.                         try {
  419.                             // Intentar convertir el serial de Excel a fecha
  420.                             $dateTime = ExcelDate::excelToDateTimeObject($value);
  421.                             $value = $dateTime->format('d/m/Y');
  422.                         } catch (\Exception $e) {
  423.                             // Si falla, mantener el valor como string
  424.                             $value = (string)$value;
  425.                         }
  426.                     } else {
  427.                         // Para todos los demás valores, solo convertir a string
  428.                         $value = (string)$value;
  429.                     }
  431.                     $rowData[] = $value;
  432.                 }
  433.                 // Solo agregar la fila si tiene al menos un valor no vacío
  434.                 if (!empty(array_filter($rowData, function($cell) {
  435.                     return trim($cell) !== '';
  436.                 }))) {
  437.                     $lines[] = $rowData;
  438.                 }
  439.             }
  440.         }
  443.         $user = $userRepository->findOneBy(['user_pass_hash' => $user_pass_hash]);
  445.         $order = new Order();
  446.         $order->setUser($user);
  447.         $order->setAccountId($account_id);
  448.         $order->setTasks($id_home_work);
  449.         $order->setFileName($file->getClientOriginalName());
  450.         $this->em->persist($order);
  451.         $this->em->flush();
  453.         /*foreach ($lines as $line) {
  454.             if ($mimeType == 'text/plain') {
  455.                 $columns = explode("\t", $line); // Dividir la línea en columnas
  456.             } else {
  457.                 $columns = $line;
  458.             }
  460.             $fields       = [];
  461.             $tasks_format = $this->getTasksFormat($request, $id_home_work);
  462.             foreach ($columns as $key => $field) {
  463.                 if (isset($tasks_format[$key])) {
  464.                     $fields[$tasks_format[$key]] = trim($field);
  465.                 }
  466.             }
  467.             
  468. //            dump($fields);
  471.             $product = $productRepository->findOneBy(['product_id' => $fields['producto']]);
  472.             
  473.             if (!$product) {
  474.                 $prod_ws = array_filter($products, function ($item) use ($fields) {
  475.                     return trim($item->producto_cod) === trim($fields['producto']);
  476.                 });
  478.                 if (!isset($prod_ws[0])) {
  479. //                    dump("No se encontró el producto con código: " . $fields['producto']);
  480.                     continue;
  481.                 }
  482.                 $prod_ws = $prod_ws[0];
  484.                 $product = new Product();
  485.                 $product->setProductId($prod_ws->producto_cod);
  486.                 $product->setName($prod_ws->desc_prod);
  487.                 $product->setPackaging($prod_ws->Unim);
  488.                 $this->em->persist($product);
  489.                 $this->em->flush();
  490.             }
  492.             // Validar que los campos requeridos existan
  493.             if (!isset($fields['cantidad']) || !isset($fields['hold']) || !isset($fields['Dirección']) || !isset($fields['Ciudad'])) {
  494.                 continue;
  495.             }
  497.             $order_prod = new OrderProduct();
  498.             $order_prod->setOrder($order);
  499.             $order_prod->setProduct($product);
  500.             $order_prod->setQuantity((int)$fields['cantidad']);
  501.             $order_prod->setHold($fields['hold']);
  502.             $order_prod->setAddress($fields['Dirección']);
  503.             $order_prod->setCity($fields['Ciudad']);
  504.             $this->em->persist($order_prod);
  505.             $this->em->flush();
  506.             
  507. //            dump($order_prod);
  509.         }*/
  511.         if ($mimeType == 'text/plain') {
  512.             $base64 = base64_encode(file_get_contents($file->getPathname()));
  513.         }else{
  515.             $content = '';
  516.             foreach ($lines as $line) {
  517.                 $content .= implode("\t", $line) . "\n";
  518.             }
  520.             $base64 = base64_encode($content);
  521.         }
  524.         $send = $this->sendFileBase64($request, $order, $id_home_work, $base64/*$mimeType == 'text/plain' ? $base64 : false*/);
  526.         if ($send) {
  527.             $response = [
  528.                 "status"  => 'success',
  529.                 "message" => 'Pedido recibido correctamente',
  531.             ];
  532.         } else {
  533.             $response = [
  534.                 "status"  => 'error',
  535.                 "message" => 'No se pudo procesar el pedido',
  537.             ];
  538.         }
  540.         return $this->json($response);
  541.     }
  544.     public function sendFileBase64($request, Order $order, $task = false, $base64 = false)
  545.     {
  546.         $session        = $request->getSession();
  547.         $user_pass_hash = $session->get('user_password_hash');
  549.         $products = $this->em->getRepository(OrderProduct::class)->findBy(['order' => $order->getId()]);
  551.         $web_task_id     = self::$default_task;
  552.         $web_task_detail = [
  553.             'cod_cliente',
  554.             'producto_cod',
  555.             'Lote',
  556.             'Cant_Solicitada',
  557.             'Dirección',
  558.             'NroReferencia',
  559.         ];
  561.         if ($base64) {
  562.             $file_64 = $base64;
  564.         } else {
  565.             $data = [];
  566.             foreach ($products as $prod) {
  567.                 $tmp = [];
  569.                 foreach ($task === false ? $web_task_detail : $this->getTasksFormat($request, $task) as $field) {
  570.                     $tmp[] = $this->resolverFieldName($prod, $field);
  571.                 }
  572.                 $data[] = $tmp;
  573.             }
  575.             $content = "";
  576.             foreach ($data as $row) {
  577.                 $content .= implode("\t", $row) . "\n";
  578.             }
  580.             $file_64 = base64_encode($content);
  581.         }
  582.         
  583.         dump(base64_decode($file_64));
  584.         exit;
  587.         $send = $this->apiConsumer->getImportsTasksFile($user_pass_hash, $task === false ? '76796070-0' : $order->getAccountId(), $order->getId(), $task === false ? $web_task_id : $task, $file_64);
  589.         if ($send) {
  590.             $order->setStatus('Enviado');
  591.             $order->setWsId($send);
  592.             $this->em->persist($order);
  593.             $this->em->flush();
  595.             return true;
  596.         } else {
  597.             return false;
  598.         }
  599.     }
  602.     /**
  603.      * @Route("/data/product.json", name="data_products")
  604.      */
  605.     public function dataProductsAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  606.     {
  607.         $id = $request->query->get('id');
  609.         $session = $request->getSession();
  611.         $products = $this->apiConsumer->getclientInv($id, $session->get('user_password_hash'));
  613.         $data     = [];
  614.         $data_tmp = [];
  616.         foreach ($products as $product) {
  618.             if (rtrim($product->Tratamiento) == '') {
  619.                 $data_tmp[$product->producto_cod][] =
  620.                     [
  621.                         "producto_cod" => $product->producto_cod,
  622.                         "desc_prod"    => $product->desc_prod,
  623.                         "Unim"         => $product->Unim,
  624.                         'Lote'         => $product->Lote,
  625.                         'Disponible'   => $product->Disponible,
  626.                         'Tratamiento'  => $product->Tratamiento,
  628.                     ];
  629.             }
  632.         }
  635.         foreach ($data_tmp as $product) {
  636.             $data_lote  = [];
  637.             $total_lote = [];
  638.             foreach ($product as $lote) {
  639.                 $data_lote[]  = [
  640.                     'batch'    => $lote['Lote'],
  641.                     'quantity' => $lote['Disponible'],
  642.                 ];
  643.                 $total_lote[] = (int)$lote['Disponible'];
  644.             }
  647.             $data[] =
  648.                 [
  649.                     "id"                => $product[0]['producto_cod'],
  650.                     "name"              => $product[0]['desc_prod'],
  651.                     "stored"            => array_sum($total_lote),
  652.                     "packagingType"     => $product[0]['Unim'],
  653.                     "packagingQuantity" => null,
  654.                     'batch'             => $data_lote
  656.                 ];
  659.         }
  662.         return $this->json($data);
  663.     }
  665.     /**
  666.      * @Route("/data/inventory.json", name="data_inventory")
  667.      * @Route("/data/inventory_json", name="data_inventory2")
  668.      */
  669.     public function dataInventoryAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  670.     {
  671.         $id = $request->query->get('id');
  673.         $session = $request->getSession();
  675.         $products = $this->apiConsumer->getclientInv($id, $session->get('user_password_hash'));
  677.         $prod = [];
  679.         foreach ($products as $product) {
  681.             $prod[] =
  682.                 [
  683.                     "id"            => $product->producto_cod,
  684.                     "name"          => $product->desc_prod,
  685.                     "stored"        => $product->Total,
  686.                     "packagingType" => $product->Unim,
  687.                     "batch"         => $product->Lote,
  688.                     "Treatment"     => $product->Tratamiento,
  689.                 ];
  690.         }
  692.         $data = [
  693.             [
  694.                 'file' => $this->generateUrl('download_inventory', ['id' => $id]),
  695.                 'data' => $prod,
  696.             ]
  697.         ];
  700.         return $this->json($data);
  701.     }
  703.     /**
  704.      * @Route("/download/inventory", name="download_inventory")
  705.      */
  706.     public function downloadInventoryAction(Request $request): StreamedResponse
  707.     {
  709.         $id = $request->query->get('id');
  711.         $session = $request->getSession();
  713.         $products = $this->apiConsumer->getclientInv($id, $session->get('user_password_hash'));
  715.         $spreadsheet = new Spreadsheet();
  716.         $sheet       = $spreadsheet->getActiveSheet();
  718.         $sheet->setCellValue('A1', 'ID Producto');
  719.         $sheet->setCellValue('B1', 'Nombre');
  720.         $sheet->setCellValue('C1', 'Lote');
  721.         $sheet->setCellValue('D1', 'Tratamiento');
  722.         $sheet->setCellValue('E1', 'Disponible');
  723.         $sheet->setCellValue('F1', 'Reservado');
  724.         $sheet->setCellValue('G1', 'En despacho');
  725.         $sheet->setCellValue('H1', 'En Preparación');
  726.         $sheet->setCellValue('I1', 'Merma');
  727.         $sheet->setCellValue('J1', 'Total');
  728.         $sheet->setCellValue('K1', 'Embalaje');
  731.         $row = 2;
  732.         foreach ($products as $item) {
  733.             $sheet->setCellValue('A' . $row, $item->producto_cod);
  734.             $sheet->setCellValue('B' . $row, $item->desc_prod);
  735.             $sheet->setCellValue('C' . $row, $item->Lote);
  736.             $sheet->setCellValue('D' . $row, $item->Tratamiento);
  737.             $sheet->setCellValue('E' . $row, $item->Disponible);
  738.             $sheet->setCellValue('F' . $row, $item->Reservado);
  739.             $sheet->setCellValue('G' . $row, $item->En_Despacho);
  740.             $sheet->setCellValue('H' . $row, $item->En_Preparación);
  741.             $sheet->setCellValue('I' . $row, $item->Merma);
  742.             $sheet->setCellValue('J' . $row, $item->Total);
  743.             $sheet->setCellValue('K' . $row, $item->Unim);
  744.             $row++;
  745.         }
  747.         $response = new StreamedResponse(function () use ($spreadsheet) {
  748.             $writer = new Xlsx($spreadsheet);
  749.             $writer->save('php://output');
  750.         });
  752.         // Configurar las cabeceras de la respuesta
  753.         $response->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
  754.         $response->headers->set('Content-Disposition', 'attachment;filename="inventario_' . date('d/m/Y H:i:s') . '.xlsx"');
  755.         $response->headers->set('Cache-Control', 'max-age=0');
  757.         return $response;
  758.     }
  760.     /**
  761.      * @Route("/data/account.json", name="data_account")
  762.      */
  763.     public function dataAccountAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  764.     {
  765.         $session = $request->getSession();
  767.         $accounts = $this->apiConsumer->getclientList($session->get('user_password_hash'));
  769.         $data = [];
  771.         foreach ($accounts as $account) {
  773.             $data[] =
  774.                 [
  775.                     "id"      => $account->cod_cliente,
  776.                     "account" => $account->cliente_nombre,
  777.                 ];
  780.         }
  782.         return $this->json($data);
  783.     }
  785.     /**
  786.      * @Route("/data/user.json", name="data_users")
  787.      * @Route("/data/users_json", name="data_user2")
  788.      */
  789.     public function dataUserAction(Request $request, SonataUserUserRepository $userRepository)
  790.     {
  791.         $session = $request->getSession();
  793.         $user = $userRepository->findOneBy(['user_pass_hash' => $session->get('user_password_hash')]);
  795.         $account = $this->apiConsumer->getclientList($session->get('user_password_hash'))[0] ?? null;
  797. //        $validate = $this->apiConsumer->getClienteValidar($session->get('user_password_hash'))[0] ?? null;
  799.         $data =
  800.             [
  801.                 "id"           => $user->getId(),
  802.                 "name"         => /*$validate->Modulo_Name*/'',
  803.                 "token"        => $session->get('user_password_hash'),
  804.                 "year"         => 1900,
  805.                 "bill"         => true,
  806.                 "accountId"    => $account->cod_cliente,
  807.                 "userMsj"      => "",
  808.                 "adminMsj"     => "",
  809.                 "modalContent" => ('Para armar el archivo de texto, crea filas con los datos separados por tabuladores y cada registro en una nueva línea, en el siguiente orden: Código de Cliente, Código de Producto, Fecha, Código, Cantidad y Tipo de embalaje.'),
  810.                 'exampleFile'  => '',
  811.                 'example'      => [
  812.                     $this->getTasksFormat($request, null, true)
  813.                 ]
  814.             ];
  817.         return $this->json($data);
  818.     }
  820.     private function getTasks($cod_client, $user_pass_hash)
  821.     {
  822. //        return $this->apiConsumer->getImportsTasksFormats('5178', $user_pass_hash) ?? null;
  823.         return $this->apiConsumer->getImportsTasksList($cod_client, $user_pass_hash)[0] ?? null;
  824.     }
  826.     private function getTasksFormat(Request $request, $task_id = null, $ucfirst = false): array
  827.     {
  828.         $session        = $request->getSession();
  829.         $user_pass_hash = $session->get('user_password_hash');
  831.         if ($task_id == null) {
  832.             $task_id = self::$default_task;
  833.         }
  835.         $tasks_format = $this->apiConsumer->getImportsTasksFormats($task_id, $user_pass_hash) ?? null;
  837.         $tasks_ar = [];
  839.         foreach ($tasks_format as $item) {
  840.             $tasks_ar[(int)$item->Posicion - 1] = $ucfirst ? ucfirst($item->Descripcion) : $item->Descripcion;
  841.         }
  843.         ksort($tasks_ar);
  845.         return $tasks_ar;
  846.     }
  848.     private function resolverFieldName(OrderProduct $product, $field): bool|int|string|null
  849.     {
  850.         return match (ltrim($field)) {
  851.             'fecha' => date('d/m/Y'),
  852.             'cod_cliente' => $product->getOrder()->getAccountId(),
  853.             'hold' => $product->getHold(),
  854.             'Ciudad' => $product->getCity(),
  855.             'producto', 'producto_cod' => $product->getProduct()->getProductId(),
  856.             'cantidad', 'Cant_Solicitada' => $product->getQuantity(),
  857.             'lot', 'Lote' => $product->getBatch() != 0 ? $product->getBatch() : '*',
  858.             'Dirección' => $product->getOrder()->getContactAddress() ?: $product->getAddress(),
  859.             'NroReferencia' => $product->getOrder()->getId(),
  860.             default => false,
  861.         };
  862.     }
  864.     private function setFieldName(OrderProduct $product, $field)
  865.     {
  866.         switch ($field) {
  867.             case'fecha':
  868.                 return date('d/m/Y');
  869.             case'producto':
  870.                 return $product->getProduct()->getProductId();
  871.             case'cantidad':
  872.                 return $product->getQuantity();
  873.             case'lot':
  874.                 return '*';
  875.             default;
  876.         }
  877.     }
  879.     #[Route('/download-example/{task_id}', name: 'download_example')]
  880.     public function downloadExampleTxt(Request $request, $task_id): Response
  881.     {
  882.         $session = $request->getSession();
  884. //        $tasks_ws = $this->apiConsumer->getImportsTasksFormats($task_id, $session->get('user_password_hash'));
  885.         $tasks_ws = $this->getTasksFormat($request, $task_id);
  887.         $fields = [];
  889.         foreach ($tasks_ws as $tasks_w) {
  890.             $fields[] = $this->correctWorks($tasks_w, true);
  891.         }
  893.         $content = "";
  895.         foreach ([$fields] as $row) {
  896.             $content .= implode("\t", $row) . "\n";
  897.         }
  900.         // Crear la respuesta con encabezados adecuados
  901.         $response = new Response($content);
  903.         $response->headers->set('Content-Type', 'text/plain');
  904.         $response->headers->set('Content-Disposition', 'attachment; filename="ejemplo_pedido.txt"');
  905.         $response->headers->set('Content-Length', strlen($content));
  907.         return $response;
  908.     }
  910.     #[Route('/download-example-xls/{task_id}', name: 'download_example_xls')]
  911.     public function downloadExampleXls(Request $request, $task_id): Response
  912.     {
  913.         $session = $request->getSession();
  915. //        $tasks_ws = $this->apiConsumer->getImportsTasksFormats($task_id, $session->get('user_password_hash'));
  916.         $tasks_ws = $this->getTasksFormat($request, $task_id);
  918.         $fields = [];
  921.         foreach ($tasks_ws as $tasks_w) {
  922.             $fields[] = $this->correctWorks($tasks_w, true);
  923.         }
  926.         $spreadsheet = new Spreadsheet();
  927.         $sheet       = $spreadsheet->getActiveSheet();
  929.         $letras = range('A', 'Z');
  930.         foreach ($fields as $index => $field) {
  931.             $sheet->setCellValue($letras[$index] . '1', $field);
  932.         }
  935.         $response = new StreamedResponse(function () use ($spreadsheet) {
  936.             $writer = new Xlsx($spreadsheet);
  937.             $writer->save('php://output');
  938.         });
  940.         $response->headers->set('Content-Type', 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
  941.         $response->headers->set('Content-Disposition', 'attachment;filename="ejemplo_archivo' . '.xlsx"');
  942.         $response->headers->set('Cache-Control', 'max-age=0');
  944.         return $response;
  945.     }
  947.     /**
  948.      * @Route("/data/tracing.json", name="data_tracing")
  949.      * @Route("/data/tracing_json", name="data_tracing2")
  950.      */
  951.     public function dataTracingAction(Request $request, OrderRepository $orderRepository): \Symfony\Component\HttpFoundation\JsonResponse
  952.     {
  953.         $session = $request->getSession();
  955.         $hash = $session->get('user_password_hash');
  957.         $id_client = $request->query->get('id');
  959.         $tracing = $this->apiConsumer->getPedidoSeguimiento($id_client, $hash);
  961.         $data = [];
  963.         foreach ($tracing as $item) {
  965.             $data[] =
  966.                 [
  967.                     "id"           => $item->ob_oid,
  968.                     "date"         => $item->Crea_date,
  969.                     "orderId"      => $item->ob_oid,
  970.                     "create_date"  => $item->Crea_date,
  971.                     "status"       => $item->Estado,
  972.                     "guide_number" => $item->num_guia_despacho,
  973.                     "cita"         => $item->Cita,
  974.                     "fecha_cita"   => $item->Fecha_Cita,
  975.                 ];
  977.         }
  979.         return $this->json($data);
  980.     }
  982.     /**
  983.      * @Route("/data/order.json", name="data_order")
  984.      * @Route("/data/order_json", name="data_order2")
  985.      */
  986.     public function dataOrderAction(Request $request, OrderRepository $orderRepository): \Symfony\Component\HttpFoundation\JsonResponse
  987.     {
  988.         $session = $request->getSession();
  990.         $hash = $session->get('user_password_hash');
  992.         $order_id  = $request->query->get('id');
  993.         $branch_id = $request->query->get('branchId');
  995.         $orders = $orderRepository->findOneBy(['ws_id' => $order_id]);
  997.         $tracings = $this->apiConsumer->getPedidoSeguimiento($branch_id, $hash);
  999.         $tracings_prods = $this->apiConsumer->getPedidoSeguimientoDetalle($branch_id, $order_id, $hash);
  1001.         $products = [];
  1003.         if ($tracings_prods) {
  1004.             foreach ($tracings_prods as $product) {
  1005.                 $products[] = [
  1006.                     'id'                  => $product->producto_cod,
  1007.                     'name'                => $product->desc_prod,
  1008.                     'quantity'            => (int)$product->Cant_Solicitada,
  1009.                     'quantity_processed'  => (int)$product->Cant_en_Proceso,
  1010.                     'quantity_dispatched' => (int)$product->Cant_Despachada,
  1011.                     'batch'               => $product->Lote ?: 'Sin lote',
  1012.                     'status'              => $product->Estado,
  1013.                 ];
  1014.             }
  1015.         }
  1018.         $data_ws = [];
  1019.         foreach ($tracings as $tracing) {
  1020. //            if ($tracing->ob_oid == $order_id) {
  1021.                 $data_ws = [
  1022.                     'Crea_date'         => $tracing->Crea_date,
  1023.                     'ob_oid'            => $tracing->ob_oid,
  1024.                     'Tipo'              => $tracing->Tipo,
  1025.                     'num_guia_despacho' => $tracing->num_guia_despacho,
  1026.                     'Productos'         => $tracing->Productos,
  1027.                     'Lineas'            => $tracing->Lineas,
  1028.                     'Cant_Solicitada'   => $tracing->Cant_Solicitada,
  1029.                     'Cant_Despachada'   => $tracing->Cant_Despachada,
  1030.                     'Estado'            => $tracing->Estado,
  1031.                     'Cita'              => $tracing->Cita,
  1032.                     'Fecha_Cita'        => $tracing->Fecha_Cita,
  1033.                     'Hora_Cita'         => $tracing->Hora_Cita,
  1034.                     'Boleto'            => $tracing->Boleto,
  1035.                     'Hora_Presentacion' => $tracing->Hora_Presentacion,
  1036.                     'Hora_Ingreso'      => $tracing->Hora_Ingreso,
  1037.                     'Hora_Salida'       => $tracing->Hora_Salida,
  1038.                 ];
  1039. //            }
  1040.         }
  1043.         $data = [];
  1046.         $data[] =
  1047.             [
  1048.                 "id"                => $data_ws['ob_oid'],
  1049.                 "date"              => $data_ws['Crea_date'],
  1050.                 "Tipo"              => $data_ws['Tipo'],
  1051.                 "num_guia_despacho" => $data_ws['num_guia_despacho'],
  1052.                 "Productos"         => $data_ws['Productos'],
  1053.                 "Lineas"            => $data_ws['Lineas'],
  1054.                 "Cant_Solicitada"   => $data_ws['Cant_Solicitada'],
  1055.                 "Cant_Despachada"   => $data_ws['Cant_Despachada'],
  1056.                 "Cita"              => $data_ws['Cita'],
  1057.                 "Fecha_Cita"        => $data_ws['Fecha_Cita'],
  1058.                 "Hora_Cita"         => $data_ws['Hora_Cita'],
  1059.                 "status"            => $data_ws['Estado'],
  1060.                 "statusMsg"         => $data_ws['Estado'],
  1061.                 "products"          => $products,
  1062.             ];
  1064.         return $this->json($data);
  1065.     }
  1067.     /**
  1068.      * @Route("/data/bill.json", name="data_bill")
  1069.      * @Route("/data/bill_json", name="data_bill2")
  1070.      */
  1071.     public function dataBillAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  1072.     {
  1073.         $session = $request->getSession();
  1075.         $id_client = $request->query->get('id');
  1077.         $bills = $this->apiConsumer->getFacturaResumen($session->get('user_password_hash'));
  1080.         $data = [];
  1082.         foreach ($bills as $item) {
  1083.             $fecha = new \DateTime($item->F_Emis);
  1085.             $data[] =
  1086.                 [
  1087.                     "id"            => $item->Factura,
  1088.                     "date"          => $fecha->format('d/m/Y'),
  1089.                     //                    "n_credito"     => $item->N_Credito ,
  1090.                     "nota_venta"    => $item->NotaVenta,
  1091.                     "cotizacion"    => $item->cotizacion,
  1092.                     "f_impt"        => $item->F_Impt,
  1093.                     "f_emis"        => $item->F_Emis,
  1094.                     "f_venc"        => $item->F_Venc,
  1095.                     "rut_recep"     => $item->RutRecep,
  1096.                     "id_erp"        => $item->id_erp,
  1097.                     "rzn_soc_recep" => $item->RznSocRecep,
  1098.                     "lineas"        => $item->Lineas,
  1099.                     "cve_des"       => $item->CveDes,
  1100.                     "venta_item"    => $this->moneyFormat($item->Venta_Item),
  1101.                     "desc"          => $this->moneyFormat($item->Desc),
  1102.                     "mnt_exe"       => $this->moneyFormat($item->MntExe),
  1103.                     "neto"          => $this->moneyFormat($item->Neto),
  1104.                     "iva"           => $this->moneyFormat($item->IVA),
  1105.                     "total"         => $this->moneyFormat($item->Total),
  1106.                     "pendiente"     => $this->moneyFormat($item->Pendiente),
  1107.                     "estado"        => $item->Estado,
  1108.                     "dias_vencido"  => $item->Dias_Vencido,
  1109.                     "file"          => $this->generateUrl('data_bill_pdf', ['folio' => $item->Factura]),
  1110.                 ];
  1113.         }
  1115.         usort($data, function ($a, $b) {
  1116.             $dateA = DateTime::createFromFormat('d/m/Y', $a['date']);
  1117.             $dateB = DateTime::createFromFormat('d/m/Y', $b['date']);
  1118.             return $dateB <=> $dateA; // Orden ascendente
  1119.         });
  1122.         return $this->json($data);
  1123.     }
  1125.     private function moneyFormat($value)
  1126.     {
  1127.         return '$' . number_format((int)$value, 0, null, '.');
  1128.     }
  1130.     /**
  1131.      * @Route("/data/bill_pdf/{folio}", name="data_bill_pdf")
  1132.      */
  1133.     public function getFacturaFile(Request $request, $folio)
  1134.     {
  1135.         $session = $request->getSession();
  1137.         $id_client = $request->query->get('id');
  1138.         $id_client = $request->query->get('id');
  1140.         $pdf_64 = $this->apiConsumer->getFacturaPDF($session->get('user_password_hash'), $folio);
  1143.         $pdfContent = base64_decode($pdf_64);
  1146.         if ($pdfContent === false) {
  1147.             return new Response("Error al decodificar el PDF.", Response::HTTP_INTERNAL_SERVER_ERROR);
  1148.         }
  1150.         // Retornar el PDF directamente en la respuesta HTTP
  1151.         return new Response($pdfContent, 200, [
  1152.             'Content-Type'        => 'application/pdf',
  1153.             'Content-Disposition' => 'inline; filename="factura-' . $folio . '.pdf"',
  1154.         ]);
  1155.     }
  1157.     /**
  1158.      * @Route("/data/report.json", name="data_report")
  1159.      * @Route("/data/report_json", name="data_report2")
  1160.      */
  1161.     public function dataReportAction(Request $request): \Symfony\Component\HttpFoundation\JsonResponse
  1162.     {
  1163.         $session = $request->getSession();
  1165.         $id_client = $request->query->get('id');
  1168.         $report = $this->apiConsumer->getPowerBIList($session->get('user_password_hash'));
  1170.         $data = [];
  1172.         foreach ($report as $item) {
  1174.             $data[] =
  1175.                 [
  1176.                     "id_registro"   => $item->id_registro,
  1177.                     "create_date"   => $item->crea_date,
  1178.                     "create_oper"   => $item->crea_oper,
  1179.                     "id_usuario"    => $item->id_usuario,
  1180.                     "Descripc"      => $item->Descripc,
  1181.                     "Estado"        => $item->Estado,
  1182.                     "URLs"          => $item->URLs,
  1183.                     "OrderBy"       => $item->OrdenBy,
  1184.                     "Intervalo"     => $item->Intervalo,
  1185.                     "URLsParametro" => $item->URLsParametro,
  1186.                 ];
  1189.         }
  1191.         return $this->json($data);
  1192.     }
  1193. }