public async Task <IHttpActionResult> AlmacenarDocumentoPruebaXBRL()
        {
            LogUtil.Info("Petición de Almacenamiento de documento de instancia recibida");
            var resultado = new ResultadoOperacionDto();

            try
            {
                var root = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/uploads");


                string rutaArchivo   = null;
                string nombreArchivo = null;

                var parametros  = new Dictionary <string, string>();
                var valorParams = "";

                parametros.Add("fechaTrimestre", "2017-03-31");
                parametros.Add("cvePizarra", "WALMEX");
                parametros.Add("cveUsuario", "1");
                //parametros.Add("cveFideicomitente", "FIDECCD");
                parametros.Add("idEnvio", "100291");
                parametros.Add("acuse", "AC443549466763-rqqszr");



                rutaArchivo = "C:/Users/Loyola/Downloads/ifrsxbrl_WALMEX_2017-1_.zip";

                nombreArchivo = "FIDECCD3T2015.zip";

                using (var streamArchivo = new FileStream(rutaArchivo, FileMode.Open))
                {
                    resultado = AlmacenarDocumentoInstanciaService.GuardarDocumentoInstanciaXBRL(streamArchivo, rutaArchivo, nombreArchivo, parametros);
                    //Enviar mensaje para procesar el documento
                }
                try
                {
                    File.Delete(rutaArchivo);
                }
                catch (Exception e)
                {
                    LogUtil.Error(e);
                }
            }
            catch (Exception ex)
            {
                LogUtil.Error(ex);
                resultado           = new ResultadoOperacionDto();
                resultado.Resultado = false;
                resultado.Mensaje   = "Ocurrió un error general al almacenar el archivo XBRL:" + ex.Message;
                resultado.Excepcion = ex.StackTrace;
            }
            var jsonResult = this.Json(resultado);

            return(jsonResult);
        }
