/// <summary>
        /// Crea un hecho y lo inyecta al documento de instancia y a la tupla padre
        /// </summary>
        /// <param name="hechoEnTupla"></param>
        /// <param name="idConcepto"></param>
        /// <param name="instancia"></param>
        /// <returns></returns>
        private AbaxXBRLCore.Viewer.Application.Dto.HechoDto CrearHechoEnTupla(AbaxXBRLCore.Viewer.Application.Dto.HechoDto tupla, string idConcepto, DocumentoInstanciaXbrlDto instancia,
                                                                               Model.IDefinicionPlantillaXbrl plantillaDocumento, string idContextoGeneral)
        {
            var idHecho  = "INV_H_" + Guid.NewGuid().ToString();
            var concepto = instancia.Taxonomia.ConceptosPorId[idConcepto];
            List <MedidaDto> listaMedidas = null;
            string           idUnidad     = null;
            var decimales = "";

            if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
            {
                idUnidad  = "moneda_reporte";
                decimales = "2";
            }
            else if (concepto.EsTipoDatoNumerico)
            {
                idUnidad  = "pure";
                decimales = "2";
            }

            var hechoNuevo = instancia.CrearHecho(idConcepto, idUnidad, idContextoGeneral, idHecho);

            hechoNuevo.Decimales = decimales;
            plantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo);
            tupla.Hechos.Add(hechoNuevo.Id);
            return(hechoNuevo);
        }
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol,
                                             AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var numRenglones = hojaAImportar.LastRowNum;
            var qNameEntidad = plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" +
                               plantillaDocumento.ObtenerVariablePorId("nombreEntidad");

            for (var iRenglon = _renglonInicioHechos; iRenglon <= numRenglones; iRenglon++)
            {
                var valorMarca    = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, _columnaMarca);
                var valorProducto = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, _columnaProducto);

                if (_tituloRenglonTotal.Equals(valorProducto.Trim()))
                {
                    //Fin de tabla
                    valorMarca    = _todasLasMarcas;
                    valorProducto = _todosLosProductos;
                }

                if (!String.IsNullOrEmpty(valorMarca) && !String.IsNullOrEmpty(valorProducto))
                {
                    for (var iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
                    {
                        var valorHecho = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
                        if (!String.IsNullOrEmpty(valorHecho))
                        {
                            var dimensionMarca = new DimensionInfoDto()
                            {
                                Explicita                 = false,
                                IdDimension               = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionMarca, _columnaMarca),
                                QNameDimension            = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionMarca, _columnaMarca)]),
                                ElementoMiembroTipificado = String.Format(_templateTypedMemeberMarcas, System.Web.HttpUtility.HtmlEncode(valorMarca))
                            };
                            var dimensionProducto = new DimensionInfoDto()
                            {
                                Explicita                 = false,
                                IdDimension               = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionProducto, _columnaProducto),
                                QNameDimension            = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionProducto, _columnaProducto)]),
                                ElementoMiembroTipificado = String.Format(_templateTypedMemeberProducto, System.Web.HttpUtility.HtmlEncode(valorProducto))
                            };
                            var dimensionTipoIngreso = new DimensionInfoDto()
                            {
                                Explicita        = true,
                                IdDimension      = _idDimensionTipoIngresos,
                                QNameDimension   = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[_idDimensionTipoIngresos]),
                                IdItemMiembro    = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol),
                                QNameItemMiembro = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol)]),
                            };

                            DateTime fechaInicio = DateTime.MinValue;
                            DateTime fechaFin    = DateTime.MinValue;
                            //Trimestre actual

                            if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_09_30"), out fechaFin)
                                &&
                                XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01"), out fechaInicio))
                            {
                                ActualizarValorHecho(instancia.Taxonomia.ConceptosPorId[_idElementoPrimarioIngresos],
                                                     valorHecho,
                                                     new List <DimensionInfoDto>()
                                {
                                    dimensionMarca,
                                    dimensionProducto,
                                    dimensionTipoIngreso
                                },
                                                     fechaInicio, fechaFin, qNameEntidad,
                                                     instancia, plantillaDocumento, resumenImportacion, hojaAImportar, iRenglon, iCol);
                            }
                        }
                    }
                }
            }
        }
        public void ExportarDatosDeHojaExcel(ISheet hojaAExportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, Model.IDefinicionPlantillaXbrl plantillaDocumento, String idioma)
        {
            DateTime fechaInicio = DateTime.MinValue;
            DateTime fechaFin    = DateTime.MinValue;

            //Trimestre actual

            if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_09_30"), out fechaFin)
                &&
                XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01"), out fechaInicio))
            {
                var todasLasMarcas = new DimensionInfoDto()
                {
                    Explicita                 = false,
                    IdDimension               = _idDimensionMarcas,
                    QNameDimension            = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[_idDimensionMarcas]),
                    ElementoMiembroTipificado = String.Format(_templateTypedMemeberMarcas, _todasLasMarcas)
                };
                var todosLosProductos = new DimensionInfoDto()
                {
                    Explicita                 = false,
                    IdDimension               = _idDimensionProductos,
                    QNameDimension            = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[_idDimensionProductos]),
                    ElementoMiembroTipificado = String.Format(_templateTypedMemeberProducto, _todosLosProductos)
                };


                var combinacionesMarcaProducto = ObtenerCombinacionesDimensionesMarcaProducto(instancia, fechaInicio, fechaFin);
                if (combinacionesMarcaProducto.Count > 0)
                {
                    hojaAExportar.ShiftRows(_renglonInicioHechos, hojaAExportar.LastRowNum, combinacionesMarcaProducto.Count);
                }

                var iRenglon = _renglonInicioHechos;
                foreach (var combinacion in combinacionesMarcaProducto)
                {
                    var renglon = hojaAExportar.CreateRow(iRenglon);

                    ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, _columnaMarca, ObtenerNombreMarcaOProducto(combinacion[0]), CellType.String, null);
                    ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, _columnaProducto, ObtenerNombreMarcaOProducto(combinacion[1]), CellType.String, null);

                    var dimensionTipoIngreso = new DimensionInfoDto()
                    {
                        Explicita = true,
                    };

                    var listaDimensiones = new List <DimensionInfoDto>
                    {
                        combinacion[0],
                        combinacion[1],
                        dimensionTipoIngreso
                    };

                    for (var iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
                    {
                        dimensionTipoIngreso.IdDimension      = _idDimensionTipoIngresos;
                        dimensionTipoIngreso.QNameDimension   = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[_idDimensionTipoIngresos]);
                        dimensionTipoIngreso.IdItemMiembro    = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol);
                        dimensionTipoIngreso.QNameItemMiembro = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol)]);

                        var hecho = instancia.BuscarHechos(_idElementoPrimarioIngresos, null, null, fechaInicio,
                                                           fechaFin, listaDimensiones);
                        if (hecho != null && hecho.Count > 0)
                        {
                            ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, iCol, hecho[0].Valor, CellType.Numeric, hecho[0]);
                        }
                    }
                    iRenglon++;
                }

                var numRenglones = hojaAExportar.LastRowNum;
                for (; iRenglon <= numRenglones; iRenglon++)
                {
                    if (_tituloRenglonTotal.Equals(ExcelUtil.ObtenerValorCelda(hojaAExportar, iRenglon, _columnaProducto)))
                    {
                        for (var iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
                        {
                            var tipoIngreso = new DimensionInfoDto()
                            {
                                Explicita        = true,
                                IdDimension      = _idDimensionTipoIngresos,
                                QNameDimension   = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[_idDimensionTipoIngresos]),
                                IdItemMiembro    = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol),
                                QNameItemMiembro = ObtenerQNameConcepto(instancia.Taxonomia.ConceptosPorId[ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionItemTipoIngreso, iCol)])
                            };

                            var hecho = instancia.BuscarHechos(_idElementoPrimarioIngresos, null, null, fechaInicio,
                                                               fechaFin, new List <DimensionInfoDto>()
                            {
                                todasLasMarcas, todosLosProductos, tipoIngreso
                            });
                            if (hecho != null && hecho.Count > 0)
                            {
                                ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, iCol, hecho[0].Valor, CellType.Numeric, hecho[0]);
                            }
                        }
                        break;
                    }
                }
            }
        }
        public void ImportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAImportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia,
                                             string rol, AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
        {
            //var idiomaDefault = instancia.Taxonomia != null && instancia.Taxonomia.IdiomasTaxonomia != null && instancia.Taxonomia.IdiomasTaxonomia.Keys.Count > 0 ?
            //                    instancia.Taxonomia.IdiomasTaxonomia.Keys.First() : String.Empty;
            //
            string idContextoGeneral = instancia.ContextosPorId.First().Value.Id;

            var numRenglones = hojaAImportar.LastRowNum;

            for (var iRenglon = _renglonInicioHechos; iRenglon <= numRenglones; iRenglon++)
            {
                var numColumnas = hojaAImportar.GetRow(iRenglon).LastCellNum;

                if (numColumnas > _columnaInicioHechos)
                {
                    var valorConsecutivo = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, _columnaInicioHechos);
                    if (!String.IsNullOrEmpty(valorConsecutivo))
                    {
                        //Localizar tupla

                        //Crear tupla
                        var hechoTupla = instancia.CrearHecho(_idConceptoRegistroCartera, null, null, "INV" + Guid.NewGuid().ToString());
                        plantillaDocumento.InyectaHechoADocumentoInstancia(hechoTupla);
                        hechoTupla.Hechos = new List <String>();

                        for (int iCol = _columnaInicioHechos; iCol <= numColumnas; iCol++)
                        {
                            var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
                            if (!String.IsNullOrEmpty(valorCelda))
                            {
                                var idConcepto = ExcelUtil.ObtenerValorCelda(hojaPlantilla, _renglonIdConceptos, iCol);

                                if (!String.IsNullOrEmpty(idConcepto))
                                {
                                    //buscar el hecho dentro de la tupla, si no existe, crearlo

                                    var hechoEnTupla = CrearHechoEnTupla(hechoTupla, idConcepto, instancia, plantillaDocumento, idContextoGeneral);

                                    hechoEnTupla.Valor = valorCelda;
                                    //hechoEnTupla.NotasAlPie = ExcelUtil.ObtenerComentariosCelda(hojaAImportar.GetRow(iRenglon), iCol, idiomaDefault);
                                }
                            }
                        }
                    }
                }
            }
        }
        public void ExportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAExportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Model.IDefinicionPlantillaXbrl plantillaDocumento, String idioma)
        {
            if (instancia.HechosPorIdConcepto.ContainsKey(_idConceptoRegistroCartera))
            {
                int renglonActual = _renglonInicioHechos;

                foreach (var idTupla in instancia.HechosPorIdConcepto[_idConceptoRegistroCartera])
                {
                    var tupla = instancia.HechosPorId[idTupla];
                    if (tupla.Hechos != null)
                    {
                        for (int iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
                        {
                            var idConcepto = ExcelUtil.ObtenerValorCelda(hojaPlantilla, _renglonIdConceptos, iCol);
                            var hecho      = tupla.Hechos.FirstOrDefault(x => x == idConcepto);
                            if (hecho != null)
                            {
                                ExcelUtil.AsignarValorCelda(hojaAExportar, renglonActual, iCol, instancia.HechosPorId[hecho].Valor, CellType.String, instancia.HechosPorId[hecho]);
                            }
                        }

                        renglonActual++;
                    }
                }
            }
        }
 public void ExportarRolADocumentoWord(Aspose.Words.Document word, Aspose.Words.Section section, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Model.IDefinicionPlantillaXbrl plantillaDocumento, string claveIdioma)
 {
 }
        public void ExportarDatosDeHojaExcel(ISheet hojaAExportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, Model.IDefinicionPlantillaXbrl plantillaDocumento, String idioma)
        {
            var numRenglones = hojaPlantilla.LastRowNum;

            for (var iRenglon = _renglonInicioHechos; iRenglon <= numRenglones; iRenglon++)
            {
                var idElementoPrimario = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, iRenglon, _columnaIdConcepto);
                if (idElementoPrimario != null && instancia.Taxonomia.ConceptosPorId.ContainsKey(idElementoPrimario))
                {
                    var concepto    = instancia.Taxonomia.ConceptosPorId[idElementoPrimario];
                    var EsAbstracto = concepto.EsAbstracto != null ? concepto.EsAbstracto.Value : false;
                    if (!EsAbstracto || (concepto.EsMiembroDimension != null && concepto.EsMiembroDimension.Value))
                    {
                        var idItemAjustes = _idItemMiembroSenialadoActualmenteAjustes;
                        //Si el concepto es un miembro de dimension, entonces se expresa el capital inicial para ese miembro
                        if (concepto.EsMiembroDimension != null && concepto.EsMiembroDimension.Value)
                        {
                            //Cambiar el concepto a capital contable y colocar el concepto a describir como miembro de la dimensión ajustes
                            idItemAjustes = concepto.Id;
                            concepto      = instancia.Taxonomia.ConceptosPorId[_elementosPrimarios[0]];
                        }
                        var numColumnas = hojaPlantilla.GetRow(iRenglon).LastCellNum;
                        for (int iCol = _columnaInicioHechos; iCol <= numColumnas; iCol++)
                        {
                            var valorDimensionAjustes = new DimensionInfoDto()
                            {
                                IdDimension   = _idDimensionAjustes,
                                IdItemMiembro = idItemAjustes,
                                Explicita     = true
                            };
                            var valorDimensionComponentesCapital = new DimensionInfoDto()
                            {
                                IdDimension   = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionComponentesCapital, _columnaInicioHechos),
                                IdItemMiembro = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonMiembroComponentesCapital, iCol),
                                Explicita     = true
                            };

                            if (!String.IsNullOrEmpty(valorDimensionAjustes.IdDimension) && !String.IsNullOrEmpty(valorDimensionAjustes.IdItemMiembro) &&
                                !String.IsNullOrEmpty(valorDimensionComponentesCapital.IdDimension) &&
                                !String.IsNullOrEmpty(valorDimensionComponentesCapital.IdItemMiembro))
                            {
                                DateTime fechaInicio         = DateTime.MinValue;
                                DateTime fechaFin            = DateTime.MinValue;
                                var      variableFechaFin    = hojaPlantilla.SheetName.Contains("Actual") ? "fecha_2015_09_30" : "fecha_2014_09_30";
                                var      variableFechaInicio = hojaPlantilla.SheetName.Contains("Actual") ? "fecha_2015_01_01" : "fecha_2014_01_01";

                                if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId(variableFechaFin), out fechaFin)
                                    &&
                                    XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId(variableFechaInicio), out fechaInicio))
                                {
                                    //Si es capital contable al inicio se envía de fecha de fin = fecha de inicio - 1 día
                                    //Si es capital contable al final se envía fecha de fin = fecha de fin
                                    if (iRenglon <= _renglonFinalAjustesRetrospectivos)
                                    {
                                        fechaFin = fechaInicio.AddDays(-1);
                                    }
                                    var listaDimensiones = new List <DimensionInfoDto>();

                                    if (instancia.Taxonomia.DimensionDefaults.ContainsKey(valorDimensionAjustes.IdDimension) &&
                                        !valorDimensionAjustes.IdItemMiembro.Equals(instancia.Taxonomia.DimensionDefaults[valorDimensionAjustes.IdDimension]))
                                    {
                                        listaDimensiones.Add(valorDimensionAjustes);
                                    }
                                    if (instancia.Taxonomia.DimensionDefaults.ContainsKey(valorDimensionComponentesCapital.IdDimension) &&
                                        !valorDimensionComponentesCapital.IdItemMiembro.Equals(instancia.Taxonomia.DimensionDefaults[valorDimensionComponentesCapital.IdDimension]))
                                    {
                                        listaDimensiones.Add(valorDimensionComponentesCapital);
                                    }

                                    var hechoDto = instancia.BuscarHechos(concepto.Id, null, null, fechaInicio, fechaFin,
                                                                          listaDimensiones);

                                    if (hechoDto != null && hechoDto.Count > 0)
                                    {
                                        ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, iCol, hechoDto[0].Valor,
                                                                    concepto.EsTipoDatoNumerico?
                                                                    CellType.Numeric:CellType.String
                                                                    , hechoDto[0]);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol,
                                             AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var numRenglones = hojaAImportar.LastRowNum;

            for (var iRenglon = _renglonInicioHechos; iRenglon <= numRenglones; iRenglon++)
            {
                var idElementoPrimario = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, iRenglon, _columnaIdConcepto);
                if (idElementoPrimario != null && instancia.Taxonomia.ConceptosPorId.ContainsKey(idElementoPrimario))
                {
                    var concepto    = instancia.Taxonomia.ConceptosPorId[idElementoPrimario];
                    var EsAbstracto = concepto.EsAbstracto != null ? concepto.EsAbstracto.Value : false;

                    if (!EsAbstracto || (concepto.EsMiembroDimension != null && concepto.EsMiembroDimension.Value))
                    {
                        var idItemAjustes = _idItemMiembroSenialadoActualmenteAjustes;
                        //Si el concepto es un miembro de dimension, entonces se expresa el capital inicial para ese miembro
                        if (concepto.EsMiembroDimension != null && concepto.EsMiembroDimension.Value)
                        {
                            //Cambiar el concepto a capital contable y colocar el concepto a describir como miembro de la dimensión ajustes
                            idItemAjustes = concepto.Id;
                            concepto      = instancia.Taxonomia.ConceptosPorId[_elementosPrimarios[0]];
                        }
                        var numColumnas = hojaAImportar.GetRow(iRenglon).LastCellNum;
                        for (int iCol = _columnaInicioHechos; iCol <= numColumnas; iCol++)
                        {
                            var valorCelda = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
                            if (!String.IsNullOrEmpty(valorCelda))
                            {
                                var valorDimensionAjustes = new DimensionInfoDto()
                                {
                                    IdDimension      = _idDimensionAjustes,
                                    IdItemMiembro    = idItemAjustes,
                                    QNameDimension   = instancia.Taxonomia.ConceptosPorId[_idDimensionAjustes].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[_idDimensionAjustes].Nombre,
                                    QNameItemMiembro = instancia.Taxonomia.ConceptosPorId[idItemAjustes].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idItemAjustes].Nombre,
                                    Explicita        = true
                                };
                                var idDimensionCapital = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonDimensionComponentesCapital, _columnaInicioHechos);
                                var idItemCapital      = ExcelUtil.ObtenerIdConceptoDeCelda(hojaPlantilla, _renglonMiembroComponentesCapital, iCol);

                                if (!String.IsNullOrEmpty(idItemCapital) && instancia.Taxonomia.ConceptosPorId.ContainsKey(idItemCapital))
                                {
                                    var valorDimensionComponentesCapital = new DimensionInfoDto()
                                    {
                                        IdDimension      = idDimensionCapital,
                                        IdItemMiembro    = idItemCapital,
                                        QNameDimension   = instancia.Taxonomia.ConceptosPorId[idDimensionCapital].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idDimensionCapital].Nombre,
                                        QNameItemMiembro = instancia.Taxonomia.ConceptosPorId[idItemCapital].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idItemCapital].Nombre,
                                        Explicita        = true
                                    };

                                    if (!String.IsNullOrEmpty(valorDimensionAjustes.IdDimension) && !String.IsNullOrEmpty(valorDimensionAjustes.IdItemMiembro) &&
                                        !String.IsNullOrEmpty(valorDimensionComponentesCapital.IdDimension) &&
                                        !String.IsNullOrEmpty(valorDimensionComponentesCapital.IdItemMiembro))
                                    {
                                        DateTime fechaInicio         = DateTime.MinValue;
                                        DateTime fechaFin            = DateTime.MinValue;
                                        var      variableFechaFin    = hojaPlantilla.SheetName.Contains("Actual") ? "fecha_2015_09_30" : "fecha_2014_09_30";
                                        var      variableFechaInicio = hojaPlantilla.SheetName.Contains("Actual") ? "fecha_2015_01_01" : "fecha_2014_01_01";
                                        if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId(variableFechaFin), out fechaFin)
                                            &&
                                            XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId(variableFechaInicio), out fechaInicio))
                                        {
                                            //Si es capital contable al inicio se envía de fecha de fin = fecha de inicio - 1 día
                                            //Si es capital contable al final se envía fecha de fin = fecha de fin
                                            if (iRenglon <= _renglonFinalAjustesRetrospectivos)
                                            {
                                                fechaFin = fechaInicio.AddDays(-1);
                                            }
                                            var listaDimensiones = new List <DimensionInfoDto>();

                                            if (instancia.Taxonomia.DimensionDefaults.ContainsKey(valorDimensionAjustes.IdDimension) &&
                                                !valorDimensionAjustes.IdItemMiembro.Equals(instancia.Taxonomia.DimensionDefaults[valorDimensionAjustes.IdDimension]))
                                            {
                                                listaDimensiones.Add(valorDimensionAjustes);
                                            }
                                            if (instancia.Taxonomia.DimensionDefaults.ContainsKey(valorDimensionComponentesCapital.IdDimension) &&
                                                !valorDimensionComponentesCapital.IdItemMiembro.Equals(instancia.Taxonomia.DimensionDefaults[valorDimensionComponentesCapital.IdDimension]))
                                            {
                                                listaDimensiones.Add(valorDimensionComponentesCapital);
                                            }

                                            ActualizarValorHecho(concepto, valorCelda,
                                                                 listaDimensiones,
                                                                 fechaInicio, fechaFin,
                                                                 plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" + plantillaDocumento.ObtenerVariablePorId("nombreEntidad"),
                                                                 instancia, plantillaDocumento, resumenImportacion, hojaAImportar, iRenglon, iCol
                                                                 );
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
        public void ImportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAImportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
        {
            DateTime fechaEvento         = DateTime.MinValue;
            int      numeroRenglonActual = RENGLON_INICIO_DATOS;
            var      qNameEntidad        = plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" +
                                           plantillaDocumento.ObtenerVariablePorId("nombreEntidad");
            ContextoDto contextoDestinoSimple    = null;
            ContextoDto contextoDestinoDimension = null;

            if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2016_10_12"), out fechaEvento))
            {
                contextoDestinoSimple = ObtenerContextoDestino(instancia, plantillaDocumento, qNameEntidad, fechaEvento, new List <DimensionInfoDto>());

                ActualizarValorHecho(instancia, "rel_ev_Ticker", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
                ActualizarValorHecho(instancia, "rel_ev_Date", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
                ActualizarValorHecho(instancia, "rel_ev_BusinessName", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
                ActualizarValorHecho(instancia, "rel_ev_Place", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
                ActualizarValorHecho(instancia, "rel_ev_Subject", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);

                if (!instancia.EspacioNombresPrincipal.Contains("fondos"))
                {
                    ActualizarValorHecho(instancia, "rel_ev_ForeignMarket", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
                }


                var valorTipoEvento      = ExcelUtil.ObtenerValorCelda(hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS);
                var idConceptoTipoEvento = BuscarTipoEvento(valorTipoEvento, instancia);
                if (idConceptoTipoEvento != null)
                {
                    DimensionInfoDto dimInfo = new DimensionInfoDto()
                    {
                        Explicita        = true,
                        IdDimension      = "rel_ev_RelevantEventTypesAxis",
                        QNameDimension   = instancia.Taxonomia.ConceptosPorId["rel_ev_RelevantEventTypesAxis"].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId["rel_ev_RelevantEventTypesAxis"].Nombre,
                        IdItemMiembro    = idConceptoTipoEvento,
                        QNameItemMiembro = instancia.Taxonomia.ConceptosPorId[idConceptoTipoEvento].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idConceptoTipoEvento].Nombre
                    };
                    contextoDestinoDimension = ObtenerContextoDestino(instancia, plantillaDocumento, qNameEntidad, fechaEvento, new List <DimensionInfoDto>()
                    {
                        dimInfo
                    });
                    ActualizarValorHecho(instancia, "rel_ev_RelevantEventContent", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoDimension, plantillaDocumento, resumenImportacion);
                }
            }
        }
 public void ExportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAExportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Model.IDefinicionPlantillaXbrl plantillaDocumento, string idioma)
 {
     foreach (var tipoPasivoActual in _miembrosTipoPasivo)
     {
         int renglonTipoPasivo = LocalizarRenglonTipoPasivo(hojaAExportar, tipoPasivoActual, _columnaTituloTipoPasivo);
         if (renglonTipoPasivo >= 0)
         {
             ExportarGrupoTipoPasivo(hojaAExportar, renglonTipoPasivo, tipoPasivoActual, instancia, plantillaDocumento);
         }
     }
 }
        public void ImportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAImportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
        {
            var secuenciasAsignadas = new Dictionary <string, string>();

            foreach (var ctx in instancia.ContextosPorId.Values)
            {
                var seq = ObtenerSecuenciaDeContexto(ctx, _idDimensionSecuencia);
                if (seq != null)
                {
                    if (!secuenciasAsignadas.ContainsKey(seq))
                    {
                        secuenciasAsignadas[seq] = ctx.Id;
                    }
                }
            }

            var etiquetasConceptosMiembro = ObtenerListaEtiquetasConceptosMiembro(instancia.Taxonomia, _miembrosTipoPasivo);

            foreach (var tipoPasivoActual in _miembrosTipoPasivo)
            {
                //Utilizar etiquetas
                var etiquetasTipoPasivo = TaxonomiaXbrlUtil.ObtenerEtiquetasConcepto(instancia.Taxonomia, tipoPasivoActual);
                foreach (var etqTipo in etiquetasTipoPasivo)
                {
                    int renglonTipoPasivo = LocalizarRenglonTipoPasivo(hojaAImportar, etqTipo, _columnaTituloTipoPasivo);
                    if (renglonTipoPasivo >= 0)
                    {
                        ImportarGrupoTipoPasivo(hojaAImportar, renglonTipoPasivo, tipoPasivoActual, instancia, plantillaDocumento, resumenImportacion, secuenciasAsignadas, etiquetasConceptosMiembro);
                        break;
                    }
                }
            }
        }