/// <summary>
        /// Carga los datos de una hoja de cálculo y aplica los valores encontrados al documento de instancia
        /// </summary>
        /// <param name="hojaImportar">Hoja de cálculo a importar</param>
        /// <param name="hojaPlantilla">Hoja de cálculo de la plantilla</param>
        /// <param name="instancia">Documento de instancia destino</param>
        /// <param name="informeErrores">Lista de de informe de errores</param>
        /// <param name="plantillaDocumento"></param>
        private void ImportarHojaDeCalculo(ISheet hojaImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
                                           ResumenProcesoImportacionExcelDto resumenImportacion,
                                           IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var rolUri = plantillaDocumento.ObtenerRolDeAlias(hojaPlantilla.SheetName);

            if (rolUri != null)
            {
                try
                {
                    //Si el rol tiene implementación específica utilizarla, si no, utilizar el importador genérico de plantilla
                    var idSpringImportador = plantillaDocumento.ObtenerIdSpringDefinicionElementosPlantillaDeRol(rolUri);
                    if (ObtenerApplicationContext().ContainsObject("importador_" + idSpringImportador))
                    {
                        var importadorRol = (IImportadorExportadorRolDocumento)ObtenerApplicationContext().GetObject("importador_" + idSpringImportador);
                        importadorRol.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
                    }
                    else
                    {
                        ImportadorRolPlantillaGenerico.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
                    }
                }
                catch (Exception ex)
                {
                    LogUtil.Error(ex);
                    resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
                    {
                        IdRol   = rolUri,
                        Mensaje = "Ocurrió un error al importar el rol : " + rolUri + " : " + ex.Message
                    });
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Genera los contextos de la serie.
        /// </summary>
        /// <param name="idDimension">Identificador de la idmensión evaluada.</param>
        /// <param name="rowImportar">Fila a iterar.</param>
        /// <param name="indiceColumnaInicio">Columna donde inicia la iteración.</param>
        /// <param name="hipercuboUtil">Utilería con la información del hipercubo.</param>
        /// <param name="resumenImportacion">Resumen de la importación para agregar errores en caso de presentarse.</param>
        /// <param name="nombreHoja">Nombre de la hoja.</param>
        /// <param name="instancia">Documento de instancia.</param>
        /// <param name="plantillaDocumento">Plantilla del documento.</param>
        /// <param name="claveIdioma"></param>
        /// <returns>Diccionario con los identificadores de contexto por columna.</returns>
        private IDictionary <int, Dto.ContextoDto> GeneraContextosSeries(
            String idDimension,
            IRow rowImportar,
            int indiceColumnaInicio,
            EvaluadorHipercuboUtil hipercuboUtil,
            ResumenProcesoImportacionExcelDto resumenImportacion,
            String nombreHoja,
            DocumentoInstanciaXbrlDto instancia,
            IDefinicionPlantillaXbrl plantillaDocumento,
            string claveIdioma)
        {
            var nombreConcepto   = ObtenEtiquetaConcepto(idDimension, instancia.Taxonomia, claveIdioma);
            var contextosColumna = new Dictionary <int, Dto.ContextoDto>();
            PlantillaDimensionInfoDto plantillaDimension = null;

            if (!hipercuboUtil.configuracion.PlantillaDimensiones.TryGetValue(idDimension, out plantillaDimension))
            {
                LogUtil.Error("No existe una definición de plantilla con el identificador \"" + idDimension + "\".");
                return(contextosColumna);
            }
            PlantillaContextoDto plantillaContexto = hipercuboUtil.configuracion.PlantillasContextos.Values.First();
            var seriesEvaluadas = new Dictionary <String, int>();

            for (var indexSerie = indiceColumnaInicio; indexSerie <= rowImportar.LastCellNum; indexSerie++)
            {
                var celdaSerie = rowImportar.GetCell(indexSerie);
                if (celdaSerie != null && !celdaSerie.CellType.Equals(CellType.Blank))
                {
                    var nombreSerie = ExcelUtil.ObtenerValorCelda(celdaSerie.CellType, celdaSerie);
                    if (String.IsNullOrWhiteSpace(nombreSerie))
                    {
                        continue;
                    }
                    if (seriesEvaluadas.ContainsKey(nombreSerie))
                    {
                        resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
                        {
                            Mensaje = "No fue posible agregar la serie \"" + nombreSerie +
                                      "\", de la hoja \"" + nombreHoja +
                                      "\" renglon \"" + rowImportar.RowNum.ToString() + "\" columna \"" + celdaSerie.ColumnIndex.ToString() +
                                      "\", debido a que este nombre de serie ya fué indicado previamente en la columna \"" + seriesEvaluadas[nombreSerie] + "\".",
                        });
                        continue;
                    }
                    var miembroDimensionSerie = plantillaDimension.CreaMiembroDimension(nombreSerie);
                    var listaDimensiones      = new List <DimensionInfoDto>()
                    {
                        miembroDimensionSerie
                    };
                    var contexto = plantillaContexto.GeneraContexto(instancia, plantillaDocumento, listaDimensiones);
                    plantillaDocumento.InyectarContextoADocumentoInstancia(contexto);
                    contextosColumna.Add(celdaSerie.ColumnIndex, contexto);
                    seriesEvaluadas.Add(nombreSerie, celdaSerie.ColumnIndex);
                }
            }
            return(contextosColumna);
        }
Beispiel #3
0
        /// <summary>
        /// Genera los hechos de la fila indicada.
        /// </summary>
        /// <param name="fila">Fila que se pretende evaluar.</param>
        /// <param name="concepto">Concepto que se pretende evaluar.</param>
        /// <param name="diccionarioContextos">Diccionario de contextos.</param>
        /// <param name="instancia">Documento de instancia.</param>
        /// <param name="plantilla">Plantilla de documento.</param>
        /// <param name="resumenImportacion">Resume de importación.</param>
        /// <param name="nombreHoja">Nombre de la hoja.</param>
        public void GeneraHechos(
            IRow fila,
            ConceptoDto concepto,
            IDictionary <int, Dto.ContextoDto> diccionarioContextos,
            DocumentoInstanciaXbrlDto instancia,
            IDefinicionPlantillaXbrl plantilla,
            ResumenProcesoImportacionExcelDto resumenImportacion,
            String nombreHoja)
        {
            UnidadDto unidad   = ObtenUniadConcepto(concepto, instancia, plantilla);
            var       idUnidad = unidad == null ? null : unidad.Id;

            foreach (var indexColumna in diccionarioContextos.Keys)
            {
                ICell celda = null;
                try
                {
                    celda = fila.GetCell(indexColumna);
                    String valorHecho = String.Empty;
                    if (celda != null && !celda.CellType.Equals(CellType.Blank))
                    {
                        valorHecho = ExcelUtil.ObtenerValorCelda(celda.CellType, celda);
                    }
                    if (String.IsNullOrEmpty(valorHecho))
                    {
                        continue;
                    }
                    var contexto = diccionarioContextos[indexColumna];
                    CreaHecho(
                        valorHecho,
                        concepto,
                        contexto,
                        idUnidad,
                        instancia,
                        plantilla,
                        resumenImportacion,
                        nombreHoja,
                        fila.RowNum,
                        celda.ColumnIndex);
                }
                catch (Exception ex)
                {
                    LogUtil.Error(ex);
                    var columnaCelda = (celda == null ? 0 : celda.ColumnIndex);
                    resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
                    {
                        Mensaje = "Error al obtener el valor de la celda en la fila \"" + fila.RowNum +
                                  "\" columna \"" + columnaCelda +
                                  "\"  de la hoja \"" + nombreHoja +
                                  "\".(" + ex.Message + ")"
                    });
                }
            }
        }
