src/Controller/ModComercio/Ventas/PedidosController.php line 43

Open in your IDE?
  1. <?php
  2. namespace App\Controller\ModComercio\Ventas;
  4. use App\Controller\ModComercio\GestionCarta\ComponentesController;
  5. use App\Entity\Catalogos\EstadoCuenta;
  6. use App\Entity\Comercio\{ConsumoInsumosOrdenMenu, ControlComponente, Cuenta, OrdenMenu, DatosComercio, OrdenMenuAcompanamiento, Reserva, ReservaOrdenMenu};
  7. use App\Entity\Producto\{Acompanamiento, ComponenteInsumo, Insumos, Menu, MenuComponentes, MenuPreciosHistorial};
  8. use App\Service\CacheService;
  9. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  10. use Symfony\Component\Routing\Annotation\Route;
  11. use Doctrine\ORM\EntityManagerInterface;
  12. use Exception;
  13. use PhpOffice\PhpSpreadsheet\Spreadsheet;
  14. use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
  15. use Symfony\Component\HttpFoundation\Request;
  16. use Symfony\Component\HttpFoundation\ResponseHeaderBag;
  17. use Symfony\Component\Security\Core\User\UserInterface;
  19. class PedidosController extends AbstractController {
  20.   private $em;
  21.   private $msgCreate;
  22.   private $msgUpdate;
  23.   private $msgDelete;
  24.   private $msgNotCreate;
  25.   private $datosComercio;
  26.   private $cache;
  28.   public function __construct(EntityManagerInterface $em, CacheService $cache) {
  29.     date_default_timezone_set('America/Guayaquil');
  30.     $this->em = $em;
  31.     $this->msgCreate = "Registro creado exitosamente.";
  32.     $this->msgUpdate = "Registro actualizado exitosamente.";
  33.     $this->msgDelete = "Registro eliminado exitosamente.";
  34.     $this->msgNotCreate = "La cuenta seleccionada está inactiva o ha alcanzado el límite de pedidos permitidos.";
  35.     $this->datosComercio = $em->getRepository(DatosComercio::class)->find(1);
  36.     $this->cache = $cache;
  37.   }
  39.   // * READ FUNCTIONS *
  40.     /**
  41.      * @Route("/getInitialPedidos", name="getInitialPedidos")
  42.      */
  43.     public function getInitialPedidos(Request $request) {
  44.       $this->cache->delete('excelListPedidos');
  45.       $idCuenta = $request->request->get('idCuenta');
  46.       $qb = $this->em->createQueryBuilder();
  47.       $datosComercio = $this->em->getRepository(DatosComercio::class)->find(1);
  48.       $iva = $datosComercio->getIdPorcentajeIva()->getPorcentaje();
  49.       $qb->select('o')
  50.         ->from(OrdenMenu::class, 'o')
  51.         ->leftJoin('o.idMenu', 'm')
  52.         ->addSelect('m')
  53.         ->where('o.idCuenta = :idCuenta')
  54.         ->setParameter('idCuenta', $idCuenta)
  55.         ->orderBy('o.id', 'DESC');
  57.       $pedidos = $qb->getQuery()->getResult();
  58.       $list = $this->setArrayPedidos($pedidos, $iva);
  59.       $this->cache->add('excelListPedidos', $list);
  60.       return $this->json(['data' => $list], 200);
  61.     }
  63.     private function setArrayPedidos($pedidos, $iva) {
  64.       $list = [];
  65.       if ($pedidos) {
  66.         $actionEntregarCancelar = false;
  67.         $actionEliminar = false;
  68.         foreach ($pedidos as $indice => $pedido) {
  69.           $actionEntregarCancelar = $pedido->getEstado() == "Entregado" || $pedido->getEstado() == "Cancelado" || $pedido->getEstado() == "Reservado" ? false : true;
  70.           $actionEliminar = $pedido->getEstado() == "Entregado" || $pedido->getEstado() == "Cancelado" ? false : true;
  71.           $menu = $pedido->getIdMenu();
  72.           $valIva = doubleval(($pedido->getPrecioUnitarioMenu() * $iva) / 100);
  73.           $total = doubleval($valIva + $pedido->getPrecioUnitarioMenu()) * $pedido->getCantidad();
  74.           array_push($list, [
  75.             'indice' => $indice + 1,
  76.             'id' => $pedido->getId(),
  77.             'cantidad' => $pedido->getCantidad(),
  78.             'cortesia' => $pedido->getCortesia(),
  79.             'fechaHoraPedido' => $pedido->getFechaHoraPedidoString(),
  80.             'fechaHoraEntrega' => $pedido->getFechaHoraEntregaString(),
  81.             'estado' => $pedido->getEstado(),
  82.             'nombre' => $menu->getNombre(),
  83.             'pu' => doubleval($valIva + $pedido->getPrecioUnitarioMenu()),
  84.             'total' => $total,
  85.             'actionEntregarCancelar' => $actionEntregarCancelar,
  86.             'actionEliminar' => $actionEliminar
  87.           ]);
  88.         }
  89.       }
  91.       return $list;
  92.     }
  94.   // * CREATE OR UPDATE FUNCTIONS *
  95.     /**
  96.      * @Route("/setOrdenCuenta", name="setOrdenCuenta")
  97.      */
  98.     public function setOrdenCuenta(UserInterface $user, Request $request) {
  99.       try {
  100.         $data = $request->request->get('data');
  101.         $jsonAcompanamiento = json_decode($data['json'], true);
  102.         $cuenta = $this->getCuenta($data['idCuenta']);
  103.         $isReserva = $this->getReserva($data['idCuenta']);
  104.         if (!$cuenta || !$this->isCuentaActiva($cuenta, $isReserva)) :
  105.           return $this->json(['response' => false, 'message' => $this->msgNotCreate]);
  106.         endif;
  107.         if ($isReserva) :
  108.           $reserva = $this->handleReserva($data, $user, $cuenta, $isReserva, $this->datosComercio, $jsonAcompanamiento);
  109.           return $this->json($reserva, 200);
  110.         endif;
  111.         $menu = $this->em->getRepository(Menu::class)->find($data['idMenu']);
  112.         $menuComponentes = $this->getMenuComponentes($data['idMenu']);
  113.         if ($menu->getAcompanamiento()) :
  114.           $acompanamiento = $this->em->getRepository(Acompanamiento::class)->findBy(['idMenu' => $data['idMenu']]);
  115.           $resultado = $this->filtrarComponentesNoUsados($acompanamiento, $menuComponentes);
  116.           $ingredientesFaltantes = $this->checkInsumosDisponibles($resultado, $data['cantidad']);
  117.           if ($ingredientesFaltantes) :
  118.             return $this->json([
  119.               'response' => false,
  120.               'stock' => true,
  121.               'ingredientes' => $this->renderInsumosFaltantes($ingredientesFaltantes)
  122.             ]);
  123.           endif;
  124.           $jsonComponentes = $this->jsonAcompanamientoFilter($jsonAcompanamiento);
  125.           $ingredientesFaltantesDos = $this->checkInsumosDisponiblesAcompanamiento($jsonComponentes, $data['cantidad'], count($jsonAcompanamiento));
  126.           if ($ingredientesFaltantesDos) :
  127.             return $this->json([
  128.               'response' => false,
  129.               'stock' => true,
  130.               'ingredientes' => $this->renderInsumosFaltantes($ingredientesFaltantes)
  131.             ]);
  132.           endif;
  133.           return $this->handleOrdenMenu($data, $user, $cuenta, $this->datosComercio, $menu->getAcompanamiento(), $jsonAcompanamiento);
  134.         else:
  135.           $ingredientesFaltantes = $this->checkInsumosDisponibles($menuComponentes, $data['cantidad']);
  136.           if ($ingredientesFaltantes) :
  137.             return $this->json([
  138.               'response' => false,
  139.               'stock' => true,
  140.               'ingredientes' => $this->renderInsumosFaltantes($ingredientesFaltantes)
  141.             ]);
  142.           endif;
  143.           return $this->handleOrdenMenu($data, $user, $cuenta, $this->datosComercio, $menu->getAcompanamiento());
  144.         endif;
  145.       } catch (Exception $e) {
  146.         return $this->json(['response' => false, 'message' => "<b>{$e->getMessage()}</b> error al realizar el registro dentro de la petición <i>setOrdenCuenta</i>", 'stock' => false]);
  147.       }
  148.     }
  150.     function filtrarComponentesNoUsados($primerArreglo, $segundoArreglo) {
  151.       $idsUsados = array_map(function ($item) {
  152.         return $item->getIdMenuComponentes()->getId();
  153.       }, $primerArreglo);
  154.       $resultado = array_filter($segundoArreglo, function ($componente) use ($idsUsados) {
  155.         return !in_array($componente->getId(), $idsUsados);
  156.       });
  157.       return array_values($resultado);
  158.     }
  160.     function filtrarComponentesNoUsadosDos($primerArreglo, $segundoArreglo, $ordenMenuACompanamiento) {
  161.       $idsUsados = array_map(function ($item) {
  162.         return $item->getIdMenuComponentes()->getId();
  163.       }, $primerArreglo);
  164.       $resultado = array_filter($segundoArreglo, function ($componente) use ($idsUsados) {
  165.         return !in_array($componente->getId(), $idsUsados);
  166.       });
  167.       return array_values($resultado);
  168.     }
  170.     function jsonAcompanamientoFilter($jsonAcompanamiento) {
  171.       $resultado = [];
  172.       foreach ($jsonAcompanamiento as $item) {
  173.         $acompanamiento = $this->em->getRepository(Acompanamiento::class)->find($item['id']);
  174.         $resultado[] = $acompanamiento->getIdMenuComponentes();
  175.       }
  176.       return array_values($resultado);
  177.     }
  179.     function jsonAcompanamientoFilterDos($ordenMenuACompanamiento) {
  180.       $resultado = [];
  181.       foreach ($ordenMenuACompanamiento as $item) {
  182.         $resultado[] = $item->getIdAcompanamiento()->getIdMenuComponentes();
  183.       }
  184.       return array_values($resultado);
  185.     }
  187.     private function getCuenta($idCuenta) {
  188.       return $this->em->getRepository(Cuenta::class)->find($idCuenta);
  189.     }
  191.     private function getReserva($idCuenta) {
  192.       return $this->em->getRepository(Reserva::class)->findOneBy(['idCuenta' => $idCuenta]);
  193.     }
  195.     private function isCuentaActiva($cuenta, $isReserva) {
  196.       return ($cuenta && $cuenta->getActiva() && !$isReserva) || ($isReserva && !$cuenta->getActiva());
  197.     }
  199.     private function handleReserva($data, $user, $cuenta, $isReserva, $datosComercio, $jsonAcompanamiento) {
  200.       $ordenMenu = new OrdenMenu;
  201.       $ordenMenu = $this->setOrdenMenu($ordenMenu, $data, 'Reservado', $cuenta, $user, $datosComercio);
  202.       $this->em->persist($ordenMenu);
  203.       $menu = $this->em->getRepository(Menu::class)->find($data['idMenu']);
  204.       if ($menu->getAcompanamiento()) :
  205.         foreach ($jsonAcompanamiento as $acompanamiento) {
  206.           $ordenMenuACompanamiento = new OrdenMenuAcompanamiento;
  207.           $ordenMenuACompanamiento
  208.             ->setIdOrdenMenu($ordenMenu)
  209.             ->setIdAcompanamiento($this->em->getRepository(Acompanamiento::class)->find($acompanamiento['id']))
  210.           ;
  211.           $ordenMenuACompanamiento = $this->setGenericData($user, $ordenMenuACompanamiento);
  212.           $this->em->persist($ordenMenuACompanamiento);
  213.         }
  214.       endif;
  215.       $reservaOrdenMenu = new ReservaOrdenMenu;
  216.       $reservaOrdenMenu = $this->setReservaOrdenMenu($reservaOrdenMenu, $ordenMenu, $isReserva, $user);
  217.       $this->em->persist($reservaOrdenMenu);
  218.       $this->em->flush();
  219.       return ['response' => true, 'message' => $this->msgCreate, 'ordenMenuReserva' => $reservaOrdenMenu];
  220.     }
  222.     private function setOrdenMenu($ordenMenu, $data, $estadoReserva, $cuenta, $user, $datosComercio) {
  223.       $menu = $this->em->getRepository(Menu::class)->find($data['idMenu']);
  224.       $costo = $this->getCostoMenu($menu);
  225.       $ordenMenu
  226.         ->setCantidad($data['cantidad'])
  227.         ->setCortesia(false)
  228.         ->setModificarStock(false)
  229.         ->setFechaHoraPedido(new \DateTime())
  230.         ->setEstado($estadoReserva)
  231.         ->setIdMenu($menu)
  232.         ->setIdCuenta($cuenta)
  233.         ->setPrecioUnitarioMenu($menu->getPrecio())
  234.         ->setPrecioCosto($costo)
  235.         ->setIdPorcentajeIva($datosComercio->getIdPorcentajeIva())
  236.       ;
  237.       $ordenMenu = $this->setGenericData($user, $ordenMenu);
  239.       return $ordenMenu;
  240.     }
  242.     private function setReservaOrdenMenu($reservaOrdenMenu, $ordenMenu, $isReserva, $user) {
  243.       $reservaOrdenMenu
  244.         ->setIdOrdenMenu($ordenMenu)
  245.         ->setIdReserva($isReserva)
  246.       ;
  247.       $reservaOrdenMenu = $this->setGenericData($user, $reservaOrdenMenu);
  248.       return $reservaOrdenMenu;
  249.     }
  251.     private function getCostoMenu($menu) {
  252.       $menuComponentes = $this->em->getRepository(MenuComponentes::class)->findBy(['idMenu' => $menu->getId()]);
  253.       return array_reduce($menuComponentes, function ($costo, $menuComponente) {
  254.         return $costo + (new ComponentesController($this->em, $this->cache))->getCostoComponente($menuComponente);
  255.       }, 0.0);
  256.     }
  258.     private function getMenuComponentes($idMenu) {
  259.       return $this->em->getRepository(MenuComponentes::class)->findBy(['idMenu' => $idMenu]);
  260.     }
  262.     private function checkInsumosDisponiblesAcompanamiento($menuComponentes, $cantidad, $nro_acompanamiento) {
  263.       $ingredientesFaltantes = [];
  264.       foreach ($menuComponentes as $menuComponente) {
  265.         $menu_componente_cantidad = floatval($menuComponente->getCantidad());
  266.         $componenteInsumos = $this->em->getRepository(ComponenteInsumo::class)->findBy(['idComponentes' => $menuComponente->getIdComponentes()->getId()]);
  267.         foreach ($componenteInsumos as $componenteInsumo) {
  268.           $componente_insumo_cantidad = floatval($componenteInsumo->getCantidad());
  269.           $cantidad_requerida = (($componente_insumo_cantidad / intval($nro_acompanamiento)) * $menu_componente_cantidad) * intval($cantidad);
  270.           if (floatval($cantidad_requerida) > $componenteInsumo->getIdInsumos()->getStock()) :
  271.             $cantidadFaltante = floatval($cantidad_requerida) - floatval($componenteInsumo->getIdInsumos()->getStock());
  272.             $abreviaturaUnidad = $this->getAbreviaturaUnidad($componenteInsumo->getIdInsumos()->getIdUnidadesInsumos()->getNombre());
  273.             $ingredientesFaltantes[] = [
  274.               'insumo' => $componenteInsumo->getIdInsumos()->getNombre(),
  275.               'cantidadFaltante' => $cantidadFaltante,
  276.               'abreviaturaUnidad' => $abreviaturaUnidad
  277.             ];
  278.           endif;
  279.         }
  280.       }
  281.       return $ingredientesFaltantes;
  282.     }
  284.     private function checkInsumosDisponibles($menuComponentes, $cantidad) {
  285.       $ingredientesFaltantes = [];
  286.       foreach ($menuComponentes as $menuComponente) {
  287.         $cantidadComponente = floatval($menuComponente->getCantidad());
  288.         $componenteInsumos = $this->em->getRepository(ComponenteInsumo::class)->findBy(['idComponentes' => $menuComponente->getIdComponentes()->getId()]);
  289.         foreach ($componenteInsumos as $componenteInsumo) {
  290.           $cantidadInsumoComponente = floatval($componenteInsumo->getCantidad());
  291.           $cantidadRequeridaOrden = $cantidadComponente * floatval($cantidadInsumoComponente * $cantidad);
  292.           if (floatval($cantidadRequeridaOrden) > $componenteInsumo->getIdInsumos()->getStock()) :
  293.             $cantidadFaltante = floatval($cantidadRequeridaOrden) - floatval($componenteInsumo->getIdInsumos()->getStock());
  294.             $abreviaturaUnidad = $this->getAbreviaturaUnidad($componenteInsumo->getIdInsumos()->getIdUnidadesInsumos()->getNombre());
  295.             $ingredientesFaltantes[] = [
  296.               'insumo' => $componenteInsumo->getIdInsumos()->getNombre(),
  297.               'cantidadFaltante' => $cantidadFaltante,
  298.               'abreviaturaUnidad' => $abreviaturaUnidad
  299.             ];
  300.           endif;
  301.         }
  302.       }
  303.       return $ingredientesFaltantes;
  304.     }
  306.     private function getAbreviaturaUnidad($nombre) {
  307.       $abreviaturas = [
  308.         'LIBRAS' => 'lbs',
  309.         'UNIDADES' => 'uds',
  310.         'LITROS' => 'l',
  311.         'MILILITROS' => 'ml',
  312.         'FUNDAS' => 'f',
  313.       ];
  314.       return $abreviaturas[$nombre] ?? 'gr';
  315.     }
  317.     private function renderInsumosFaltantes($ingredientesFaltantes) {
  318.       $html = '<ul class="list-group">';
  319.       foreach ($ingredientesFaltantes as $ingrediente) {
  320.         $html .= '<li class="list-group-item d-flex justify-content-between align-items-center" style="padding: .15rem 1.25rem;">';
  321.         $html .= $ingrediente['insumo'];
  322.         $html .= '<span class="badge bg-primary rounded-pill">';
  323.         $html .= $ingrediente['cantidadFaltante'] . $ingrediente['abreviaturaUnidad'];
  324.         $html .= '</span>';
  325.         $html .= '</li>';
  326.       }
  327.       $html .= '</ul>';
  328.       return $html;
  329.     }
  331.     private function handleOrdenMenu($data, $user, $cuenta, $datosComercio, $acompanamiento, $jsonAcompanamiento = []) {
  332.       $ordenMenu = new OrdenMenu();
  333.       $ordenMenu = $this->setOrdenMenu($ordenMenu, $data, 'Confirmado', $cuenta, $user, $datosComercio);
  334.       $this->em->persist($ordenMenu);
  335.       if ($acompanamiento) :
  336.         foreach ($jsonAcompanamiento as $item) {
  337.           $ordenMenuACompanamiento = new OrdenMenuAcompanamiento;
  338.           $ordenMenuACompanamiento
  339.             ->setIdOrdenMenu($ordenMenu)
  340.             ->setIdAcompanamiento($this->em->getRepository(Acompanamiento::class)->find($item['id']))
  341.           ;
  342.           $ordenMenuACompanamiento = $this->setGenericData($user, $ordenMenuACompanamiento);
  343.           $this->em->persist($ordenMenuACompanamiento);
  344.         }
  345.       endif;
  346.       $veryMenuPrecio = $this->em->getRepository(MenuPreciosHistorial::class)->findOneBy(['idMenu' => $ordenMenu->getIdMenu()->getId()], ['fecha' => 'DESC']);
  347.       if (!$veryMenuPrecio || $this->isPrecioDiferente($ordenMenu, $veryMenuPrecio)) :
  348.         $menuPreciosHistorial = $this->setMenuPrecioHistorial(new MenuPreciosHistorial(), $ordenMenu, $user);
  349.         $this->em->persist($menuPreciosHistorial);
  350.       endif;
  352.       $this->em->flush();
  353.       return $this->json(['response' => true, 'message' => $this->msgCreate]);
  354.     }
  356.     private function isPrecioDiferente($ordenMenu, $veryMenuPrecio) {
  357.       return round($ordenMenu->getPrecioCosto(), 4) != round($veryMenuPrecio->getPrecioCosto(), 4);
  358.     }
  360.     private function setMenuPrecioHistorial($menuPreciosHistorial, $ordenMenu, $user) {
  361.       $iva = $ordenMenu->getIdPorcentajeIva()->getPorcentaje();
  362.       $precio = floatval(($iva * $ordenMenu->getIdMenu()->getPrecio()) / 100) + floatval($ordenMenu->getIdMenu()->getPrecio());
  363.       $menuPreciosHistorial
  364.         ->setFecha(new \DateTime())
  365.         ->setPrecioCosto($ordenMenu->getPrecioCosto())
  366.         ->setPrecioPvp($precio)
  367.         ->setIdMenu($ordenMenu->getIdMenu())
  368.         ->setIdPorcentajeIva($ordenMenu->getIdPorcentajeIva())
  369.       ;
  370.       $menuPreciosHistorial = $this->setGenericData($user, $menuPreciosHistorial);
  371.       return $menuPreciosHistorial;
  372.     }
  374.     /**
  375.      * @Route("/setPedidoEstado", name="setPedidoEstado")
  376.      */
  377.     public function setPedidoEstado(UserInterface $user, Request $request) {
  378.       try {
  379.         $data = $request->request->get('data');
  380.         $ordenMenu = $this->em->getRepository(OrdenMenu::class)->find($data['id']);
  381.         $cuenta = $ordenMenu->getIdCuenta();
  382.         switch ($data['estado']) {
  383.           case 'entregado':
  384.             $this->setEstadoEntregado($ordenMenu, $user, $cuenta);
  385.             break;
  386.           case 'cancelado':
  387.             $this->setEstadoCancelado($ordenMenu, $user);
  388.             break;
  389.           default:
  390.             return $this->json(['response' => false, 'message' => "Estado desconocido"]);
  391.         }
  392.         $this->updateStock($ordenMenu, $user);
  393.         $this->em->flush();
  394.         return $this->json(['response' => true, 'message' => $this->msgUpdate]);
  395.       } catch (Exception $e) {
  396.         return $this->json(['response' => false, 'message' => "<b>{$e->getMessage()}</b> error al realizar el registro dentro de la petición <i>setPedidoEstado</i>"]);
  397.       }
  398.     }
  400.     private function setEstadoEntregado(OrdenMenu $ordenMenu, UserInterface $user, Cuenta $cuenta)  {
  401.       $ordenMenu
  402.         ->setEstado('Entregado')
  403.         ->setModificarStock(true)
  404.         ->setFechaHoraEntrega(new \DateTime());
  405.       $this->setGenericData($user, $ordenMenu);
  407.       $this->em->persist($ordenMenu);
  409.       if ($cuenta->getIdEstadoCuenta()->getId() == 1) :
  410.         $estadoCuenta = $this->em->getRepository(EstadoCuenta::class)->find(2);
  411.         $cuenta->setIdEstadoCuenta($estadoCuenta);
  412.         $this->em->persist($cuenta);
  413.       endif;
  414.     }
  416.     private function setEstadoCancelado(OrdenMenu $ordenMenu, UserInterface $user)  {
  417.       $ordenMenu
  418.         ->setEstado('Cancelado')
  419.         ->setModificarStock(true);
  420.       $this->setGenericData($user, $ordenMenu);
  421.       $this->em->persist($ordenMenu);
  422.     }
  424.     private function updateStock($ordenMenu, $user) {
  425.       $list = [];
  426.       $cantidadOrden = $ordenMenu->getCantidad();
  427.       $menuComponentes = $this->em->getRepository(MenuComponentes::class)->findBy(['idMenu' => $ordenMenu->getIdMenu()->getId()]);
  428.       if ($ordenMenu->getIdMenu()->getAcompanamiento()) :
  429.         $acompanamiento = $this->em->getRepository(Acompanamiento::class)->findBy(['idMenu' => $ordenMenu->getIdMenu()->getId()]);
  430.         $resultado = $this->filtrarComponentesNoUsados($acompanamiento, $menuComponentes);
  431.         foreach ($resultado as $menuComponente) {
  432.           $cantidadComponente = (float)$menuComponente->getCantidad();
  433.           $componenteInsumo = $this->em->getRepository(ComponenteInsumo::class)->findBy(['idComponentes' => $menuComponente->getIdComponentes()->getId()]);
  434.           foreach ($componenteInsumo as $componente) {
  435.             $cantidadInsumo = (float)$componente->getCantidad();
  436.             $cantidadDescontar = $cantidadInsumo * $cantidadComponente;
  437.             $insumo = $componente->getIdInsumos();
  438.             $list[] = [
  439.               'id' => $insumo->getId(),
  440.               'cantidad' => $cantidadDescontar
  441.             ];
  442.           }
  443.         }
  445.         $ordenMenuACompanamiento = $this->em->getRepository(OrdenMenuAcompanamiento::class)->findBy(['idOrdenMenu' => $ordenMenu->getId()]);
  446.         $jsonComponentes = $this->jsonAcompanamientoFilterDos($ordenMenuACompanamiento);
  447.         foreach ($jsonComponentes as $menuComponente) {
  448.           $menu_componente_cantidad = floatval($menuComponente->getCantidad());
  449.           $componenteInsumos = $this->em->getRepository(ComponenteInsumo::class)->findBy(['idComponentes' => $menuComponente->getIdComponentes()->getId()]);
  450.           foreach ($componenteInsumos as $componenteInsumo) {
  451.             $componente_insumo_cantidad = floatval($componenteInsumo->getCantidad());
  452.             $cantidad_requerida = (($componente_insumo_cantidad / count($ordenMenuACompanamiento)) * $menu_componente_cantidad);
  453.             $insumo = $componenteInsumo->getIdInsumos();
  454.             $list[] = [
  455.               'id' => $insumo->getId(),
  456.               'cantidad' => $cantidad_requerida
  457.             ];
  458.           }
  459.         }
  460.       else:
  461.         foreach ($menuComponentes as $menuComponente) {
  462.           $cantidadComponente = (float)$menuComponente->getCantidad();
  463.           $componenteInsumo = $this->em->getRepository(ComponenteInsumo::class)->findBy(['idComponentes' => $menuComponente->getIdComponentes()->getId()]);
  464.           foreach ($componenteInsumo as $componente) {
  465.             $cantidadInsumo = (float)$componente->getCantidad();
  466.             $cantidadDescontar = $cantidadInsumo * $cantidadComponente;
  467.             $insumo = $componente->getIdInsumos();
  468.             $list[] = [
  469.               'id' => $insumo->getId(),
  470.               'cantidad' => $cantidadDescontar
  471.             ];
  472.           }
  473.         }
  474.       endif;
  475.       foreach ($list as $item) {
  476.         $insumo = $this->em->getRepository(Insumos::class)->find($item['id']);
  477.         $consumoInsumosOrdenMenu = new ConsumoInsumosOrdenMenu;
  478.         $consumoInsumosOrdenMenu
  479.           ->setConsumo(floor(($item['cantidad'] * $cantidadOrden)))
  480.           ->setIdInsumos($insumo)
  481.           ->setIdOrdenMenu($ordenMenu)
  482.         ;
  483.         $this->em->persist($consumoInsumosOrdenMenu);
  484.         $stock = $insumo->getStock();
  485.         $nuevoStock = $stock - floor(($item['cantidad'] * $cantidadOrden));
  486.         $insumo->setStock($nuevoStock);
  487.         $insumo = $this->setGenericData($user, $insumo);
  488.         $this->em->persist($insumo);
  489.       }
  490.     }
  492.     /**
  493.      * @Route("/setCheckCortesia", name="setCheckCortesia")
  494.      */
  495.     public function setCheckCortesia(Request $request, UserInterface $user){
  496.       try {
  497.         ['id' => $id, 'val'=> $val, 'observacion' => $observacion] = $request->request->get('data');
  498.         $ordenMenu = $this->em->getRepository(OrdenMenu::class)->find($id);
  499.         $ordenMenu
  500.           ->setCortesia($val == 'true' ? true : false)
  501.           ->setObservacionCortesia($observacion)
  502.         ;
  503.         $ordenMenu = $this->setGenericData($user, $ordenMenu);
  504.         $this->em->persist($ordenMenu);
  505.         $this->em->flush();
  506.         return $this->json(['response' => true, 'message' => $this->msgUpdate]);
  507.       } catch (Exception $e) {
  508.         return $this->json(['response' => false, 'message' => "<b>{$e->getMessage()}</b> error al realizar el registro dentro de la petición <i>setCheckCortesia</i>"]);
  509.       }
  510.     }
  512.     private function setGenericData($user = null, $entity) {
  513.       $entity
  514.         ->setIdUsuarioModificacion($user != null ? $user->getId() : '1')
  515.         ->setFechaModificacion(new \DateTime())
  516.         ->setIpModificacion($_SERVER['REMOTE_ADDR'])
  517.       ;
  519.       return $entity;
  520.     }
  522.   // * DELETE FUNCTIONS *
  523.     /**
  524.      * @Route("/deleteOrdenCuenta", name="deleteOrdenCuenta")
  525.      */
  526.     public function deleteOrdenCuenta(Request $request) {
  527.       try {
  528.         $id = $request->request->get('id');
  529.         $ordenMenu = $this->em->getRepository(OrdenMenu::class)->find($id);
  530.         // * VALIDACIONES
  531.           $controlComponente = $this->em->getRepository(ControlComponente::class)->findOneBy(['idOrdenMenu' => $id]);
  532.           if ($controlComponente) : $this->em->remove($controlComponente); endif;
  533.           $reservaOrdenMenu = $this->em->getRepository(ReservaOrdenMenu::class)->findOneBy(['idOrdenMenu' => $id]);
  534.           if ($reservaOrdenMenu) : $this->em->remove($reservaOrdenMenu); endif;
  535.           
  536.         $this->em->remove($ordenMenu);
  537.         $this->em->flush();
  538.         return $this->json(['response' => true, 'message' => $this->msgDelete, 'exception' => false], 200);
  539.       } catch (Exception $e) {
  540.         return $this->json(['response' => false, 'message' => "<b>{$e->getMessage()}</b> error al realizar el registro dentro de la petición <i>deleteOrdenCuenta</i>", 'exception' => true]);
  541.       }
  542.     }
  544.   // * EXPORTS *
  545.     /**
  546.      * @Route("/getExcelPedidos", name="getExcelPedidos")
  547.      */
  548.     public function getExcelPedidos(){
  549.       $spreadsheet = new Spreadsheet();
  550.       $sheet = $spreadsheet->getActiveSheet();
  551.       $sheet->setTitle("Pedidos");
  553.       $headers = ['id', 'producto', 'cantidad', 'vu', 'total', 'fecha solicitud', 'fecha entrega', 'estado', 'cortesia'];
  554.       $sheet->fromArray( $headers, NULL, 'A1' );
  555.       $lista = $this->cache->get('excelListPedidos');
  556.       $lista = !$lista ? [] : $lista;
  558.       if(count($lista) != 0):
  559.         $data = array_map(function ($menu) {
  560.           return [
  561.             $menu['id'],
  562.             $menu['nombre'],
  563.             $menu['cantidad'],
  564.             round($menu['pu'], 4),
  565.             round($menu['total'], 2),
  566.             $menu['fechaHoraPedido'],
  567.             $menu['fechaHoraEntrega'],
  568.             $menu['estado'],
  569.             $menu['cortesia'] ? 'Sí' : 'No',
  570.           ];
  571.         }, $lista);
  572.       endif;
  573.       $sheet->fromArray($data, null, 'A2');
  575.       $writer = new Xlsx($spreadsheet);
  576.       $fileName = 'pedidos.xlsx';
  577.       $temp_file = tempnam(sys_get_temp_dir(), $fileName);
  578.       $writer->save($temp_file);
  579.       return $this->file($temp_file, $fileName, ResponseHeaderBag::DISPOSITION_INLINE);
  580.     }
  581. }