Ejemplo n.º 2
0
        /// <inheritdoc/>
        public ResultadoOperacionDto ProcesarXbrlSobre(string rutaArchivo, string cvePizarra)
        {
            ResultadoOperacionDto resultadoOperacionDto = new ResultadoOperacionDto
            {
                Resultado = false
            };

            ResultadoRecepcionSobreXBRLDTO resultadoRecepcionSobreXBRLDTO = new ResultadoRecepcionSobreXBRLDTO();
            var pathXbrlAdjunto = "";
            var parametros      = new Dictionary <string, string>();

            parametros.Add("cvePizarra", cvePizarra);

            //Se obtiene el objeto ResultadoRecepcionSobreXBRLDTO de la ubicación especificada.
            resultadoOperacionDto = ObtenerSobreXbrl(rutaArchivo);

            if (resultadoOperacionDto.Resultado)
            {
                resultadoRecepcionSobreXBRLDTO = (ResultadoRecepcionSobreXBRLDTO)resultadoOperacionDto.InformacionExtra;
            }

            if (resultadoRecepcionSobreXBRLDTO != null)
            {
                //Llamamos al servicio para obtener el xbrl adjunto.
                resultadoOperacionDto = AlmacenarDocumentoInstanciaService.ObtenerPathTemporalXBRLAdjunto(resultadoRecepcionSobreXBRLDTO);
                pathXbrlAdjunto       = (String)resultadoOperacionDto.InformacionExtra;
            }

            if (resultadoOperacionDto.Resultado)
            {
                resultadoOperacionDto = EmpresaService.ValidarTickersXbrlSobre(cvePizarra, resultadoRecepcionSobreXBRLDTO.claveCotizacion);
                if (resultadoOperacionDto.Resultado)
                {
                    parametros.Add("cveFideicomitente", resultadoRecepcionSobreXBRLDTO.claveCotizacion);

                    ResultadoOperacionDto resultadoOperacionObtenerPeriodicidadDto = new ResultadoOperacionDto();
                    resultadoOperacionObtenerPeriodicidadDto = DocumentoInstanciaService.ObtenerPeriodicidadReportePorEspacioNombresPrincipal(resultadoRecepcionSobreXBRLDTO.espacioNombresArchivoAdjunto);

                    //Revisar que periodicidad es la taxonomia para asignar valorPeroiodo o fechaTrimestre según sea el caso.
                    if (resultadoOperacionDto.Resultado)
                    {
                        PeriodicidadReporte periodicidadReporte = (PeriodicidadReporte)resultadoOperacionObtenerPeriodicidadDto.InformacionExtra;

                        switch (periodicidadReporte.Nombre)
                        {
                        case "Anual":
                            //para anual el validador solo verifica que sea un año.
                            parametros.Add("valorPeroiodo", resultadoRecepcionSobreXBRLDTO.anioReportado.ToString());
                            break;

                        case "Mensual":
                            //para anexto T solo se verifica que el periodo sea de un año y mes válido.
                            if (resultadoRecepcionSobreXBRLDTO.mesReportado != null && resultadoRecepcionSobreXBRLDTO.mesReportado.ToString().Count() > 0)
                            {
                                string mesReportado = resultadoRecepcionSobreXBRLDTO.mesReportado.ToString().Count() == 1 ? "0" + resultadoRecepcionSobreXBRLDTO.mesReportado.ToString() : resultadoRecepcionSobreXBRLDTO.mesReportado.ToString();
                                parametros.Add("valorPeroiodo", resultadoRecepcionSobreXBRLDTO.anioReportado.ToString() + "-" + mesReportado + "-01");
                            }
                            break;

                        case "Trimestral":
                            //para trimestrales se válida la fecha fin de periodo.
                            parametros.Add("fechaTrimestre", UtilAbax.obtenerFechaTrimestre(resultadoRecepcionSobreXBRLDTO.anioReportado.Value, resultadoRecepcionSobreXBRLDTO.trimestreReportado));
                            break;

                        default:
                            break;
                        }
                    }

                    if (!pathXbrlAdjunto.Equals(""))
                    {
                        resultadoOperacionDto = ValidarDocumentoInstanciaService.ValidarDocumentoInstanciaXBRL(null, pathXbrlAdjunto, resultadoRecepcionSobreXBRLDTO.nombreArchivoAdjunto, parametros);

                        if (resultadoOperacionDto.Resultado)
                        {
                            resultadoOperacionDto = AlmacenarDocumentoInstanciaService.GuardarDocumentoInstanciaXBRL(null, pathXbrlAdjunto, resultadoRecepcionSobreXBRLDTO.nombreArchivoAdjunto, parametros);

                            //Se mandan los mensajes de distribucion a la cola.

                            /*if (resultado.Resultado)
                             * {
                             *  var identificadorDocNuevo = resultado.InformacionExtra as long[];
                             *
                             *  var idDocmentoInstancia = identificadorDocNuevo[0];
                             *  var idVersionDocumento = identificadorDocNuevo[1];
                             *  if (USAR_QUEUE)
                             *  {
                             *      var envioMensajes = (ProcesarDocumentoXBRLEmsGateway)ServiceLocator.ObtenerFabricaSpring().GetObject("ProcesarDocumentoXBRLGateway");
                             *      envioMensajes.EnviarSolicitudProcesarXBRL(idDocmentoInstancia, idVersionDocumento);
                             *  }
                             * }*/
                        }
                    }
                }
            }

            return(resultadoOperacionDto);
        }
        public async Task <IHttpActionResult> ObtenrFirmasXBRLSobre()
        {
            LogUtil.Info("Petición de obtención de firmas de XBRL Sobre");
            var resultado = new ResultadoOperacionDto();

            try
            {
                var root     = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/uploads");
                var provider = new MultipartFormDataStreamProvider(root);
                await Request.Content.ReadAsMultipartAsync(provider);

                var    fileData      = provider.FileData.FirstOrDefault();
                string rutaArchivo   = null;
                string nombreArchivo = null;
                if (fileData != null)
                {
                    var parametros  = new Dictionary <string, string>();
                    var valorParams = "";
                    foreach (var key in provider.FormData.AllKeys)
                    {
                        parametros.Add(key, provider.FormData[key]);
                        valorParams += key + ":" + provider.FormData[key] + ";";
                    }

                    rutaArchivo   = fileData.LocalFileName;
                    nombreArchivo = fileData.Headers.ContentDisposition.FileName ?? "";
                    nombreArchivo = nombreArchivo.Replace("\\", "").Replace("\"", "");
                    LogUtil.Info("Nombre del archivo:" + fileData.Headers.ContentDisposition.FileName + ": Parámetros de la petición:" + valorParams);
                    using (var streamArchivo = new FileStream(rutaArchivo, FileMode.Open))
                    {
                        resultado = AlmacenarDocumentoInstanciaService.ObtenerFirmasXBRLSobre(streamArchivo, rutaArchivo, nombreArchivo);
                    }
                    try
                    {
                        File.Delete(rutaArchivo);
                    }
                    catch (Exception e)
                    {
                        LogUtil.Error(e);
                    }
                }
                else
                {
                    LogUtil.Info("Petición de obtención de firmas no contiene ningún archivo adjunto");
                    resultado           = new ResultadoOperacionDto();
                    resultado.Resultado = false;
                    resultado.Mensaje   = "Falta archivo de instancia XBRL Sobre a validar";
                }
            }
            catch (Exception ex)
            {
                LogUtil.Error(ex);
                resultado           = new ResultadoOperacionDto();
                resultado.Resultado = false;
                resultado.Mensaje   = "Ocurrió un error general al obtener las firmas del sobre XBRL:" + ex.Message;
                resultado.Excepcion = ex.StackTrace;
            }
            var jsonResult = this.Json(resultado);

            return(jsonResult);
        }
        public async Task <IHttpActionResult> AlmacenarDocumentoXBRLDirecto()
        {
            LogUtil.Info("Petición de Almacenamiento de documento de instancia recibida, no se aplicará validación");
            var resultado = new ResultadoOperacionDto();

            try
            {
                var root     = System.Web.HttpContext.Current.Server.MapPath("~/App_Data/uploads");
                var provider = new MultipartFormDataStreamProvider(root);
                await Request.Content.ReadAsMultipartAsync(provider);

                var    fileData      = provider.FileData.FirstOrDefault();
                string rutaArchivo   = null;
                string nombreArchivo = null;
                if (fileData != null)
                {
                    var parametros = new Dictionary <string, string>();
                    foreach (var key in provider.FormData.AllKeys)
                    {
                        parametros.Add(key, provider.FormData[key]);
                    }
                    rutaArchivo   = fileData.LocalFileName;
                    nombreArchivo = fileData.Headers.ContentDisposition.FileName ?? "";
                    nombreArchivo = nombreArchivo.Replace("\\", "").Replace("\"", "");
                    LogUtil.Info("Nombre del archivo:" + fileData.Headers.ContentDisposition.FileName);
                    using (var streamArchivo = new FileStream(rutaArchivo, FileMode.Open))
                    {
                        resultado = AlmacenarDocumentoInstanciaService.GuardarDocumentoInstanciaXBRL(streamArchivo, rutaArchivo, nombreArchivo.Trim(), parametros);
                        //Enviar mensaje para procesar el documento
                        var identificadorDocNuevo = resultado.InformacionExtra as long[];

                        if (resultado.Resultado)
                        {
                            var idDocmentoInstancia = identificadorDocNuevo[0];
                            var idVersionDocumento  = identificadorDocNuevo[1];

                            if (USAR_QUEUE)
                            {
                                var envioMensajes = (ProcesarDocumentoXBRLEmsGateway)ServiceLocator.ObtenerFabricaSpring().GetObject("ProcesarDocumentoXBRLGateway");
                                envioMensajes.EnviarSolicitudProcesarXBRL(idDocmentoInstancia, idVersionDocumento);
                            }
                            else
                            {
                                var procesador = (IProcesarDistribucionDocumentoXBRLService)ServiceLocator.ObtenerFabricaSpring().GetObject("ProcesarDistribucionDocumentoXBRLService");
                                procesador.DistribuirDocumentoInstanciaXBRL(idDocmentoInstancia, idVersionDocumento, new Dictionary <string, object>());
                            }
                        }
                    }
                    try
                    {
                        File.Delete(rutaArchivo);
                    }
                    catch (Exception e)
                    {
                        LogUtil.Error(e);
                    }
                }
                else
                {
                    LogUtil.Info("Petición de Almacenamiento de documento de instancia no contiene ningún archivo adjunto");
                    resultado           = new ResultadoOperacionDto();
                    resultado.Resultado = false;
                    resultado.Mensaje   = "Falta archivo de instancia XBRL a validar";
                }
            }
            catch (Exception ex)
            {
                LogUtil.Error(ex);
                resultado           = new ResultadoOperacionDto();
                resultado.Resultado = false;
                resultado.Mensaje   = "Ocurrió un error general al almacenar el archivo XBRL:" + ex.Message;
                resultado.Excepcion = ex.StackTrace;
            }
            var jsonResult = this.Json(resultado);

            return(jsonResult);
        }