Beispiel #4
0
 /// <summary>
 /// Constructor de la clase.
 /// </summary>
 /// <param name="instancia">Documento de instancia.</param>
 /// <param name="plantillaDocumento">Plantilla de definición.</param>
 public ConfiguracionReporteExcel427000(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion)
 {
     Instancia                         = instancia;
     PlantillaDocumento                = plantillaDocumento;
     ListaConceptosMiembro             = new List <ConceptoDto>();
     DiccionarioConceptosPorColumna    = new Dictionary <int, ConceptoDto>();
     NombreHoja                        = String.Empty;
     ResumenImportacion                = resumenImportacion;
     DiccionarioUnidadesPorIdConcepto  = new Dictionary <String, UnidadDto>();
     DiccionarioDecimalesPorIdConcepto = new Dictionary <String, String>();
 }
Beispiel #5
0
        /// <summary>
        /// Crea un nuevo hecho.
        /// </summary>
        /// <param name="valor">Valor del hecho.</param>
        /// <param name="concepto">Concepto del hecho.</param>
        /// <param name="contexto">Contexto del hecho.</param>
        /// <param name="idUnidad">Identificador de la unidad.</param>
        /// <param name="instancia">Documento de instancia.</param>
        /// <param name="plantilla">Plantilla del documento.</param>
        /// <param name="resumenImportacion">Detalle de la importación.</param>
        /// <param name="nombreHoja">Nombre de la hoja.</param>
        /// <param name="numeroFila">Indice de la fila.</param>
        /// <param name="numeroColumna">Indice de la columna.</param>
        private void CreaHecho(
            String valor,
            ConceptoDto concepto,
            Dto.ContextoDto contexto,
            String idUnidad,
            DocumentoInstanciaXbrlDto instancia,
            IDefinicionPlantillaXbrl plantilla,
            ResumenProcesoImportacionExcelDto resumenImportacion,
            String nombreHoja,
            int numeroFila,
            int numeroColumna)
        {
            var idHecho    = "A" + Guid.NewGuid().ToString();
            var hechoNuevo = instancia.CrearHecho(concepto.Id, idUnidad, contexto.Id, idHecho);

            if (concepto.EsTipoDatoNumerico)
            {
                if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
                {
                    hechoNuevo.Decimales = "-3";
                }
                else
                {
                    hechoNuevo.Decimales = "0";
                }
            }
            if (!ActualizarValor(concepto, valor, hechoNuevo, plantilla))
            {
                resumenImportacion.AgregarErrorFormato(
                    UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, concepto.Id),
                    nombreHoja,
                    numeroFila.ToString(),
                    numeroColumna.ToString(),
                    valor);
            }
            else
            {
                resumenImportacion.TotalHechosImportados++;
                var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
                {
                    IdConcepto     = hechoNuevo.IdConcepto,
                    IdHecho        = hechoNuevo.Id,
                    ValorImportado = valor,
                    HojaExcel      = nombreHoja,
                    Renglon        = numeroFila,
                    Columna        = numeroColumna
                };
                resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, hechoNuevo.Id));
            }

            plantilla.InyectaHechoADocumentoInstancia(hechoNuevo);
        }
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
                                             string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var maxRow        = hojaPlantilla.LastRowNum;
            var fechaDefault  = plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01");
            var idiomaDefault = instancia.Taxonomia != null && instancia.Taxonomia.IdiomasTaxonomia != null && instancia.Taxonomia.IdiomasTaxonomia.Keys.Count > 0 ?
                                instancia.Taxonomia.IdiomasTaxonomia.Keys.First() : String.Empty;

            for (var iRenglon = 0; iRenglon <= maxRow; iRenglon++)
            {
                var renglon = hojaPlantilla.GetRow(iRenglon);
                if (renglon != null)
                {
                    var maxCol = renglon.LastCellNum;

                    for (var iCol = 0; iCol <= maxCol; iCol++)
                    {
                        var valorHechoPlantilla = ExcelUtil.ObtenerValorCelda(renglon, iCol);
                        if (!String.IsNullOrEmpty(valorHechoPlantilla) && valorHechoPlantilla.StartsWith(PREFIJO_CELDA_HECHO_PLANTILLA) &&
                            valorHechoPlantilla.Length > PREFIJO_CELDA_HECHO_PLANTILLA.Length)
                        {
                            var idHechoPlantilla = valorHechoPlantilla.Substring(PREFIJO_CELDA_HECHO_PLANTILLA.Length);

                            var valorCeldaImportar = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);

                            if (!String.IsNullOrEmpty(valorCeldaImportar))
                            {
                                //Buscar el hecho de plantilla en el documento de instancia
                                var hechoInstancia =
                                    plantillaDocumento.BuscarHechoPlantillaEnHechosDocumentoInstancia(
                                        idHechoPlantilla);


                                //Si el hecho no existe crearlo en base a la plantilla
                                if (hechoInstancia == null)
                                {
                                    hechoInstancia =
                                        plantillaDocumento.CrearHechoAPartirDeIdDefinicionPlantilla(
                                            idHechoPlantilla);
                                    if (hechoInstancia != null)
                                    {
                                        hechoInstancia.NotasAlPie = ExcelUtil.ObtenerComentariosCelda(renglon, iCol, idiomaDefault);
                                        plantillaDocumento.InyectaHechoADocumentoInstancia(hechoInstancia);
                                    }
                                }
                                if (hechoInstancia != null)
                                {
                                    var conceptoImportar = instancia.Taxonomia.ConceptosPorId[hechoInstancia.IdConcepto];
                                    if (!UtilAbax.ActualizarValorHecho(conceptoImportar, hechoInstancia, valorCeldaImportar, fechaDefault))
                                    {
                                        resumenImportacion.AgregarErrorFormato(
                                            UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id),
                                            hojaAImportar.SheetName,
                                            iRenglon.ToString(),
                                            iCol.ToString(),
                                            valorCeldaImportar);
                                    }
                                    else
                                    {
                                        resumenImportacion.TotalHechosImportados++;
                                        var hechoImportado = new InformacionHechoImportadoExcelDto()
                                        {
                                            IdConcepto     = hechoInstancia.IdConcepto,
                                            IdHecho        = hechoInstancia.Id,
                                            ValorImportado = valorCeldaImportar,
                                            HojaExcel      = hojaAImportar.SheetName,
                                            Renglon        = iRenglon,
                                            Columna        = iCol
                                        };

                                        resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id));
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Beispiel #7
0
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var    nombreHoja = hojaPlantilla.SheetName;
            String idConceptoHipercubo;
            IDictionary <int, Dto.ContextoDto> diccionarioContextosSeries         = null;
            IDictionary <int, Dto.ContextoDto> diccionarioContextosCalificaciones = null;

            if (ConceptosHipercuboPorHoja.TryGetValue(nombreHoja, out idConceptoHipercubo))
            {
                HipercuboReporteDTO hiperCubo = ObtenConfiguracionHipercubo(idConceptoHipercubo, instancia, plantillaDocumento);
                HipercuboReporteDTO hiperCuboCalificaciones = null;
                var miembroCalificadora = String.Empty;

                for (var indexRow = hojaPlantilla.FirstRowNum; indexRow <= hojaPlantilla.LastRowNum; indexRow++)
                {
                    var rowPlantilla  = hojaPlantilla.GetRow(indexRow);
                    var rowImportar   = hojaAImportar.GetRow(indexRow);
                    var celdaConcepto = rowPlantilla.GetCell(rowPlantilla.FirstCellNum);
                    if (celdaConcepto == null ||
                        !celdaConcepto.CellType.Equals(CellType.String) ||
                        String.IsNullOrWhiteSpace(celdaConcepto.StringCellValue) ||
                        !celdaConcepto.StringCellValue.Contains("idConcepto"))
                    {
                        continue;
                    }
                    var         elementosCelda = celdaConcepto.StringCellValue.Split(';');
                    var         idConcepto     = elementosCelda[1];
                    ConceptoDto concepto;
                    var         indiceColumnaImprimir = celdaConcepto.ColumnIndex + 1;
                    if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
                    {
                        if (concepto.EsDimension ?? false)
                        {
                            diccionarioContextosSeries =
                                GeneraContextosSeries(
                                    concepto.Id,
                                    rowImportar,
                                    indiceColumnaImprimir,
                                    hiperCubo.Utileria,
                                    resumenImportacion,
                                    hojaAImportar.SheetName,
                                    instancia,
                                    plantillaDocumento, "es");
                            if (diccionarioContextosSeries.Count > 0)
                            {
                                EliminarHechos(hojaPlantilla, instancia);
                            }
                        }
                        else if (concepto.EsMiembroDimension ?? false)
                        {
                            if (hiperCuboCalificaciones == null)
                            {
                                hiperCuboCalificaciones = ObtenConfiguracionHipercubo("ar_pros_SecuritiesRatingTable", instancia, plantillaDocumento);
                            }
                            diccionarioContextosCalificaciones = GeneraContextosCalificaciones(
                                concepto,
                                diccionarioContextosSeries,
                                hiperCuboCalificaciones.Utileria,
                                instancia,
                                plantillaDocumento);
                        }
                        else if (!concepto.EsAbstracto ?? false && !concepto.EsHipercubo)
                        {
                            var diccionarioContextos = diccionarioContextosSeries;
                            if (ConceptosCalificaciones.Contains(concepto.Id))
                            {
                                if (hiperCuboCalificaciones != null && diccionarioContextosCalificaciones != null)
                                {
                                    diccionarioContextos = diccionarioContextosCalificaciones;
                                }
                            }
                            GeneraHechos(rowImportar, concepto, diccionarioContextos, instancia, plantillaDocumento, resumenImportacion, hojaAImportar.SheetName);
                        }
                    }
                }
            }
        }
Beispiel #8
0
        /// <summary>
        /// Procesa un renglón de la tabla de personas responsables importando su contenido
        /// </summary>

        /// <returns></returns>
        private int ImportarRenglonFigura(int numRow, string idMiembroFiguraActual, ISheet hojaAImportar, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion)
        {
            var      institucionesActuales = new Dictionary <string, int>();
            DateTime fechaInicio           = DateTime.MinValue;
            DateTime fechaFin = DateTime.MinValue;

            if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2014_12_31"), out fechaFin)
                &&
                XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2014_12_31"), out fechaInicio))
            {
                //Si inicia un tipo de figura

                int lastRowNum = hojaAImportar.LastRowNum;
                //Mientras no se termine el documento o no se encuentre el inicio de otra figura
                while (numRow <= lastRowNum)
                {
                    var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_FIGURA);

                    if (valorCelda != null && _mapeoMiembrosDimension.ContainsKey(valorCelda.Trim()))
                    {
                        break;
                    }

                    var valorInstitucion = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_INSTITUCION);
                    var valorLeyenda     = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_LEYENDA);
                    var valorNombre      = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_NOMBRE);
                    var valorCargo       = ExcelUtil.ObtenerValorCelda(hojaAImportar, numRow, COL_CONCEPTO_CARGO);


                    if (!String.IsNullOrEmpty(valorInstitucion) && !String.IsNullOrEmpty(valorNombre) && !String.IsNullOrEmpty(valorCargo))
                    {
                        if (!valoresAnterioresBorrados)
                        {
                            ReporteXBRLUtil.EliminarHechosConceptos(ID_CONCEPTO_PERSONAS, instancia);
                            ReporteXBRLUtil.EliminarHechosConceptos(ID_CONCEPTO_INSTITUCION, instancia);
                            valoresAnterioresBorrados = true;
                        }
                        var dimensionFigura = new DimensionInfoDto()
                        {
                            Explicita        = true,
                            IdDimension      = ID_DIMENSION_FIGURA,
                            QNameDimension   = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_FIGURA]),
                            IdItemMiembro    = idMiembroFiguraActual,
                            QNameItemMiembro = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[idMiembroFiguraActual])
                        };
                        var dimensionInstitucion = new DimensionInfoDto()
                        {
                            Explicita      = false,
                            IdDimension    = ID_DIMENSION_TYPED_INSTITUCION,
                            QNameDimension = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_TYPED_INSTITUCION])
                        };

                        var dimensionPersona = new DimensionInfoDto()
                        {
                            Explicita      = false,
                            IdDimension    = ID_DIMENSION_TYPED_PERSONA,
                            QNameDimension = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ID_DIMENSION_TYPED_PERSONA])
                        };

                        if (!institucionesActuales.ContainsKey(valorInstitucion))
                        {
                            //Agregar hechos de institución y leyenda
                            dimensionInstitucion.ElementoMiembroTipificado = String.Format(_templateTypedMemeberInstitucion, secuenciaInstitucion);
                            institucionesActuales[valorInstitucion]        = secuenciaInstitucion;
                            secuenciaInstitucion++;
                            ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_INSTITUCION[0]],
                                                 valorInstitucion,
                                                 new List <DimensionInfoDto>()
                            {
                                dimensionFigura, dimensionInstitucion
                            },
                                                 fechaInicio, fechaFin,
                                                 plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
                                                 instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_INSTITUCION);

                            ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_INSTITUCION[1]],
                                                 valorLeyenda,
                                                 new List <DimensionInfoDto>()
                            {
                                dimensionFigura, dimensionInstitucion
                            },
                                                 fechaInicio, fechaFin,
                                                 plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
                                                 instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_LEYENDA);
                        }
                        else
                        {
                            dimensionInstitucion.ElementoMiembroTipificado = String.Format(_templateTypedMemeberInstitucion, institucionesActuales[valorInstitucion]);
                        }

                        //Agregar hechos de nombre y cargo
                        dimensionPersona.ElementoMiembroTipificado = String.Format(_templateTypedMemeberPerson, secuenciaPersona++);

                        ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_PERSONAS[0]],
                                             valorNombre,
                                             new List <DimensionInfoDto>()
                        {
                            dimensionFigura, dimensionInstitucion, dimensionPersona
                        },
                                             fechaInicio, fechaFin,
                                             plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
                                             instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_NOMBRE);

                        ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[ID_CONCEPTO_PERSONAS[1]],
                                             valorCargo,
                                             new List <DimensionInfoDto>()
                        {
                            dimensionFigura, dimensionInstitucion, dimensionPersona
                        },
                                             fechaInicio, fechaFin,
                                             plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
                                             instancia, plantillaDocumento, resumenImportacion, hojaAImportar, numRow, COL_CONCEPTO_CARGO);
                    }

                    numRow++;
                }
            }


            return(numRow);
        }
