src/Noahtech/Sistemas/InterjamaBundle/Controller/PrecargaController.php line 69

Open in your IDE?
  1. <?php
  2. namespace Noahtech\Sistemas\InterjamaBundle\Controller;
  4. use Noahtech\Sistemas\InterjamaBundle\Utils\Codes;
  5. use Symfony\Component\HttpFoundation\Response;
  6. use Symfony\Component\Routing\Annotation\Route;
  7. use Symfony\Component\HttpFoundation\Request;
  8. use Noahtech\Sistemas\InterjamaBundle\Controller\BaseController;
  9. use Noahtech\Sistemas\InterjamaBundle\Handler\McPrecargaHandler;
  10. use Noahtech\Sistemas\InterjamaBundle\Handler\McPrecargaArchivoHandler;
  11. use Noahtech\Sistemas\InterjamaBundle\Handler\McClienteHandler;
  12. use Noahtech\Sistemas\InterjamaBundle\Handler\McVehiculoHandler;
  13. use Noahtech\Sistemas\InterjamaBundle\Handler\McChoferHandler;
  14. use Noahtech\Sistemas\InterjamaBundle\Handler\McTiposTramiteHandler;
  15. use Noahtech\Sistemas\InterjamaBundle\Handler\McCajaHandler;
  16. use Symfony\Component\Security\Core\Exception\AccessDeniedException;
  17. use Noahtech\Sistemas\InterjamaBundle\Utils\Constants;
  18. use Symfony\Component\HttpKernel\Exception\HttpException;
  20. class PrecargaController extends BaseController {
  22.     private function validarAdmin () {
  23.         $usuario = $this->getUser();
  24.         if ($usuario) {
  25.             $admin = false;
  26.             foreach ($usuario->getRoles() as $rol) {            
  27.                 if ($rol == 'ROLE_ADMIN'){
  28.                     $admin = true;
  29.                 }
  30.             }
  31.             if (!$admin){
  32.                 throw new AccessDeniedException("No tiene permiso para acceder a esta pagina.");
  33.             }
  34.         } else {
  35.             throw new AccessDeniedException("No tiene permiso para acceder a esta pagina."); 
  36.         }
  37.     }
  39.     private function validarChofer ($tipo, $numero, $id=null) {
  40.         $chofer = $this->get(McChoferHandler::class)->getChoferDuplicate($tipo, $numero, $id);
  41.         if (!is_null($chofer)) {
  42.             throw new HttpException(409, "Ya existe un chofer con el tipo y número de documento ingresados.");
  43.         }
  44.     }
  45.     
  46.    /**
  47.      * @Route("/admin/precargas/tramites/finalizados", name="admin_precargas_tramites_finalizados_listado")
  48.      * @return type
  49.      */
  50.     public function precargaFinalizadasListadoAction() {
  51.         $this->validarAdmin();
  52.         $usuario = $this->getUser();               
  53.         $this->setTitle("Listado de trámites finalizados | InterJama");
  54.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  55.         $this->addBreadCrumb("Listado de trámites finalizados", true);
  56.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  57.         $this->data['data'] = null;
  58.         $this->data['clientes'] = $clientes;
  59.          return $this->render(
  60.                         '@NoahtechSistemasInterjama/admin/precargas/finalizadas/listado.html.twig', $this->data
  61.         );
  62.     }
  64.     /**
  65.      * consulta de tramite finalizado
  66.      *
  67.      * @Route("/admin/ajax/tramites/finalizados/search", name="admin_ajax_tramites_finalizados_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  68.      */
  69.     public function searchPrecargasFinalizadasAction(Request $request) {
  70.         $this->validarAdmin();
  71.         $searchParam = $request->request->all();        
  72.         $usuario = $this->getUser();               
  73.         $currentPage = $request->query->get('page');
  74.         $sortField = $request->query->get('sort');
  75.         $sortDirection = $request->query->get('direction');
  76.         $currentPage = null == $currentPage ? 1 : $currentPage;
  77.         $offset = ($currentPage - 1) * 100;
  78.         $limit = 100;
  79.         try {
  80.             /** @var McPrecargaHandler $handler */
  81.             $handler = $this->get(McPrecargaHandler::class);
  82.             $lp = $handler->searchPrecargasFinalizadas($offset, $limit, $sortField, $sortDirection, $searchParam);
  83.             $lp->setCurrentPage($currentPage);
  84.             $lp->setPageSize(100);
  85.             $this->response->setData($lp);
  86.             $this->response->setCode(Codes::OK);
  87.         } catch (Exception $e) {
  88.             $this->response->setCode(Codes::ERROR);
  89.             $this->response->setMessage($e->getMessage());
  90.         }
  91.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  92.         return new Response($serializedEntity);
  93.     }
  95.     /**
  96.      * @Route("/admin/precargas", name="admin_precargas_listado")
  97.      * @return type
  98.      */
  99.     public function precargaListadoAction() {
  100.         $this->validarAdmin();
  101.         $usuario = $this->getUser();               
  102.         $this->setTitle("Bandeja de entrada | InterJama");
  103.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  104.         $this->addBreadCrumb("Bandeja de entrada", true);
  105.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  106.         $this->data['data'] = null;
  107.         $this->data['clientes'] = $clientes;
  108.          return $this->render(
  109.                         '@NoahtechSistemasInterjama/admin/precargas/listado.html.twig', $this->data
  110.         );
  111.     }
  113.     /**
  114.      * consulta de precarga
  115.      *
  116.      * @Route("/admin/ajax/precargas/search", name="admin_ajax_precargas_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  117.      */
  118.     public function searchAction(Request $request) {
  119.         $this->validarAdmin();
  120.         $searchParam = $request->request->all();        
  121.         $usuario = $this->getUser();               
  122.         $currentPage = $request->query->get('page');
  123.         $sortField = $request->query->get('sort');
  124.         $sortDirection = $request->query->get('direction');
  125.         $currentPage = null == $currentPage ? 1 : $currentPage;
  126.         $offset = ($currentPage - 1) * 100;
  127.         $limit = 100;
  128.         try {
  129.             /** @var McPrecargaHandler $handler */
  130.             $handler = $this->get(McPrecargaHandler::class);
  131.             $lp = $handler->search($offset, $limit, $sortField, $sortDirection, $searchParam);
  132.             $lp->setCurrentPage($currentPage);
  133.             $lp->setPageSize(100);
  134.             $this->response->setData($lp);
  135.             $this->response->setCode(Codes::OK);
  136.         } catch (Exception $e) {
  137.             $this->response->setCode(Codes::ERROR);
  138.             $this->response->setMessage($e->getMessage());
  139.         }
  140.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  141.         return new Response($serializedEntity);
  142.     }
  144.     /**
  145.      * @Route("/admin/precarga/nueva", name="admin_precarga_nueva")
  146.      * @return type
  147.      */
  148.     public function precargaNuevoAction() {
  149.         $this->validarAdmin();
  150.         $this->setTitle("Nuevo ingreso");
  151.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  152.         $this->addBreadCrumb("Bandeja de entrada", false, "admin_precargas_listado");        
  153.         $this->addBreadCrumb("Nueva ingreso", true);        
  154.         $this->data['data'] = null;
  155.         return $this->render(
  156.                         '@NoahtechSistemasInterjama/admin/precargas/nueva.html.twig', $this->data
  157.         );
  158.     }
  160.     /**
  161.      * consulta de un vehículo por dominio principal
  162.      *
  163.      * @Route("/admin/ajax/precargas/vehiculo/dominio/{dominio}/exists", name="ajax_admin_precargas_vehiculo_dominio_exists", methods={"GET"}, condition="request.isXmlHttpRequest()")
  164.      */
  165.     public function dominioExistsAction($dominio) {
  166.         $this->validarAdmin();
  167.         try {
  168.             $handler = $this->get(McPrecargaHandler::class);
  169.             $vehiculo = $handler->getVehiculoByDominio($dominio);
  170.             $this->response->setData($vehiculo);
  171.             $this->response->setCode(Codes::OK);
  172.         } catch (Exception $e) {
  173.             $this->response->setCode(Codes::ERROR);
  174.             $this->response->setMessage($e->getMessage());
  175.         }
  176.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  177.         return new Response($serializedEntity);
  178.     }
  180.     /**
  181.      * Guarda una precarga
  182.      *
  183.      * @Route("/admin/ajax/precargas", name="admin_ajax_precargas_save", methods={"POST"}, condition="request.isXmlHttpRequest()")
  184.      */
  185.     public function postPrecargaSaveAction(Request $request) {        
  186.         $this->validarAdmin();
  187.         $archivos = (isset($_FILES)) ? $_FILES : null;
  188.         try {
  189.             $handler = $this->get(McPrecargaHandler::class);
  190.             $usuario = $this->getUser();        
  191.             $precarga = $handler->getPrecargaFromRequest($request, $usuario);       
  192.             $result = $handler->save($precarga, $archivos, $request);
  193.             $this->response->setData($result);
  194.             $this->response->setCode(Codes::OK);
  195.         } catch (Exception $e) {
  196.             $this->response->setCode(Codes::ERROR);
  197.             $this->response->setMessage($e->getMessage());
  198.         }
  199.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  200.         return new Response($serializedEntity);
  201.     }
  202.     
  203.     /**
  204.      * @Route("/admin/precargas/{id}", name="admin_precargas_modificacion")
  205.      * @return type
  206.      */
  207.     public function precargaModificacionAction($id) {
  208.         $this->validarAdmin();
  209.         $this->setTitle("Modificar ingreso");
  210.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  211.         $this->addBreadCrumb("Bandeja de entrada", false, "admin_precargas_listado");
  212.         $this->addBreadCrumb("Modificar ingreso", true);
  213.         $this->data['data'] = $id;
  214.         return $this->render(
  215.                         '@NoahtechSistemasInterjama/admin/precargas/modificacion.html.twig', $this->data
  216.         );
  217.     }
  219.     /**
  220.      * Devuelve una precarga
  221.      *
  222.      * @Route("/admin/ajax/precargas/{id}", name="admin_ajax_precarga_get_by_id", methods={"GET"}, condition="request.isXmlHttpRequest()")
  223.      */
  224.     public function getPrecargaByIdAction($id) {
  225.         $this->validarAdmin();
  226.         try {
  227.             $handler = $this->get(McPrecargaHandler::class);
  228.             $precarga = $handler->getById($id);
  229.             $this->response->setData($precarga);
  230.             $this->response->setCode(Codes::OK);
  231.         } catch (Exception $e) {
  232.             $this->response->setCode(Codes::ERROR);
  233.             $this->response->setMessage($e->getMessage());
  234.         }
  235.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  236.         return new Response($serializedEntity);
  237.     }
  239.     /**
  240.      * Modifica una precarga
  241.      *
  242.      * @Route("/admin/ajax/precargas/{id}", name="admin_ajax_precarga_update", methods={"POST"}, condition="request.isXmlHttpRequest()")
  243.      */
  244.     public function putUpdateAction(Request $request, $id) {
  245.         $this->validarAdmin();
  246.         $archivos = (isset($_FILES)) ? $_FILES : null;  
  247.         try {          
  248.             $handler = $this->get(McPrecargaHandler::class);
  249.             $usuario = $this->getUser();
  250.             $precarga = $handler->getPrecargaFromRequest($request, $usuario, $id);        
  251.             $result = $handler->update($precarga, $archivos, $request, $id);        
  252.             $this->response->setData($result);
  253.             $this->response->setCode(Codes::OK);
  254.         } catch (Exception $e) {
  255.             $this->response->setCode(Codes::ERROR);
  256.             $this->response->setMessage($e->getMessage());
  257.         }
  258.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  259.         return new Response($serializedEntity);
  260.     }
  262.     /**
  263.      * @Route("/admin/precargas/{id}/archivos", name="admin_precargas_by_id_archivos")
  264.      * @return type
  265.      */
  266.     public function precargaArchivosListadoAction($id) {
  267.         $this->validarAdmin();
  268.         $usuario = $this->getUser();               
  269.         $this->setTitle("Archivos adjuntos");
  270.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  271.         $this->addBreadCrumb("Bandeja de entrada", false, "admin_precargas_listado");        
  272.         $this->addBreadCrumb("Archivos adjuntos", true);
  273.         $precargaArchivos = $this->get(McPrecargaArchivoHandler::class)->findAllByPrecarga($id);      
  274.         $this->data['data'] = $id;
  275.         $this->data['archivos'] = $precargaArchivos;
  276.          return $this->render(
  277.                         '@NoahtechSistemasInterjama/admin/precargas/archivos.html.twig', $this->data
  278.         );
  279.     }
  281.     /**
  282.      * descarga de archivos de una precarga
  283.      *
  284.      * @Route("/admin/ajax/precargas/{id}/download/archivos", name="admin_ajax_precarga_get_by_id_descarga")
  285.      */
  286.     public function downloadFileByPrecargaAction($id) {
  287.         try {
  288.             $this->validarAdmin();
  289.             $handler = $this->get(McPrecargaArchivoHandler::class);
  290.             return $handler->downloadFilesByPrecarga($id);
  291.         } catch (Exception $e) {
  292.             return $e->getMessage();
  293.         }
  294.     }
  296.     /**
  297.      * Guarda un chofer
  298.      *
  299.      * @Route("/admin/ajax/chofer", name="admin_chofer_save", methods={"POST"}, condition="request.isXmlHttpRequest()")
  300.      */
  301.     public function postChoferSaveAction(Request $request) {
  302.         $this->validarAdmin();
  303.         $this->validarChofer($request->request->get('tipo'), $request->request->get('numero'));
  304.         try {
  305.             $handler = $this->get(McChoferHandler::class);            
  306.             $chofer = $handler->getChoferFromRequest($request, null, null);
  307.             $result = $handler->save($chofer);
  308.             $this->response->setData($result);
  309.             $this->response->setCode(Codes::OK);            
  310.         } catch (Exception $e) {
  311.             $this->response->setCode(Codes::ERROR);
  312.             $this->response->setMessage($e->getMessage());
  313.         }
  314.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  315.         return new Response($serializedEntity);       
  316.     }
  318.     /**
  319.      * @Route("/admin/precargas/tramites/finalizados/deudas", name="admin_precargas_tramites_finalizados_deudas_listado")
  320.      * @return type
  321.      */
  322.     public function precargaFinalizadasDeudasListadoAction() {
  323.         $this->validarAdmin();
  324.         $usuario = $this->getUser();               
  325.         $this->setTitle("Listado de Empresas con deudas | InterJama");
  326.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  327.         $this->addBreadCrumb("Listado de Empresas con deudas", true);
  328.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  329.         $this->data['data'] = null;
  330.         $this->data['clientes'] = $clientes;
  331.          return $this->render(
  332.                         '@NoahtechSistemasInterjama/admin/precargas/finalizadas/deudas.html.twig', $this->data
  333.         );
  334.     }
  336.     /**
  337.      * consulta de tramite finalizado
  338.      *
  339.      * @Route("/admin/ajax/tramites/finalizados/deudas/search", name="admin_ajax_tramites_finalizados_deudas_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  340.      */
  341.     public function searchPrecargasFinalizadasDeudasAction(Request $request) {
  342.         $this->validarAdmin();
  343.         $searchParam = $request->request->all();        
  344.         $usuario = $this->getUser();               
  345.         $currentPage = $request->query->get('page');
  346.         $sortField = $request->query->get('sort');
  347.         $sortDirection = $request->query->get('direction');
  348.         $currentPage = null == $currentPage ? 1 : $currentPage;
  349.         $offset = ($currentPage - 1) * 100;
  350.         $limit = 100;
  351.         try {
  352.             /** @var McPrecargaHandler $handler */
  353.             $handler = $this->get(McPrecargaHandler::class);
  354.             $lp = $handler->searchPrecargasFinalizadasConDeudas($offset, $limit, $sortField, $sortDirection, $searchParam);
  355.             $lp->setCurrentPage($currentPage);
  356.             $lp->setPageSize(100);
  357.             $this->response->setData($lp);
  358.             $this->response->setCode(Codes::OK);
  359.         } catch (Exception $e) {
  360.             $this->response->setCode(Codes::ERROR);
  361.             $this->response->setMessage($e->getMessage());
  362.         }
  363.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  364.         return new Response($serializedEntity);
  365.     }
  367.     /**
  368.      * @Route("/admin/precargas/tramites/finalizados/{id}", name="admin_precargas_tramite_finalizada_update")
  369.      * @return type
  370.      */
  371.     public function precargaUpdateAtencionAction($id) {
  372.         $this->validarAdmin();
  373.         $this->setTitle("Editar Trámite");
  374.         $this->addBreadCrumb("Inicio - Atención", false, "admin_home");
  375.         $this->addBreadCrumb("Listado de trámites finalizados", false, "admin_precargas_tramites_finalizados_listado");
  376.         $this->addBreadCrumb("Editar Trámite", true);
  377.         $tiposTramite = $this->get(McTiposTramiteHandler::class)->getTiposTramite();
  378.         $caja = $this->get(McCajaHandler::class)->getCajaAbierta('operador');
  379.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  380.         $this->data['data'] = $id;
  381.         $this->data['clientes'] = $clientes;
  382.         $this->data['tiposTramite'] = $tiposTramite;
  383.         $this->data['caja'] = $caja;
  384.         return $this->render(
  385.                         '@NoahtechSistemasInterjama/admin/precargas/finalizadas/update.html.twig', $this->data
  386.         );
  387.     }
  389.     /**
  390.      * Modifica una atencion de precarga
  391.      *
  392.      * @Route("/admin/ajax/precargas/{id}/modificacion/atencion", name="admin_ajax_precarga_modificacion_atencion_update", methods={"PUT"}, condition="request.isXmlHttpRequest()")
  393.      */
  394.     public function editAtencionPrecargaAction(Request $request, $id) {
  395.         $this->validarAdmin();
  396.         $handler = $this->get(McPrecargaHandler::class);
  397.         $usuario = $this->getUser();
  398.         $precarga = $handler->getAtencionPrecargaFromRequest($request,$id, $usuario);        
  399.         $result = $handler->updateAtencion($precarga, $id);        
  400.         $this->response->setData($result);
  401.         $this->response->setCode(Codes::OK);
  402.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  403.         return new Response($serializedEntity);
  404.     }
  406.     /**
  407.      * Devuelve una precarga finalizada
  408.      *
  409.      * @Route("/admin/ajax/precargas/atencion/{id}", name="admin_ajax_precarga_atencion_get_by_id", methods={"GET"}, condition="request.isXmlHttpRequest()")
  410.      */
  411.     public function getAtencionPrecargaByIdAction($id) {
  412.         $this->validarAdmin();
  413.         try {
  414.             $handler = $this->get(McPrecargaHandler::class);
  415.             $precarga = $handler->getPrecargaAtencionById($id);
  416.             $this->response->setData($precarga);
  417.             $this->response->setCode(Codes::OK);
  418.         } catch (Exception $e) {
  419.             $this->response->setCode(Codes::ERROR);
  420.             $this->response->setMessage($e->getMessage());
  421.         }
  422.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  423.         return new Response($serializedEntity);
  424.     }
  426.     /**
  427.      * 
  428.      * Descarga manifiesto de carga
  429.      * 
  430.      * @Route("/admin/ajax/precargas/{precargaId}/descarga/manifiesto", name="admin_ajax_precargas_manifiesto_descarga")
  431.      * 
  432.      */
  433.     public function descargaManifiestoPdfAction($precargaId) {        
  434.         try { 
  435.            $this->validarAdmin();           
  436.            return $this->get(McPrecargaHandler::class)->descargaManifiestoPdf($precargaId);
  437.         } catch (Exception $e) {
  438.            return $e->getMessage();
  439.         }
  440.    }
  442.    /**
  443.      * 
  444.      * Descarga Hoja de ruta
  445.      * 
  446.      * @Route("/admin/ajax/precargas/{precargaId}/descarga/hoja_ruta", name="admin_ajax_precargas_hoja_ruta_descarga")
  447.      * 
  448.      */
  449.     public function descargaHojaRutaPdfAction($precargaId) {        
  450.         try { 
  451.            $this->validarAdmin();           
  452.            return $this->get(McPrecargaHandler::class)->descargaHojaRutaPdf($precargaId);
  453.         } catch (Exception $e) {
  454.            return $e->getMessage();
  455.         }
  456.    }
  458.    /**
  459.      * 
  460.      * Descarga MCDTA
  461.      * 
  462.      * @Route("/admin/ajax/precargas/{precargaId}/descarga/mcdta", name="admin_ajax_precargas_mcdta_descarga")
  463.      * 
  464.      */
  465.     public function descargaMcdtaPdfAction($precargaId) {        
  466.         try { 
  467.            $this->validarAdmin();           
  468.            return $this->get(McPrecargaHandler::class)->descargaMcdtaPdf($precargaId);
  469.         } catch (Exception $e) {
  470.            return $e->getMessage();
  471.         }
  472.    }
  474.     /**
  475.      * 
  476.      * Descarga recibo de atención de precarga
  477.      * 
  478.      * @Route("/admin/ajax/precargas/{precargaId}/descarga/recibo", name="admin_ajax_precarga_recibo_descarga")
  479.      * 
  480.     */
  481.     public function descargaReciboAction($precargaId) {        
  482.         try { 
  483.            $this->validarAdmin();           
  484.            return $this->get(McPrecargaHandler::class)->descargaReciboPdf($precargaId);
  485.         } catch (Exception $e) {
  486.            return $e->getMessage();
  487.         }
  488.    }
  490.    /**
  491.      * 
  492.      * Descarga factura de Afip de atención de precarga
  493.      * 
  494.      * @Route("/atencion/ajax/precargas/afip/{precargaId}/tipo/{tipoFactura}/descarga", name="atencion_ajax_precarga_factura_descarga")
  495.      * 
  496.     */
  497.     public function descargaFacturaAfipAction($precargaId, $tipoFactura) {        
  498.         try { 
  499.            $this->validarAtencion();           
  500.            return $this->get(McPrecargaHandler::class)->descargaFacturaAfipPdf($precargaId, $tipoFactura);
  501.         } catch (Exception $e) {
  502.            return $e->getMessage();
  503.         }
  504.    }
  506.    /**
  507.      * descarga del formulario SENASA
  508.      *
  509.      * @Route("/admin/ajax/precargas/atencion/{id}/formulario/senasa", name="admin_ajax_precarga_atencion_formulario_senasa")
  510.      */
  511.     public function downloadSenasaAction(Request $request, $id) {
  512.         $request_body = file_get_contents('php://input');
  513.         $data = json_decode($request_body, true);
  514.         try {
  515.             $this->validarAdmin();
  516.             $handler = $this->get(McPrecargaHandler::class);
  517.             return $handler->downloadSenasa($data, $id);
  518.         } catch (Exception $e) {
  519.             return $e->getMessage();
  520.         }
  521.     }
  524.     /**
  525.      * @Route("/admin/precargas/tramites/finalizados/deudas/cliente/{clienteId}", name="admin_precargas_tramites_finalizados_deudas_by_cliente_listado")
  526.      * @return type
  527.     */
  528.     public function precargaFinalizadasDeudasByClienteListadoAction($clienteId) {
  529.         $this->validarAdmin();
  530.         $usuario = $this->getUser();               
  531.         $this->setTitle("Listado de deudas del Cliente | InterJama");
  532.         $this->addBreadCrumb("Inicio - Admin", false, "admin_home");
  533.         $this->addBreadCrumb("Listado de Empresas con deudas", false, "admin_precargas_tramites_finalizados_deudas_listado");
  534.         $this->addBreadCrumb("Listado de Deudas", true);
  535.         $cliente = $this->get(McClienteHandler::class)->getById($clienteId);
  536.         $this->data['data'] = null;
  537.         $this->data['cliente'] = $cliente;
  538.          return $this->render(
  539.                         '@NoahtechSistemasInterjama/admin/precargas/finalizadas/clientes/deudas.html.twig', $this->data
  540.         );
  541.     }
  543.     /**
  544.      * consulta de tramite con deudas por cliente
  545.      *
  546.      * @Route("/admin/ajax/tramites/finalizados/deudas/cliente/{clienteId}/search", name="admin_ajax_tramites_finalizados_deudas_by_cliente_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  547.      */
  548.     public function searchPrecargasFinalizadasDeudasByClienteAction(Request $request, $clienteId) {
  549.         $this->validarAdmin();
  550.         $searchParam = $request->request->all();        
  551.         $usuario = $this->getUser();               
  552.         $currentPage = $request->query->get('page');
  553.         $sortField = $request->query->get('sort');
  554.         $sortDirection = $request->query->get('direction');
  555.         $currentPage = null == $currentPage ? 1 : $currentPage;
  556.         $offset = ($currentPage - 1) * 100;
  557.         $limit = 100;
  558.         try {
  559.             /** @var McPrecargaHandler $handler */
  560.             $handler = $this->get(McPrecargaHandler::class);
  561.             $lp = $handler->searchPrecargasFinalizadasConDeudasByCliente($offset, $limit, $sortField, $sortDirection, $searchParam);
  562.             $lp->setCurrentPage($currentPage);
  563.             $lp->setPageSize(100);
  564.             $this->response->setData($lp);
  565.             $this->response->setCode(Codes::OK);
  566.         } catch (Exception $e) {
  567.             $this->response->setCode(Codes::ERROR);
  568.             $this->response->setMessage($e->getMessage());
  569.         }
  570.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  571.         return new Response($serializedEntity);
  572.     }
  574.     /**
  575.      * Actualiza las deudas de un cliente
  576.      *
  577.      * @Route("/admin/ajax/update/deudas/cliente", name="admin_ajax_tramite_deuda_update", methods={"PUT"}, condition="request.isXmlHttpRequest()")
  578.      */
  579.     public function putDeudaClienteAction(Request $request) {
  580.         $this->validarAdmin();
  581.         try {          
  582.             $handler = $this->get(McPrecargaHandler::class);    
  583.             $result = $handler->updateDeuda($request);        
  584.             $this->response->setData($result);
  585.             $this->response->setCode(Codes::OK);
  586.         } catch (Exception $e) {
  587.             $this->response->setCode(Codes::ERROR);
  588.             $this->response->setMessage($e->getMessage());
  589.         }
  590.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  591.         return new Response($serializedEntity);
  592.     }
  594.     /**
  595.      * 
  596.      * Descarga recibo de atención de precargas
  597.      * 
  598.      * @Route("/admin/ajax/precargas/cliente/{clienteId}/descarga/recibo", name="admin_ajax_precarga_by_cliente_recibo_descarga", methods={"POST"})
  599.      * 
  600.     */
  601.     public function descargaReciboMultipleAction($clienteId, Request $request) {        
  602.         try { 
  603.            $this->validarAdmin();
  604.            // Obtener el contenido de la solicitud JSON
  605.             $data = json_decode($request->getContent(), true);
  607.             // Obtener el array de tramites que llegó en el cuerpo de la solicitud
  608.             $tramitesIds = $data['tramites'];
  610.             // Validar que haya trámites enviados en la solicitud
  611.             if (empty($tramitesIds)) {
  612.                 throw new Exception('No se han proporcionado trámites.');
  613.             }
  614.            return $this->get(McPrecargaHandler::class)->descargaReciboMultiplePdf($tramitesIds);
  615.         } catch (Exception $e) {
  616.            return $e->getMessage();
  617.         }
  618.    }
  620.    /**
  621.      * 
  622.      * Descarga Factura Afip Multiples
  623.      * 
  624.      * @Route("/admin/ajax/precargas/cliente/{clienteId}/factura/afip", name="admin_ajax_precarga_by_cliente_factura_afip", methods={"POST"})
  625.      * 
  626.     */
  627.     public function descargaFacturaAFipMultipleAction($clienteId, Request $request) {        
  628.         try { 
  629.            $this->validarAdmin();
  630.            // Obtener el contenido de la solicitud JSON
  631.             $data = json_decode($request->getContent(), true);
  632.             
  633.             // Obtener el array de tramites que llegó en el cuerpo de la solicitud
  634.             $tramitesIds = $data['datos']['tramites'];
  635.             $comprobante = $data['datos']['comprobante'];
  637.             // Validar que haya trámites enviados en la solicitud
  638.             if (empty($tramitesIds)) {
  639.                 throw new Exception('No se han proporcionado trámites.');
  640.             }
  641.            return $this->get(McPrecargaHandler::class)->descargaFacturaAfipMultiplePdf($tramitesIds, $comprobante);
  642.         } catch (Exception $e) {
  643.            return $e->getMessage();
  644.         }
  645.    }
  647. }