src/Noahtech/Sistemas/InterjamaBundle/Controller/Atencion/PrecargaController.php line 254

Open in your IDE?
  1. <?php
  2. namespace Noahtech\Sistemas\InterjamaBundle\Controller\Atencion;
  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 validarAtencion () {
  23.         $usuario = $this->getUser();
  24.         if ($usuario) {
  25.             $atencion = false;
  26.             foreach ($usuario->getRoles() as $rol) {
  27.                 if ($rol == 'ROLE_ATENCION'){
  28.                     $atencion = true;
  29.                 }
  30.             }
  31.             if (!$atencion){
  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.     }
  46.     /**
  47.      * @Route("/atencion/precarga/atenciones", name="atencion_precarga_atenciones_listado")
  48.      * @return type
  49.      */
  50.     public function listadoAtencionAction() {
  51.         $this->validarAtencion();
  52.         $this->setTitle("Listado de atenciones");
  53.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  54.         $this->addBreadCrumb("Listado de atenciones", true);
  55.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  56.         $this->data['data'] = null;
  57.         $this->data['clientes'] = $clientes;
  58.         return $this->render(
  59.                         '@NoahtechSistemasInterjama/atencion/precargas/atenciones/listado.html.twig', $this->data
  60.         );
  61.     }
  63.     /**
  64.      * consulta de precarga
  65.      *
  66.      * @Route("/atencion/ajax/precargas/atenciones/search", name="atencion_ajax_precargas_atenciones_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  67.      */
  68.     public function searchAtencionesAction(Request $request) {
  69.         $this->validarAtencion();
  70.         $searchParam = $request->request->all();        
  71.         $usuario = $this->getUser();               
  72.         $currentPage = $request->query->get('page');
  73.         $sortField = $request->query->get('sort');
  74.         $sortDirection = $request->query->get('direction');
  75.         $currentPage = null == $currentPage ? 1 : $currentPage;
  76.         $offset = ($currentPage - 1) * 100;
  77.         $limit = 100;
  78.         try {
  79.             /** @var McPrecargaHandler $handler */
  80.             $handler = $this->get(McPrecargaHandler::class);
  81.             $lp = $handler->searchAtenciones($offset, $limit, $sortField, $sortDirection, $searchParam);
  82.             $lp->setCurrentPage($currentPage);
  83.             $lp->setPageSize(100);
  84.             $this->response->setData($lp);
  85.             $this->response->setCode(Codes::OK);
  86.         } catch (Exception $e) {
  87.             $this->response->setCode(Codes::ERROR);
  88.             $this->response->setMessage($e->getMessage());
  89.         }
  90.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  91.         return new Response($serializedEntity);
  92.     }
  94.     /**
  95.      * @Route("/atencion/precarga/atencion/{id}", name="atencion_precarga_atencion")
  96.      * @return type
  97.      */
  98.     public function precargaAtencionAction($id) {
  99.         $this->validarAtencion();
  100.         $this->setTitle("Nueva Atención de precarga");
  101.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  102.         $this->addBreadCrumb("Listado de atenciones", false, "atencion_precarga_atenciones_listado");
  103.         $this->addBreadCrumb("Nueva Atención de precarga", true);
  104.         $tiposTramite = $this->get(McTiposTramiteHandler::class)->getTiposTramite();
  105.         $caja = $this->get(McCajaHandler::class)->getCajaAbierta('operador');
  106.         $this->data['data'] = $id;
  107.         $this->data['tiposTramite'] = $tiposTramite;
  108.         $this->data['caja'] = $caja;
  109.         return $this->render(
  110.                         '@NoahtechSistemasInterjama/atencion/precargas/atenciones/atencion.html.twig', $this->data
  111.         );
  112.     }
  114.     /**
  115.      * Devuelve una precarga
  116.      *
  117.      * @Route("/atencion/ajax/precargas/atencion/{id}", name="atencion_ajax_precarga_atencion_get_by_id", methods={"GET"}, condition="request.isXmlHttpRequest()")
  118.      */
  119.     public function getAtencionPrecargaByIdAction($id) {
  120.         $this->validarAtencion();
  121.         try {
  122.             $handler = $this->get(McPrecargaHandler::class);
  123.             $precarga = $handler->getPrecargaAtencionById($id);
  124.             $this->response->setData($precarga);
  125.             $this->response->setCode(Codes::OK);
  126.         } catch (Exception $e) {
  127.             $this->response->setCode(Codes::ERROR);
  128.             $this->response->setMessage($e->getMessage());
  129.         }
  130.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  131.         return new Response($serializedEntity);
  132.     }
  134.     /**
  135.      * Modifica una precarga para agregar los datos de atención
  136.      *
  137.      * @Route("/atencion/ajax/precargas/{id}/atencion", name="atencion_ajax_precarga_atencion_update", methods={"PUT"}, condition="request.isXmlHttpRequest()")
  138.      */
  139.     public function putAtencionAction(Request $request, $id) {
  140.         $this->validarAtencion();
  141.         $handler = $this->get(McPrecargaHandler::class);
  142.         $usuario = $this->getUser();
  143.         $precarga = $handler->getAtencionPrecargaFromRequest($request,$id, $usuario);        
  144.         $result = $handler->updateAtencion($precarga, $id);        
  145.         $this->response->setData($result);
  146.         $this->response->setCode(Codes::OK);
  147.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  148.         return new Response($serializedEntity);
  149.     }
  151.     /**
  152.      * 
  153.      * Descarga manifiesto de carga
  154.      * 
  155.      * @Route("/atencion/ajax/precargas/{precargaId}/descarga/manifiesto", name="atencion_ajax_precargas_manifiesto_descarga")
  156.      * 
  157.      */
  158.     public function descargaManifiestoPdfAction($precargaId) {        
  159.         try { 
  160.            $this->validarAtencion();           
  161.            return $this->get(McPrecargaHandler::class)->descargaManifiestoPdf($precargaId);
  162.         } catch (Exception $e) {
  163.            return $e->getMessage();
  164.         }
  165.    }
  167.    /**
  168.      * 
  169.      * Descarga Hoja de ruta
  170.      * 
  171.      * @Route("/atencion/ajax/precargas/{precargaId}/descarga/hoja_ruta", name="atencion_ajax_precargas_hoja_ruta_descarga")
  172.      * 
  173.      */
  174.     public function descargaHojaRutaPdfAction($precargaId) {        
  175.         try { 
  176.            $this->validarAtencion();           
  177.            return $this->get(McPrecargaHandler::class)->descargaHojaRutaPdf($precargaId);
  178.         } catch (Exception $e) {
  179.            return $e->getMessage();
  180.         }
  181.    }
  183.    /**
  184.      * 
  185.      * Descarga MCDTA
  186.      * 
  187.      * @Route("/atencion/ajax/precargas/{precargaId}/descarga/mcdta", name="atencion_ajax_precargas_mcdta_descarga")
  188.      * 
  189.      */
  190.     public function descargaMcdtaPdfAction($precargaId) {        
  191.         try { 
  192.            $this->validarAtencion();           
  193.            return $this->get(McPrecargaHandler::class)->descargaMcdtaPdf($precargaId);
  194.         } catch (Exception $e) {
  195.            return $e->getMessage();
  196.         }
  197.    }
  199.     /**
  200.      * 
  201.      * Descarga recibo de atención de precarga
  202.      * 
  203.      * @Route("/atencion/ajax/precargas/{precargaId}/descarga/recibo", name="atencion_ajax_precarga_recibo_descarga")
  204.      * 
  205.     */
  206.     public function descargaReciboAction($precargaId) {        
  207.         try { 
  208.            $this->validarAtencion();           
  209.            return $this->get(McPrecargaHandler::class)->descargaReciboPdf($precargaId);
  210.         } catch (Exception $e) {
  211.            return $e->getMessage();
  212.         }
  213.    }
  215.    /**
  216.      * 
  217.      * Descarga factura de Afip de atención de precarga
  218.      * 
  219.      * @Route("/atencion/ajax/precargas/afip/{precargaId}/tipo/{tipoFactura}/descarga", name="atencion_ajax_precarga_factura_descarga")
  220.      * 
  221.     */
  222.     public function descargaFacturaAfipAction($precargaId, $tipoFactura) {        
  223.         try { 
  224.            $this->validarAtencion();           
  225.            return $this->get(McPrecargaHandler::class)->descargaFacturaAfipPdf($precargaId, $tipoFactura);
  226.         } catch (Exception $e) {
  227.            return $e->getMessage();
  228.         }
  229.    }
  231.    /**
  232.      * @Route("/atencion/tramites/finalizados", name="atencion_tramites_finalizados_listado")
  233.      * @return type
  234.      */
  235.     public function precargaFinalizadasListadoAction() {
  236.         $this->validarAtencion();
  237.         $usuario = $this->getUser();               
  238.         $this->setTitle("Trámites finalizados | InterJama");
  239.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  240.         $this->addBreadCrumb("Trámites finalizados", true);
  241.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  242.         $this->data['data'] = null;
  243.         $this->data['clientes'] = $clientes;
  244.          return $this->render(
  245.                         '@NoahtechSistemasInterjama/atencion/precargas/finalizadas/listado.html.twig', $this->data
  246.         );
  247.     }
  249.     /**
  250.      * consulta de tramite finalizado
  251.      *
  252.      * @Route("/atencion/ajax/tramites/finalizados/search", name="atencion_ajax_tramites_finalizados_listado", methods={"POST"}, condition="request.isXmlHttpRequest()")
  253.      */
  254.     public function searchPrecargasFinalizadasAction(Request $request) {
  255.         $this->validarAtencion();
  256.         $searchParam = $request->request->all();        
  257.         $usuario = $this->getUser();               
  258.         $currentPage = $request->query->get('page');
  259.         $sortField = $request->query->get('sort');
  260.         $sortDirection = $request->query->get('direction');
  261.         $currentPage = null == $currentPage ? 1 : $currentPage;
  262.         $offset = ($currentPage - 1) * 100;
  263.         $limit = 100;
  264.         try {
  265.             /** @var McPrecargaHandler $handler */
  266.             $handler = $this->get(McPrecargaHandler::class);
  267.             $lp = $handler->searchPrecargasFinalizadas($offset, $limit, $sortField, $sortDirection, $searchParam);
  268.             $lp->setCurrentPage($currentPage);
  269.             $lp->setPageSize(100);
  270.             $this->response->setData($lp);
  271.             $this->response->setCode(Codes::OK);
  272.         } catch (Exception $e) {
  273.             $this->response->setCode(Codes::ERROR);
  274.             $this->response->setMessage($e->getMessage());
  275.         }
  276.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  277.         return new Response($serializedEntity);
  278.     }
  280.     /**
  281.      * Devuelve un cliente segun el termino de busqueda
  282.      *
  283.      * @Route("/atencion/ajax/search/clientes/ByTermino", name="atencion_ajax_cliente_by_termino", methods={"GET"}, condition="request.isXmlHttpRequest()")
  284.      */
  285.     public function getClienteByTerminoSerachAction(Request $request) {
  286.         $this->validarAtencion();
  287.         $userCurrent = $this->getUser();
  288.         $searchParam = $request->query->get('q');
  289.         try {
  290.             $handler = $this->get(McClienteHandler::class);
  291.             $clientes = $handler->searchClientesByTermino($searchParam);
  292.             $this->response->setData($clientes);
  293.             $this->response->setCode(Codes::OK);
  294.         } catch (Exception $e) {
  295.             $this->response->setCode(Codes::ERROR);
  296.             $this->response->setMessage($e->getMessage());
  297.         }
  298.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  299.         return new Response($serializedEntity);
  300.     }
  302.     /**
  303.      * descarga de archivos de una precarga
  304.      *
  305.      * @Route("/atencion/ajax/precargas/{id}/download/archivos", name="atencion_ajax_precarga_get_by_id_descarga")
  306.      */
  307.     public function downloadFileByPrecargaAction($id) {
  308.         try {
  309.             $this->validarAtencion();
  310.             $handler = $this->get(McPrecargaArchivoHandler::class);
  311.             return $handler->downloadFilesByPrecarga($id);
  312.         } catch (Exception $e) {
  313.             return $e->getMessage();
  314.         }
  315.     }
  317.     /**
  318.      * @Route("/atencion/precargas/{id}/archivos", name="atencion_precargas_by_id_archivos")
  319.      * @return type
  320.      */
  321.     public function precargaArchivosListadoAction($id) {
  322.         $this->validarAtencion();
  323.         $usuario = $this->getUser();               
  324.         $this->setTitle("Archivos adjuntos");
  325.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  326.         $this->addBreadCrumb("Bandeja de entrada", false, "atencion_precargas_listado");        
  327.         $this->addBreadCrumb("Archivos adjuntos", true);
  328.         $precargaArchivos = $this->get(McPrecargaArchivoHandler::class)->findAllByPrecarga($id);      
  329.         $this->data['data'] = $id;
  330.         $this->data['archivos'] = $precargaArchivos;
  331.          return $this->render(
  332.                         '@NoahtechSistemasInterjama/atencion/precargas/archivos.html.twig', $this->data
  333.         );
  334.     }
  336.     /**
  337.      * @Route("/atencion/precarga/atencion/{id}/formulario/senasa", name="atencion_precarga_atencion_formulario_senasa")
  338.      * @return type
  339.      */
  340.     public function precargaAtencionSenasaAction($id) {
  341.         $this->validarAtencion();
  342.         $this->setTitle("Formulario Senasa");
  343.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  344.         $this->addBreadCrumb("Listado de precargas", false, "atencion_precarga_atenciones_listado");
  345.         $this->addBreadCrumb("Formulario Senasa", true);
  346.         $this->data['data'] = $id;
  347.         return $this->render(
  348.                         '@NoahtechSistemasInterjama/atencion/precargas/atenciones/senasa.html.twig', $this->data
  349.         );
  350.     }
  352.     /**
  353.      * descarga del formulario SENASA
  354.      *
  355.      * @Route("/atencion/ajax/precargas/atencion/{id}/formulario/senasa", name="atencion_ajax_precarga_atencion_formulario_senasa")
  356.      */
  357.     public function downloadSenasaAction(Request $request, $id) {
  358.         $request_body = file_get_contents('php://input');
  359.         $data = json_decode($request_body, true);
  360.         try {
  361.             $this->validarAtencion();
  362.             $handler = $this->get(McPrecargaHandler::class);
  363.             return $handler->downloadSenasa($data, $id);
  364.         } catch (Exception $e) {
  365.             return $e->getMessage();
  366.         }
  367.     }
  369.     /**
  370.      * @Route("/atencion/precarga/atencion/{id}/formulario/anmac", name="atencion_precarga_atencion_formulario_anmac")
  371.      * @return type
  372.      */
  373.     public function precargaAtencionAnmacAction($id) {
  374.         $this->validarAtencion();
  375.         $this->setTitle("Formulario Anmac");
  376.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  377.         $this->addBreadCrumb("Listado de precargas", false, "atencion_precarga_atenciones_listado");
  378.         $this->addBreadCrumb("Formulario Anmac", true);
  379.         $this->data['data'] = $id;
  380.         return $this->render(
  381.                         '@NoahtechSistemasInterjama/atencion/precargas/atenciones/anmac.html.twig', $this->data
  382.         );
  383.     }
  385.     /**
  386.      * descarga del formulario ANMAC
  387.      *
  388.      * @Route("/atencion/ajax/precargas/atencion/{id}/formulario/anmac", name="atencion_ajax_precarga_atencion_formulario_anmac")
  389.      */
  390.     public function downloadAnmacAction(Request $request, $id) {
  391.         $request_body = file_get_contents('php://input');
  392.         $data = json_decode($request_body, true);
  393.         try {
  394.             $this->validarAtencion();
  395.             $handler = $this->get(McPrecargaHandler::class);
  396.             return $handler->downloadAnmac($data, $id);
  397.         } catch (Exception $e) {
  398.             return $e->getMessage();
  399.         }
  400.     }
  402.     /**
  403.      * Guarda un chofer
  404.      *
  405.      * @Route("/atencion/ajax/chofer", name="atencion_chofer_save", methods={"POST"}, condition="request.isXmlHttpRequest()")
  406.      */
  407.     public function postChoferSaveAction(Request $request) {
  408.         $this->validarAtencion();
  409.         $this->validarChofer($request->request->get('tipo'), $request->request->get('numero'));
  410.         try {
  411.             $handler = $this->get(McChoferHandler::class);            
  412.             $chofer = $handler->getChoferFromRequest($request, null, null);
  413.             $result = $handler->save($chofer);
  414.             $this->response->setData($result);
  415.             $this->response->setCode(Codes::OK);            
  416.         } catch (Exception $e) {
  417.             $this->response->setCode(Codes::ERROR);
  418.             $this->response->setMessage($e->getMessage());
  419.         }
  420.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  421.         return new Response($serializedEntity);       
  422.     }
  424.     /**
  425.      * 
  426.      * Descarga archivos de una precarga finalizada
  427.      * 
  428.      * @Route("/atencion/ajax/tramites/finalizados/{precargaId}/download", name="atencion_ajax_tramite_finalizado_download")
  429.      * 
  430.      */
  431.     public function descargaArchivosAction($precargaId) {
  432.         try {
  433.             $this->validarAtencion();
  434.             $handler = $this->get(McPrecargaHandler::class);
  435.             return $handler->downloadArchivosFinalizado($precargaId);
  436.         } catch (Exception $e) {
  437.             return $e->getMessage();
  438.         }
  439.    }
  441.    /**
  442.      * @Route("/atencion/tramites/atencion/editar/{id}", name="atencion_tramite_atencion_update")
  443.      * @return type
  444.      */
  445.     public function precargaUpdateAtencionAction($id) {
  446.         $this->validarAtencion();
  447.         $this->setTitle("Editar Trámite");
  448.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  449.         $this->addBreadCrumb("Listado de trámites finalizados", false, "atencion_tramites_finalizados_listado");
  450.         $this->addBreadCrumb("Editar Trámite", true);
  451.         $tiposTramite = $this->get(McTiposTramiteHandler::class)->getTiposTramite();
  452.         $caja = $this->get(McCajaHandler::class)->getCajaAbierta('operador');
  453.         $clientes = $this->get(McClienteHandler::class)->getClientes();
  454.         $this->data['data'] = $id;
  455.         $this->data['clientes'] = $clientes;
  456.         $this->data['tiposTramite'] = $tiposTramite;
  457.         $this->data['caja'] = $caja;
  458.         return $this->render(
  459.                         '@NoahtechSistemasInterjama/atencion/precargas/atenciones/updateAtencion.html.twig', $this->data
  460.         );
  461.     }
  464.     /**
  465.      * Modifica una atencion de precarga
  466.      *
  467.      * @Route("/atencion/ajax/precargas/{id}/modificacion/atencion", name="atencion_ajax_precarga_modificacion_atencion_update", methods={"PUT"}, condition="request.isXmlHttpRequest()")
  468.      */
  469.     public function editAtencionPrecargaAction(Request $request, $id) {
  470.         $this->validarAtencion();
  471.         $handler = $this->get(McPrecargaHandler::class);
  472.         $usuario = $this->getUser();
  473.         $precarga = $handler->getAtencionPrecargaFromRequest($request,$id, $usuario);        
  474.         $result = $handler->updateAtencion($precarga, $id);        
  475.         $this->response->setData($result);
  476.         $this->response->setCode(Codes::OK);
  477.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  478.         return new Response($serializedEntity);
  479.     }
  481.      /**
  482.      * @Route("/atencion/precarga/finalizar/{id}", name="operador_precargas_atencion_modificacion")
  483.      * @return type
  484.      */
  485.     public function precargaAtencionModificacionAction($id) {
  486.         $this->validarAtencion();
  487.         $this->setTitle("Finalizar Atención");
  488.         $this->addBreadCrumb("Inicio - Atención", false, "atencion_home");
  489.         $this->addBreadCrumb("Listado de atenciones", false, "atencion_precarga_atenciones_listado");
  490.         $this->addBreadCrumb("Finalizar Atención", true);
  491.         $tiposTramite = $this->get(McTiposTramiteHandler::class)->getTiposTramite();
  492.         $this->data['data'] = $id;
  493.         $this->data['tiposTramite'] = $tiposTramite;
  494.         return $this->render(
  495.                         '@NoahtechSistemasInterjama/atencion/precargas_atencion/finalizar.html.twig', $this->data
  496.         );
  497.     }
  499.         /**
  500.      * Devuelve una atención de la precarga
  501.      *
  502.      * @Route("/atencion/ajax/precargas_atencion/{id}", name="atencion_ajax_precarga_atencion_atencion_get_by_id", methods={"GET"}, condition="request.isXmlHttpRequest()")
  503.      */
  504.     public function getPrecargaAtencionByIdAction($id) {
  505.         $this->validarAtencion();
  506.         try {
  507.             $handler = $this->get(McPrecargaHandler::class);
  508.             $precarga = $handler->getPrecargaAtencionById($id);
  509.             $this->response->setData($precarga);
  510.             $this->response->setCode(Codes::OK);
  511.         } catch (Exception $e) {
  512.             $this->response->setCode(Codes::ERROR);
  513.             $this->response->setMessage($e->getMessage());
  514.         }
  515.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  516.         return new Response($serializedEntity);
  517.     }
  519.     /**
  520.      * Modifica una precarga
  521.      *
  522.      * @Route("/atencion/ajax/precargas_atencion/finalizar/{id}", name="atencion_ajax_precarga_atencion_finalizar", methods={"POST"}, condition="request.isXmlHttpRequest()")
  523.      */
  524.     public function putUpdateAction(Request $request, $id) {
  525.         $this->validarAtencion();
  526.         $archivo = (isset($_FILES['archivo'])) ? $_FILES['archivo'] : null;                
  527.         $handler = $this->get(McPrecargaHandler::class);
  528.         $usuario = $this->getUser();
  529.         $precarga = $handler->getAtencionPrecargaFinalizarFromRequest($request, $archivo, $usuario, $id);        
  530.         $result = $handler->updateAtencion($precarga, $id);        
  531.         $this->response->setData($result);
  532.         $this->response->setCode(Codes::OK);
  533.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  534.         return new Response($serializedEntity);
  535.     }
  537.     /**
  538.      * Guarda una precarga
  539.      *
  540.      * @Route("/atencion/ajax/precargas", name="atencion_ajax_precargas_save", methods={"POST"}, condition="request.isXmlHttpRequest()")
  541.      */
  542.     public function postPrecargaSaveAction(Request $request) {
  543.         $this->validarAtencion();
  544.         try {
  545.             $handler = $this->get(McPrecargaHandler::class);
  546.             $usuario = $this->getUser();
  547.             $precarga = $handler->getPrecargaFromRequest($request, $usuario);
  548.             $result = $handler->save($precarga, $request);
  549.             $this->response->setData($result);
  550.             $this->response->setCode(Codes::OK);
  551.         } catch (Exception $e) {
  552.             $this->response->setCode(Codes::ERROR);
  553.             $this->response->setMessage($e->getMessage());
  554.         }
  555.         $serializedEntity = $this->container->get('serializer')->serialize($this->response, 'json');
  556.         return new Response($serializedEntity);
  557.     }
  559. }