Beispiel #9
0
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
        {
            this.Inicializar(instancia, plantillaDocumento, rol);


            String idMiembroFiguraActual = null;
            int    iRow       = 0;
            int    lastRowNum = hojaAImportar.LastRowNum;

            while (iRow <= lastRowNum)
            {
                //Si inicia un tipo de figura
                var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRow, COL_CONCEPTO_FIGURA);
                if (!String.IsNullOrEmpty(valorCelda) && _mapeoMiembrosDimension.ContainsKey(valorCelda.Trim()))
                {
                    idMiembroFiguraActual = _mapeoMiembrosDimension[valorCelda.Trim()];
                    if (idMiembroFiguraActual != null)
                    {
                        iRow = ImportarRenglonFigura(iRow + 1, idMiembroFiguraActual, hojaAImportar, instancia, plantillaDocumento, resumenImportacion);
                    }
                }
                else
                {
                    iRow++;
                }
            }
        }
Beispiel #10
0
        /// <summary>
        /// Obtiene la configuración para procesar los elementos de la hoja actual.
        /// </summary>
        /// <param name="hojaPlantilla">Hoja de plantilla que se pertende procesar.</param>
        /// <param name="instancia">Documento de instancia que se procesa.</param>
        /// <param name="plantillaDocumento">Plantilla de la taxonomía que se procesa.</param>
        /// <param name="resumenImportacion">Detalle de la importación.</param>
        /// <returns>Configuración del documento a procesar.</returns>
        private ConfiguracionReporteExcel427000 GeneraConfiguracionReporte(ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion = null)
        {
            var configuracion = new ConfiguracionReporteExcel427000(instancia, plantillaDocumento, resumenImportacion);

            configuracion.NombreHoja = hojaPlantilla.SheetName;
            for (var indexRow = 0; indexRow < hojaPlantilla.LastRowNum; indexRow++)
            {
                var row           = hojaPlantilla.GetRow(indexRow);
                var currentColumn = row.FirstCellNum;
                var cell          = row.GetCell(currentColumn);
                if (cell != null && cell.CellType.Equals(CellType.String))
                {
                    var valorCelda = cell.StringCellValue;
                    if (valorCelda.Contains("idConcepto"))
                    {
                        var             splitCell  = valorCelda.Split(';');
                        var             idConcepto = splitCell[1];
                        Dto.ConceptoDto concepto;
                        if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
                        {
                            if (concepto.EsHipercubo)
                            {
                                configuracion.HipercuboReporte = ObtenConfiguracionHipercubo(concepto.Id, instancia, plantillaDocumento);
                            }
                            else if (concepto.EsMiembroDimension ?? false)
                            {
                                configuracion.ListaConceptosMiembro.Add(concepto);
                            }
                            else if (!(concepto.EsDimension ?? false) && !(concepto.EsAbstracto ?? false))
                            {
                                for (var indexColumn = currentColumn; indexColumn < row.LastCellNum; indexColumn++)
                                {
                                    var celdaConceptoItem = row.GetCell(indexColumn);
                                    if (celdaConceptoItem != null && celdaConceptoItem.CellType.Equals(CellType.String))
                                    {
                                        var valorCeldaItem = celdaConceptoItem.StringCellValue;
                                        if (valorCeldaItem.Contains("idConcepto"))
                                        {
                                            var         splitItems     = valorCeldaItem.Split(';');
                                            var         idConceptoItem = splitItems[1];
                                            ConceptoDto conceptoItem;
                                            if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConceptoItem, out conceptoItem))
                                            {
                                                configuracion.DiccionarioConceptosPorColumna[indexColumn] = conceptoItem;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            return(configuracion);
        }
Beispiel #11
0
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var         configuracion = GeneraConfiguracionReporte(hojaPlantilla, instancia, plantillaDocumento, resumenImportacion);
            var         diccionarioEtiquetasMiembro = configuracion.ObtenDiccionarioEtiquetasMiembros(rol);
            ConceptoDto conceptoMiembroActual       = null;

            for (var indexRow = hojaAImportar.FirstRowNum; indexRow < hojaAImportar.LastRowNum; indexRow++)
            {
                var fila = hojaAImportar.GetRow(indexRow);
                if (fila != null)
                {
                    var celda = fila.GetCell(fila.FirstCellNum);
                    if (celda != null)
                    {
                        var         valor = ExcelUtil.ObtenerValorCelda(celda.CellType, celda).Trim();
                        ConceptoDto conceptoMiembro;
                        if (diccionarioEtiquetasMiembro.TryGetValue(valor, out conceptoMiembro))
                        {
                            conceptoMiembroActual = conceptoMiembro;
                        }
                        else if (conceptoMiembroActual != null)
                        {
                            GeneraHechos(fila, conceptoMiembroActual, configuracion);
                        }
                    }
                }
            }
        }
        public override ResultadoOperacionDto ImportarDatosExcel(Stream archivoEntrada, DocumentoInstanciaXbrlDto instancia, IDictionary <string, bool> conceptosDescartar = null, IList <string> hojasDescartar = null)
        {
            var res            = new ResultadoOperacionDto();
            var resumenProceso = new ResumenProcesoImportacionExcelDto()
            {
                HechosImportados      = new Dictionary <string, List <InformacionHechoImportadoExcelDto> >(),
                HechosSobreescritos   = new List <InformacionHechoSobreescritoDto>(),
                InformeErrores        = new List <InformeErrorImportacion>(),
                TotalHechosImportados = 0
            };

            res.Resultado = true;


            string entryPointTax = instancia.EspacioNombresPrincipal;

            try
            {
                //Verificar si existe la plantilla para la taxonomía
                if (entryPointTax != null)
                {
                    entryPointTax = entryPointTax.Replace(_puntoXSD, String.Empty).Replace(_guion, _caracterReemplazo).Replace(_dosPuntos, _caracterReemplazo).
                                    Replace(_diagonal, _caracterReemplazo).Replace(_punto, _caracterReemplazo);
                    if (ObtenerApplicationContext().ContainsObject(entryPointTax))
                    {
                        var plantillaDocumento = (IDefinicionPlantillaXbrl)ObtenerApplicationContext().GetObject(entryPointTax);
                        plantillaDocumento.Inicializar(instancia);
                        if (plantillaDocumento.ObtenerRutaPlantillaExcel() != null)
                        {
                            using (
                                var streamPlantilla =
                                    Assembly.GetExecutingAssembly()
                                    .GetManifestResourceStream(plantillaDocumento.ObtenerRutaPlantillaExcel()))
                            {
                                if (streamPlantilla != null)
                                {
                                    Stream streamPlantillaEvaluada = evaluaElementosDescartarPlantillaExcel(streamPlantilla, conceptosDescartar, hojasDescartar, instancia.Taxonomia);

                                    var workBookImportar  = WorkbookFactory.Create(archivoEntrada);
                                    var workBookPlantilla = WorkbookFactory.Create(streamPlantillaEvaluada);

                                    if (plantillaDocumento.ValidarPlantillaExcelImportacion(workBookImportar, resumenProceso))
                                    {
                                        for (var iItem = 0; iItem < workBookPlantilla.NumberOfSheets; iItem++)
                                        {
                                            var hojaImportar =
                                                workBookImportar.GetSheet(workBookPlantilla.GetSheetAt(iItem).SheetName);
                                            if (hojaImportar != null)
                                            {
                                                ImportarHojaDeCalculo(hojaImportar, workBookPlantilla.GetSheetAt(iItem), instancia, resumenProceso, plantillaDocumento);
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine(ex.StackTrace);
                resumenProceso.InformeErrores.Add(new InformeErrorImportacion()
                {
                    Mensaje = "Ocurrió un error al importar el archivo:" + ex.Message
                });
                res.Resultado = false;
            }
            res.InformacionExtra = resumenProceso;

            return(res);
        }