コード例 #1
0
        /// <summary>
        /// Elimina los hechos definidos en la hoja de importación.
        /// </summary>
        /// <param name="hojaPlantilla">Definición de la hoja.</param>
        /// <param name="instancia">Documento de instancia donde se eliminaran los hechos.</param>
        private void EliminarHechos(ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia)
        {
            var listaIdsConceptosEliminar = new List <String>();

            for (var indexRow = hojaPlantilla.FirstRowNum; indexRow <= hojaPlantilla.LastRowNum; indexRow++)
            {
                var rowPlantilla = hojaPlantilla.GetRow(indexRow);

                var primerCelda = rowPlantilla.FirstCellNum;

                if (primerCelda == -1)
                {
                    primerCelda = 0;
                }

                var celdaConcepto = rowPlantilla.GetCell(primerCelda);
                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];
                listaIdsConceptosEliminar.Add(idConcepto);
            }
            ReporteXBRLUtil.EliminarHechosConceptos(listaIdsConceptosEliminar, instancia);
        }
コード例 #2
0
        /// <summary>
        /// Retorna un flujo de bytes con los PDF's adjuntos.
        /// </summary>
        /// <param name="instancia">Documento de instancia a evaluar.</param>
        /// <returns>Flujo de bytes con los documentos ajuntos.</returns>
        public static String ObtenDocumentosAdjuntos(DocumentoInstanciaXbrlDto instancia)
        {
            var conceptosPorId             = instancia.Taxonomia.ConceptosPorId;
            var diccionarioConceptosBase64 = new Dictionary <String, String>();

            foreach (var idConcepto in conceptosPorId.Keys)
            {
                var concepto = conceptosPorId[idConcepto];
                if (concepto.TipoDato.Contains("base64BinaryItemType"))
                {
                    IList <string> idsHechos;
                    if (instancia.HechosPorIdConcepto.TryGetValue(concepto.Id, out idsHechos) && idsHechos.Count > 0)
                    {
                        var token            = String.Empty;
                        var etiquetaConcepto = ReporteXBRLUtil.obtenerEtiquetaConcepto("es", ReporteXBRLUtil.ETIQUETA_DEFAULT, idConcepto, instancia);
                        for (var indexHecho = 0; indexHecho < idsHechos.Count; indexHecho++)
                        {
                            HechoDto hecho;
                            if (instancia.HechosPorId.TryGetValue(idsHechos[indexHecho], out hecho) && !String.IsNullOrWhiteSpace(hecho.Valor))
                            {
                                var titulo = etiquetaConcepto + token;
                                diccionarioConceptosBase64[titulo] = hecho.Valor;
                                token += " ";
                            }
                        }
                    }
                }
            }
            String salida = diccionarioConceptosBase64.Count > 0 ? PDFUtil.MesclaBase64PDFs(diccionarioConceptosBase64) : null;

            return(salida);
        }
コード例 #3
0
        public override void crearParametrosReporte(DocumentoInstanciaXbrlDto instancia)
        {
            String[] idConceptosMiembro = new String[] {
                "annext_SerieTypedAxis",

                "annext_TimeIntervalAxis",
                "annext_LessThan1MonthOrLessThan30DaysMember",
                "annext_Between31And60DaysOrBetween1AndUpTo2MonthsMember",
                "annext_Between61And90DaysOrBetween2AndUpTo3MonthsMember",
                "annext_Between91And120DaysOr3ToUpTo4MonthsMember",
                "annext_Between121And150DaysOrFrom4To5MonthsMember",
                "annext_Between151And180DaysOrBetween5AndUpTo6MonthsMember",
                "annext_MoreThan180DaysOrMoreThan6MonthsMember",
                "annext_InJudicialProcessMember",
                "annext_ExtensionMember",
                "annext_TotalMember",
            };

            IDictionary <Object, Object> parametrosReporte = new Dictionary <Object, Object>();

            foreach (String idConcepto in idConceptosMiembro)
            {
                parametrosReporte.Add((idConcepto + "_HEADER"), ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, null, idConcepto, instancia));
            }

            reporteXBRLDTO.ParametrosReporte = parametrosReporte;
        }
コード例 #4
0
        public override void obtenerValoresIniciales(DocumentoInstanciaXbrlDto instancia)
        {
            String claveCotizacion = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_EMISORA, instancia);
            String moneda = ReporteXBRLUtil.obtenerValorMoneda(instancia);
            String fechaReporte = obtenerFechaReporteAnual(instancia);

            reporteXBRLDTO.ClaveCotizacion = claveCotizacion;
            reporteXBRLDTO.Moneda = moneda;
            reporteXBRLDTO.FechaReporte = fechaReporte;
        }
コード例 #5
0
 /// <summary>
 /// Inicializa el diccionario de unidades, elimina los hechos que aplican para el hipercubo.
 /// </summary>
 public void InicializaImportacion()
 {
     if (!ElementosImportacionInicializados)
     {
         InicializaUnidadesConceptos();
         var listaIdsConceptosEliminar = ObtenIdsConceptosReporte();
         ReporteXBRLUtil.EliminarHechosConceptos(listaIdsConceptosEliminar, Instancia);
         ElementosImportacionInicializados = true;
     }
 }
コード例 #6
0
        ///
        /// (non-Javadoc)
        /// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#obtenerValoresIniciales(com.hh.xbrl.abax.viewer.application.dto.DocumentoInstanciaXbrlDto)
        ////
        public override void obtenerValoresIniciales(DocumentoInstanciaXbrlDto instancia)
        {
            String nombreReporte = ReporteXBRLUtil.NOMBRE_REPORTE_FIDU;

            String  claveCotizacion = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_EMISORA, instancia);
            String  fechaReporte    = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_FECHA_CIERRE_REPORTE_2014, instancia);
            String  anio            = fechaReporte.Substring(0, fechaReporte.IndexOf("-"));
            String  trimestre       = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_NUMERO_TRIMESTRE, instancia);
            String  moneda          = ReporteXBRLUtil.obtenerValorMoneda(instancia);
            Boolean consolidado     = false;
            String  fideicomiso     = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_NUMERO_FIDEICOMISO, instancia);
            String  fechaCreacion   = DateTime.Now.ToString(ReporteXBRLUtil.FORMATO_FECHA_CREACION);

            if (reporteXBRLDTO.Taxonomia.Equals(ReportConstants.CLAVE_CCD))
            {
                consolidado = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToUpper().Trim().Equals(ReportConstants.VALOR_SI) ||
                              ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToLower().Trim().Equals(ReportConstants.VALOR_SI_TRUE) ||
                              ReporteXBRLUtil.obtenerValorHecho(ReportConstants.NOMBRE_CONCEPTO_CCD_CONSOLIDADO, instancia).ToLower().Trim().Equals(ReportConstants.VALOR_SI_2) ? true : false;

                reporteXBRLDTO.AplicaConsolidado = true;
            }
            else
            {
                reporteXBRLDTO.AplicaConsolidado = false;
            }

            reporteXBRLDTO.ClaveCotizacion = claveCotizacion;
            reporteXBRLDTO.FechaReporte    = fechaReporte;
            reporteXBRLDTO.RazonSocial     = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_NOMBRE_RAZON_SOCIAL, instancia);
            reporteXBRLDTO.Anio            = anio;
            reporteXBRLDTO.Trimestre       = trimestre;
            reporteXBRLDTO.Moneda          = moneda;
            reporteXBRLDTO.Consolidado     = consolidado;
            reporteXBRLDTO.Fideicomiso     = fideicomiso;
            reporteXBRLDTO.FechaCreacion   = fechaCreacion;

            if (claveCotizacion != null && fechaReporte != null && trimestre != null && moneda != null && consolidado != null)
            {
                nombreReporte = nombreReporte.
                                Replace(ReporteXBRLUtil.CLAVE_COTIZACION, claveCotizacion).
                                Replace(ReporteXBRLUtil.ANIO, anio).
                                Replace(ReporteXBRLUtil.TRIMESTRE, trimestre).
                                Replace(ReporteXBRLUtil.MONEDA, moneda).
                                Replace(ReporteXBRLUtil.CONSOLIDACION, (consolidado ? ReporteXBRLUtil.CONSOLIDADO : ReporteXBRLUtil.NO_CONSOLIDADO)).
                                Replace(ReporteXBRLUtil.FIDEICOMISO, fideicomiso).
                                Replace(ReporteXBRLUtil.FECHA_CREACION, fechaCreacion);

                reporteXBRLDTO.NombreReporte = nombreReporte;
            }
        }
コード例 #7
0
        /// <summary>
        /// Genera nombre legible de contexto
        /// </summary>
        /// <param name="ctxNuevo">Contexto origen</param>
        /// <returns>Nombre propuesto</returns>
        private static string ProponerNombreContexto(ContextoDto ctxNuevo, DocumentoInstanciaXbrlDto instancia)
        {
            StringBuilder sb = new StringBuilder();

            sb.Append("ctx");
            //tipo de periodo - fechas
            if (ctxNuevo.Periodo.Tipo == PeriodoDto.ParaSiempre)
            {
                sb.Append("_porSiempre");
            }
            else if (ctxNuevo.Periodo.Tipo == PeriodoDto.Duracion)
            {
                sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInicio) + "_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaFin));
            }
            else
            {
                sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInstante));
            }
            //Dimensiones
            var dimTotales = new List <DimensionInfoDto>();

            if (ctxNuevo.ValoresDimension != null)
            {
                dimTotales.AddRange(ctxNuevo.ValoresDimension);
            }
            if (ctxNuevo.Entidad.ValoresDimension != null)
            {
                dimTotales.AddRange(ctxNuevo.Entidad.ValoresDimension);
            }
            foreach (var dimension in dimTotales)
            {
                if (dimension.Explicita)
                {
                    sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdItemMiembro].Nombre);
                }
                else
                {
                    if (String.IsNullOrEmpty(dimension.ElementoMiembroTipificado))
                    {
                        sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdDimension].Nombre);
                    }
                    else
                    {
                        sb.Append("_" + ReporteXBRLUtil.eliminaEtiquetas(dimension.ElementoMiembroTipificado));
                    }
                }
            }
            return(sb.ToString());
        }
コード例 #8
0
        public override void obtenerValoresIniciales(DocumentoInstanciaXbrlDto instancia)
        {
            String claveCotizacion = ReporteXBRLUtil.obtenerValorHecho(reporteXBRLDTO.PrefijoTaxonomia + ReportConstants.NOMBRE_CONCEPTO_EMISORA, instancia);
            String fideicomiso     = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.CONCEPTO_ANNEXT_NUMERO_FIDEICOMISO, instancia);
            String fechaReporte    = obtenerFechaAnexoT(instancia);
            String razonSocial     = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.CONCEPTO_ANNEXT_RAZON_SOCIAL, instancia);
            String series          = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.CONCEPTO_ANNEXT_SERIES, instancia);
            String moneda          = ReporteXBRLUtil.obtenerValorMoneda(instancia);

            reporteXBRLDTO.ClaveCotizacion = claveCotizacion;
            reporteXBRLDTO.Fideicomiso     = fideicomiso;
            reporteXBRLDTO.FechaReporte    = fechaReporte;
            reporteXBRLDTO.RazonSocial     = razonSocial;
            reporteXBRLDTO.Series          = series;
            reporteXBRLDTO.Moneda          = moneda;
        }
コード例 #9
0
        /**
         * Elimina del listado de roles 510 o 520 dependiendo de la bande que indica
         * si se va a usar el estado de flujo de efectivo por método indirecto o no
         * @param instancia documento de instancia procesado.
         */
        private void quitarRolesNoUsadosDeEstadoDeFlujoDeEfectivo(DocumentoInstanciaXbrlDto instancia)
        {
            if (!reporteXBRLDTO.PrefijoTaxonomia.Equals(ReportConstants.PREFIJO_ID_TRAC))
            {
                //Si existe la bandera CashFlowStatementForInderectMethod se elige si se elimina 510 o 520
                String idCashFlowIndirect = reporteXBRLDTO.PrefijoTaxonomia + "CashFlowStatementForInderectMethod";

                String indicadorCashFlowIndirect = ReporteXBRLUtil.obtenerValorHecho(idCashFlowIndirect, instancia);
                if (indicadorCashFlowIndirect != null)
                {
                    IndiceReporteDTO indiceEliminar = null;
                    String           rolEliminar    = null;
                    if ("SI".Equals(indicadorCashFlowIndirect))
                    {
                        //Se usa 520, elimina 510
                        rolEliminar = "510000";
                    }
                    else
                    {
                        //Se usa 510, elimina 520
                        rolEliminar = "520000";
                    }

                    foreach (IndiceReporteDTO indiceActual in reporteXBRLDTO.Indices)
                    {
                        if (indiceActual.Rol.Contains(rolEliminar))
                        {
                            indiceEliminar = indiceActual;
                            break;
                        }
                    }

                    if (indiceEliminar != null)
                    {
                        reporteXBRLDTO.Indices.Remove(indiceEliminar);
                        reporteXBRLDTO.Roles.Remove(indiceEliminar.Rol);

                        int index = Array.BinarySearch(reporteXBRLDTO.NombresHojas, indiceEliminar.Rol);
                        if (index >= 0)
                        {
                            reporteXBRLDTO.NombresHojas = reporteXBRLDTO.NombresHojas.Where((val, i) => i != index).ToArray();
                        }
                    }
                }
            }
        }
コード例 #10
0
 public ResumenInformacion4DDTO(ResumenInformacion4D entity)
 {
     this.Taxonomia                            = ReporteUtil.obtenerNombreSimpleTaxonomia(entity.Taxonomia);
     this.FechaReporte                         = entity.FechaReporte;
     this.ClaveCotizacion                      = entity.ClaveCotizacion;
     this.NumeroFideicomiso                    = entity.NumeroFideicomiso;
     this.Unidad                               = entity.Unidad;
     this.TotalActivo                          = entity.TotalActivo;
     this.TotalActivoFormateado                = "$" + ReporteXBRLUtil.formatoDecimal(entity.TotalActivo, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
     this.TotalPasivo                          = entity.TotalPasivo;
     this.TotalPasivoFormateado                = "$" + ReporteXBRLUtil.formatoDecimal(entity.TotalPasivo, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
     this.TotalCapitalContablePasivo           = entity.TotalCapitalContablePasivo;
     this.TotalCapitalContablePasivoFormateado = "$" + ReporteXBRLUtil.formatoDecimal(entity.TotalCapitalContablePasivo, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
     this.Ingreso                              = entity.Ingreso;
     this.IngresoFormateado                    = "$" + ReporteXBRLUtil.formatoDecimal(entity.Ingreso, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
     this.NombreProveedorServiciosAuditoria    = entity.NombreProveedorServiciosAuditoria;
     this.NombreSocioOpinion                   = entity.NombreSocioOpinion;
     this.TipoOpinionEstadosFinancieros        = entity.TipoOpinionEstadosFinancieros;
 }
コード例 #11
0
        private void escribirDosColumnas(DocumentBuilder docBuilder, ReporteXBRLDTO estructuraReporte, DocumentoInstanciaXbrlDto instancia, String idConcepto, double tabulacionConcepto, ParagraphAlignment alineacionValor)
        {
            var conceptoDto = BuscarPorIdConcepto(estructuraReporte, idConcepto);

            if (conceptoDto != null)
            {
                docBuilder.InsertCell();
                docBuilder.Font.Name = TipoLetraTituloConcepto;
                docBuilder.Font.Bold = TituloConceptoNegrita;
                docBuilder.Font.Size = 9;
                docBuilder.ParagraphFormat.Alignment  = ParagraphAlignment.Left;
                docBuilder.ParagraphFormat.LeftIndent = tabulacionConcepto;
                docBuilder.Write(conceptoDto.Valor);

                docBuilder.InsertCell();
                docBuilder.Font.Name = TipoLetraTextos;
                docBuilder.Font.Bold = false;
                docBuilder.Font.Size = TamanioLetraTextos;
                docBuilder.ParagraphFormat.LeftIndent   = 0;
                docBuilder.ParagraphFormat.Alignment    = alineacionValor;
                docBuilder.CellFormat.VerticalAlignment = CellVerticalAlignment.Center;

                if (conceptoDto.TipoDato.Contains(ReporteXBRLUtil.TIPO_DATO_ENTERO_NO_NEGATIVO))
                {
                    var valorHecho            = obtenerValorNoNumerico(instancia, idConcepto);
                    var valorFormateadoEntero = ReporteXBRLUtil.formatoDecimal(Convert.ToDecimal(valorHecho), ReporteXBRLUtil.FORMATO_CANTIDADES_ENTERAS);
                    docBuilder.Write(!String.IsNullOrEmpty(valorFormateadoEntero) ? valorFormateadoEntero : String.Empty);
                }
                else if (conceptoDto.TipoDato.Contains(ReporteXBRLUtil.TIPO_DATO_DECIMAL))
                {
                    var valorHecho             = obtenerValorNoNumerico(instancia, idConcepto);
                    var valorFormateadoDecimal = ReporteXBRLUtil.formatoDecimal(Convert.ToDecimal(valorHecho), ReporteXBRLUtil.FORMATO_CANTIDADES_DECIMALES);
                    docBuilder.Write(!String.IsNullOrEmpty(valorFormateadoDecimal) ? valorFormateadoDecimal : String.Empty);
                }
                else
                {
                    escribirValorHecho(docBuilder, estructuraReporte, estructuraReporte.Roles[ID_ROL], idConcepto);
                }

                docBuilder.EndRow();
            }
        }
コード例 #12
0
        private static IngresosProductoReporteDto actualizarIngresosProducto(IngresosProductoReporteDto ingresos, String producto, String idItemMiembro, HechoDto hecho, ReporteXBRLDTO reporteXBRLDTO)
        {
            if (ingresos == null)
            {
                ingresos                      = new IngresosProductoReporteDto();
                ingresos.Producto             = true;
                ingresos.PrincipalesProductos = producto;
            }

            if (idItemMiembro.Equals("ifrs_mx-cor_20141205_IngresosNacionalesMiembro"))
            {
                ingresos.IngresosNacionales = new HechoReporteDTO();
                ingresos.IngresosNacionales.ValorNumerico   = hecho.ValorNumerico;
                ingresos.IngresosNacionales.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                obtenerNotasAlPie(hecho, ingresos.IngresosNacionales, reporteXBRLDTO);
            }
            else if (idItemMiembro.Equals("ifrs_mx-cor_20141205_IngresosPorExportacionMiembro"))
            {
                ingresos.IngresosExportacion = new HechoReporteDTO();
                ingresos.IngresosExportacion.ValorNumerico   = hecho.ValorNumerico;
                ingresos.IngresosExportacion.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                obtenerNotasAlPie(hecho, ingresos.IngresosExportacion, reporteXBRLDTO);
            }
            else if (idItemMiembro.Equals("ifrs_mx-cor_20141205_IngresosDeSubsidiariasEnElExtranjeroMiembro"))
            {
                ingresos.IngresosSubsidirias = new HechoReporteDTO();
                ingresos.IngresosSubsidirias.ValorNumerico   = hecho.ValorNumerico;
                ingresos.IngresosSubsidirias.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                obtenerNotasAlPie(hecho, ingresos.IngresosSubsidirias, reporteXBRLDTO);
            }
            else if (idItemMiembro.Equals("ifrs_mx-cor_20141205_IngresosTotalesMiembro"))
            {
                ingresos.IngresosTotales = new HechoReporteDTO();
                ingresos.IngresosTotales.ValorNumerico   = hecho.ValorNumerico;
                ingresos.IngresosTotales.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                obtenerNotasAlPie(hecho, ingresos.IngresosTotales, reporteXBRLDTO);
            }

            return(ingresos);
        }
        public void ExportarDatosDeHojaExcel(ISheet hojaAExportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, IDefinicionPlantillaXbrl plantillaDocumento, String idioma)
        {
            int numeroRenglonActual = RENGLON_INICIO_DATOS;

            EscribirValorPrimerHecho(instancia, "rel_ev_Ticker", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
            EscribirValorPrimerHecho(instancia, "rel_ev_Date", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
            EscribirValorPrimerHecho(instancia, "rel_ev_BusinessName", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
            EscribirValorPrimerHecho(instancia, "rel_ev_Place", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
            EscribirValorPrimerHecho(instancia, "rel_ev_Subject", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);

            if (!instancia.EspacioNombresPrincipal.Contains("fondos"))
            {
                EscribirValorPrimerHecho(instancia, "rel_ev_ForeignMarket", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
            }



            var descTipoEvento = "";

            if (instancia.HechosPorIdConcepto.ContainsKey("rel_ev_RelevantEventContent"))
            {
                var listaHechosId = instancia.HechosPorIdConcepto["rel_ev_RelevantEventContent"];
                if (listaHechosId.Count > 0)
                {
                    var hechoContenido = instancia.HechosPorId[listaHechosId[0]];
                    var contexto       = instancia.ContextosPorId[hechoContenido.IdContexto];
                    if (contexto.ValoresDimension != null && contexto.ValoresDimension.Count > 0)
                    {
                        descTipoEvento = ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, null, contexto.ValoresDimension[0].IdItemMiembro, instancia);
                    }
                }
            }

            ExcelUtil.AsignarValorCelda(hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS, descTipoEvento,
                                        CellType.String, null);

            EscribirValorPrimerHecho(instancia, "rel_ev_RelevantEventContent", hojaAExportar, numeroRenglonActual++, COLUMNA_DATOS);
        }
コード例 #14
0
        /// <summary>
        /// (non-Javadoc)
        /// </summary>
        ///  @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#obtenerValoresIniciales(com.hh.xbrl.abax.viewer.application.dto.DocumentoInstanciaXbrlDto)
        public override void obtenerValoresIniciales(DocumentoInstanciaXbrlDto instancia)
        {
            String nombreReporte = ReporteXBRLUtil.NOMBRE_REPORTE_IFRS;

            String  claveCotizacion   = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_CLAVE_COTIZACION_2014, instancia);
            String  fechaReporte      = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_FECHA_CIERRE_REPORTE_2014, instancia);
            String  anio              = fechaReporte.Substring(0, fechaReporte.IndexOf("-"));
            String  trimestre         = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_TRIMESTRE_REPORTADO, instancia);
            String  moneda            = ReporteXBRLUtil.obtenerValorMoneda(instancia);
            String  fechaCreacion     = DateUtil.ToFormatString(DateTime.Now, ReporteXBRLUtil.FORMATO_FECHA_CREACION);
            String  stringConsolidado = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_CUENTA_CONSOLIDADO, instancia);
            Boolean consolidado       = false;

            Boolean.TryParse(stringConsolidado, out consolidado);

            reporteXBRLDTO.AplicaConsolidado = true;
            reporteXBRLDTO.ClaveCotizacion   = claveCotizacion;
            reporteXBRLDTO.RazonSocial       = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_NOMBRE_RAZON_SOCIAL, instancia);
            reporteXBRLDTO.FechaReporte      = fechaReporte;
            reporteXBRLDTO.Anio          = anio;
            reporteXBRLDTO.Trimestre     = trimestre;
            reporteXBRLDTO.Moneda        = moneda;
            reporteXBRLDTO.Consolidado   = consolidado;
            reporteXBRLDTO.FechaCreacion = fechaCreacion;

            if (claveCotizacion != null && fechaReporte != null && trimestre != null && moneda != null && consolidado != null)
            {
                nombreReporte = nombreReporte.
                                Replace(ReporteXBRLUtil.CLAVE_COTIZACION, claveCotizacion).
                                Replace(ReporteXBRLUtil.ANIO, anio).
                                Replace(ReporteXBRLUtil.TRIMESTRE, trimestre).
                                Replace(ReporteXBRLUtil.MONEDA, moneda).
                                Replace(ReporteXBRLUtil.CONSOLIDACION, (consolidado ? ReporteXBRLUtil.CONSOLIDADO : ReporteXBRLUtil.NO_CONSOLIDADO)).
                                Replace(ReporteXBRLUtil.FECHA_CREACION, fechaCreacion);

                reporteXBRLDTO.NombreReporte = nombreReporte;
            }
        }
コード例 #15
0
        /// <summary>
        /// Llena los conceptos haciendo uso de identificador del periodo evaluado.
        /// </summary>
        /// <param name="conceptos"></param>
        /// <param name="instancia"></param>
        /// <returns></returns>
        private IList<ConceptoReporteDTO> llenarRolAnualProspecto424000(IList<ConceptoReporteDTO> conceptos, DocumentoInstanciaXbrlDto instancia)
        {
            IList<String> listaAliasPeriodos = new List<String>()
            {
                "periodo_actual",
                "periodo_anterior",
                "periodo_pre_anterior",
                "anual_actual",
                "anual_anterior",
                "anual_pre_anterior"
            };
            foreach (ConceptoReporteDTO concepto in conceptos)
            {
                HechoReporteDTO hechoReporte = null;
                llenarConcepto(concepto, instancia);
                if (concepto.Abstracto)
                {
                    continue;
                }
                foreach (var aliasPeriodo in listaAliasPeriodos)
                {
                    if (concepto.Hechos.TryGetValue(aliasPeriodo, out hechoReporte))
                    {
                        obtenerHecho(concepto, hechoReporte, aliasPeriodo, instancia);

                        if (hechoReporte != null)
                        {
                            if (concepto.Numerico && concepto.TipoDato.Contains(ReporteXBRLUtil.TIPO_DATO_MONETARY))
                            {   
                                hechoReporte.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hechoReporte.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_DECIMALES);
                            }
                        }
                    }
                }
            }

            return conceptos;
        }
コード例 #16
0
        public override void obtenerValoresIniciales(Viewer.Application.Dto.DocumentoInstanciaXbrlDto instancia)
        {
            String nombreReporte = ReporteXBRLUtil.NOMBRE_REPORTE_EVENTO_RELEVANTE;

            String claveCotizacion = ReporteXBRLUtil.obtenerValorHecho("rel_ev_Ticker", instancia);
            String razonSocial     = ReporteXBRLUtil.obtenerValorHecho("rel_ev_BusinessName", instancia);
            String fechaReporte    = ReporteXBRLUtil.obtenerValorHecho("rel_ev_Date", instancia);
            String fechaCreacion   = DateUtil.ToFormatString(DateTime.Now, ReporteXBRLUtil.FORMATO_FECHA_CREACION);

            if (String.IsNullOrEmpty(claveCotizacion))
            {
                claveCotizacion = ReporteXBRLUtil.obtenerValorHecho("rel_news_Ticker", instancia);
            }
            if (String.IsNullOrEmpty(razonSocial))
            {
                razonSocial = ReporteXBRLUtil.obtenerValorHecho("rel_news_BusinessName", instancia);
            }
            if (String.IsNullOrEmpty(fechaReporte))
            {
                fechaReporte = ReporteXBRLUtil.obtenerValorHecho("rel_news_Date", instancia);
            }

            reporteXBRLDTO.ClaveCotizacion = claveCotizacion;
            reporteXBRLDTO.RazonSocial     = razonSocial;
            reporteXBRLDTO.FechaReporte    = fechaReporte;

            reporteXBRLDTO.FechaCreacion = fechaCreacion;

            if (claveCotizacion != null && fechaReporte != null)
            {
                nombreReporte = nombreReporte.
                                Replace(ReporteXBRLUtil.CLAVE_COTIZACION, claveCotizacion).
                                Replace(ReporteXBRLUtil.FECHA_CREACION, fechaCreacion).Replace(ReporteXBRLUtil.FECHA, fechaReporte);

                reporteXBRLDTO.NombreReporte = nombreReporte;
            }
        }
コード例 #17
0
        public static IList <IngresosProductoReporteDto> generaContenidoReporte(DocumentoInstanciaXbrlDto documentoInstancia, ReporteXBRLDTO reporteXBRLDTO, int ContadorNotasAlPie, out int outContadorNotasAlPie)
        {
            contadorTMP = ContadorNotasAlPie;

            IDictionary <String, IDictionary <String, IngresosProductoReporteDto> > marcas = new Dictionary <String, IDictionary <String, IngresosProductoReporteDto> >();

            IList <IngresosProductoReporteDto> contenido = null;

            IngresosProductoReporteDto total = new IngresosProductoReporteDto();

            total.Total = true;
            total.PrincipalesProductos = tituloRenglonTotal;

            String finPeriodo    = ReporteXBRLUtil.obtenerValorHecho(ReportConstants.ID_FECHA_CIERRE_REPORTE_2014, documentoInstancia);
            String inicioPeriodo = DateReporteUtil.obtenerPeriodos(finPeriodo)["acum_anio_actual"].Split(new String[] { "_" }, StringSplitOptions.None)[0];

            var dateInicioPeriodo = DateReporteUtil.obtenerFecha(inicioPeriodo);
            var dateFinPeriodo    = DateReporteUtil.obtenerFecha(finPeriodo);

            foreach (ContextoDto contexto in documentoInstancia.ContextosPorId.Values)
            {
                if (contexto.Periodo.Tipo == PeriodoDto.Instante)
                {
                    if (!contexto.Periodo.FechaInstante.Equals(dateFinPeriodo))
                    {
                        continue;
                    }
                }
                else
                {
                    if (!contexto.Periodo.FechaInicio.Equals(dateInicioPeriodo) || !contexto.Periodo.FechaFin.Equals(dateFinPeriodo))
                    {
                        continue;
                    }
                }

                if (contexto.ValoresDimension != null && contexto.ValoresDimension.Count() > 0)
                {
                    DimensionInfoDto dimensionMarca    = obtenerPrimero(contexto.ValoresDimension, IdDimensionMarcas);
                    DimensionInfoDto dimensionProducto = obtenerPrimero(contexto.ValoresDimension, IdDimensionProductos);

                    if (dimensionMarca != null && dimensionProducto != null)
                    {
                        String   marca     = obtenerNombreMarcaProducto(dimensionMarca.ElementoMiembroTipificado).Trim();
                        String   producto  = obtenerNombreMarcaProducto(dimensionProducto.ElementoMiembroTipificado).Trim();
                        String   idMiembro = obtenerIdItemMiembro(contexto.ValoresDimension);
                        HechoDto hecho     = documentoInstancia.HechosPorId[documentoInstancia.HechosPorIdContexto[contexto.Id][0]];

                        if (marca.Equals(todasLasMarcas) && producto.Equals(todosLosProductos))
                        {
                            actualizarIngresosProducto(total, producto, idMiembro, hecho, reporteXBRLDTO);
                        }
                        else
                        {
                            actualizarHechosProducto(marcas, marca, producto, idMiembro, hecho, reporteXBRLDTO);
                        }
                    }
                }
            }

            contenido = crearIngresosProducto(marcas);
            contenido.Add(total);

            outContadorNotasAlPie = contadorTMP;
            contadorTMP           = 0;

            return(contenido);
        }
コード例 #18
0
 private static String obtenerNombreMarcaProducto(String miembroTipificado)
 {
     return(ReporteXBRLUtil.eliminaEtiquetas(miembroTipificado));
 }
コード例 #19
0
        /// <summary>
        /// Imprime el contenido de un grupo de hechos de tipo pasivo, ya sea un crédito o un renglón total
        /// </summary>

        private void ImprimirGrupoTipoPasivo(string idTipoPasivo, string[] elementosPrimarios, DocumentBuilder docBuilder, Viewer.Application.Dto.DocumentoInstanciaXbrlDto instancia, String idioma, Dto.ReporteXBRLDTO estructuraReporte)
        {
            var hechosDeTipoPasivo = ObtenerHechosPorDimensionYMiembro(instancia, null, ImportadorExportadorRol815100Bmv2014._idDimensionTipoPasivo, idTipoPasivo);

            if (ImportadorExportadorRol815100Bmv2014._miembrosTipoPasivoTotales.Contains(idTipoPasivo))
            {
                docBuilder.InsertCell();
                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;

                docBuilder.RowFormat.HeadingFormat    = false;
                docBuilder.CellFormat.HorizontalMerge = CellMerge.None;
                docBuilder.CellFormat.VerticalMerge   = CellMerge.None;


                docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.White;
                docBuilder.Font.Color = Color.Black;
                docBuilder.Write(ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT, idTipoPasivo, instancia));

                var iSubMiembro = 0;

                for (int iElemento = 1; iElemento < elementosPrimarios.Length; iElemento++)
                {
                    docBuilder.InsertCell();
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;

                    docBuilder.RowFormat.HeadingFormat    = false;
                    docBuilder.CellFormat.HorizontalMerge = CellMerge.None;
                    docBuilder.CellFormat.VerticalMerge   = CellMerge.None;


                    docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.White;
                    docBuilder.Font.Color = Color.Black;
                    if (ImportadorExportadorRol815100Bmv2014._elementosPrimariosTotal.Contains(elementosPrimarios[iElemento]))
                    {
                        var listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, hechosDeTipoPasivo, elementosPrimarios[iElemento], null);

                        if (elementosPrimarios[iElemento] == ImportadorExportadorRol815100Bmv2014._idConceptoSubtabla)
                        {
                            listaHechos = FiltrarHechosPorDimensionYMiembro(instancia, listaHechos, ImportadorExportadorRol815100Bmv2014._idDimensionIntervalo, ImportadorExportadorRol815100Bmv2014._miembrosIntervaloDeTiempo[iSubMiembro++]);
                        }


                        if (listaHechos != null && listaHechos.Count > 0)
                        {
                            if (!String.IsNullOrEmpty(listaHechos[0].Valor))
                            {
                                if (listaHechos[0].EsNumerico)
                                {
                                    var valorHecho = ReporteXBRLUtil.formatoDecimal(listaHechos[0].ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                    EscribirLinkNotaAlPie(docBuilder, listaHechos[0], estructuraReporte);
                                    docBuilder.Write(valorHecho);
                                }
                                else
                                {
                                    EscribirLinkNotaAlPie(docBuilder, listaHechos[0], estructuraReporte);
                                    docBuilder.Write(listaHechos[0].Valor);
                                }
                            }
                        }
                    }
                }
                docBuilder.EndRow();
            }
            else
            {
                var secuenciasEnHechos = OrganizarHechosPorSecuencia(instancia, hechosDeTipoPasivo);

                if (secuenciasEnHechos.Count > 0)
                {
                    foreach (var secuencia in secuenciasEnHechos.Keys)
                    {
                        int iMiembroSubtabla = 0;
                        foreach (var elementoPrimario in elementosPrimarios)
                        {
                            docBuilder.InsertCell();
                            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;

                            docBuilder.RowFormat.HeadingFormat    = false;
                            docBuilder.CellFormat.HorizontalMerge = CellMerge.None;
                            docBuilder.CellFormat.VerticalMerge   = CellMerge.None;


                            docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.White;
                            docBuilder.Font.Color = Color.Black;


                            IList <HechoDto> listaHechos = null;

                            if (elementoPrimario.Equals(ImportadorExportadorRol815100Bmv2014._idConceptoSubtabla))
                            {
                                listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, secuenciasEnHechos[secuencia], elementoPrimario, null);
                                listaHechos = FiltrarHechosPorDimensionYMiembro(instancia, listaHechos, ImportadorExportadorRol815100Bmv2014._idDimensionIntervalo, ImportadorExportadorRol815100Bmv2014._miembrosIntervaloDeTiempo[iMiembroSubtabla++]);
                            }
                            else
                            {
                                listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, secuenciasEnHechos[secuencia], elementoPrimario, null);
                            }

                            if (listaHechos != null && listaHechos.Count > 0)
                            {
                                if (!String.IsNullOrEmpty(listaHechos[0].Valor))
                                {
                                    if (listaHechos[0].EsNumerico)
                                    {
                                        var valorHecho = ReporteXBRLUtil.formatoDecimal(listaHechos[0].ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                        EscribirLinkNotaAlPie(docBuilder, listaHechos[0], estructuraReporte);
                                        docBuilder.Write(valorHecho);
                                    }
                                    else
                                    {
                                        EscribirLinkNotaAlPie(docBuilder, listaHechos[0], estructuraReporte);
                                        docBuilder.Write(listaHechos[0].Valor);
                                    }
                                }
                            }
                        }
                        docBuilder.EndRow();
                    }
                }
            }
        }
コード例 #20
0
        public override void exportarRolAWord(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte)
        {
            //estructuraReporte.ConceptosReportePorRol[""][0].Hechos[""].Valor
            foreach (HeaderFooter head in docBuilder.Document.FirstSection.HeadersFooters)
            {
                head.Range.Replace("${label_rel_ev_RelevantEventReportAbstract}",
                                   ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_RelevantEventReportAbstract", instancia),
                                   false, false);

                head.Range.Replace("${label_rel_ev_Date}",
                                   ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_Date", instancia),
                                   false, false);

                head.Range.Replace("${rel_ev_Date}",
                                   ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_Date", instancia, ""),
                                   false, false);

                head.Range.Replace("${rel_ev_BusinessName}",
                                   ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_BusinessName", instancia, ""),
                                   false, false);
            }

            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_Ticker}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_Ticker", instancia),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_Ticker}",
                                                           ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_Ticker", instancia, ""),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_BusinessName}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_BusinessName", instancia),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_BusinessName}",
                                                           ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_BusinessName", instancia, ""),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_Place}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_Place", instancia),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_Place}",
                                                           ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_Place", instancia, ""),
                                                           false, false);


            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_ForeignMarket}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_ForeignMarket", instancia),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_ForeignMarket}",
                                                           ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_ForeignMarket", instancia, ""),
                                                           false, false);



            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_RelevantEventTypesAxis}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_RelevantEventTypesAxis", instancia),
                                                           false, false);

            string descTipoEvento = String.Empty;

            if (instancia.HechosPorIdConcepto.ContainsKey("rel_ev_RelevantEventContent"))
            {
                var listaHechosId = instancia.HechosPorIdConcepto["rel_ev_RelevantEventContent"];
                if (listaHechosId.Count > 0)
                {
                    var hechoContenido = instancia.HechosPorId[listaHechosId[0]];
                    var contexto       = instancia.ContextosPorId[hechoContenido.IdContexto];
                    if (contexto.ValoresDimension != null && contexto.ValoresDimension.Count > 0)
                    {
                        descTipoEvento = ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, contexto.ValoresDimension[0].IdItemMiembro, instancia);
                    }
                }
            }

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_RelevantEventTypesAxis}",
                                                           descTipoEvento,
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_Subject}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_Subject", instancia),
                                                           false, false);

            docBuilder.Document.FirstSection.Range.Replace("${rel_ev_Subject}",
                                                           ReporteXBRLUtil.obtenerValorHechoDefault("rel_ev_Subject", instancia, ""),
                                                           false, false);


            docBuilder.Document.FirstSection.Range.Replace("${label_rel_ev_RelevantEventContent}",
                                                           ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_ev_RelevantEventContent", instancia),
                                                           false, false);
            docBuilder.MoveToSection(0);
            docBuilder.MoveToDocumentEnd();

            foreach (var rol in estructuraReporte.ConceptosReportePorRol.Keys)
            {
                var concepto = estructuraReporte.ConceptosReportePorRol[rol].FirstOrDefault(x => x.IdConcepto == "rel_ev_RelevantEventContent");
                if (concepto != null)
                {
                    escribirValorHecho(docBuilder, estructuraReporte, concepto.Hechos["trim_actual"], concepto);
                }
            }

            docBuilder.MoveToDocumentEnd();



            /*
             * foreach (var rol in estructuraReporte.ConceptosReportePorRol.Keys)
             * {
             *  var concepto = estructuraReporte.ConceptosReportePorRol[rol].FirstOrDefault(x => x.IdConcepto == "rel_ev_AttachedDocumentPdf");
             *  if (concepto != null)
             *  {
             *      //escribirConceptoEnTablaNota(docBuilder, estructuraReporte, concepto.Hechos["trim_actual"], concepto);
             *
             *      escribirValorHecho(docBuilder, estructuraReporte, concepto.Hechos["trim_actual"], concepto);
             *  }
             * }
             */
        }
コード例 #21
0
        public override void escribirEncabezado(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, ReporteXBRLDTO estructuraReporte, bool imprimirFooter)
        {
            var etiquetaReporte = ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_news_RelevantEventReportAbstract", instancia);
            var claveEntidad    = ReporteXBRLUtil.obtenerValorHechoDefault("rel_news_Ticker", instancia, "");
            var etiquetaFecha   = ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, null, "rel_news_Date", instancia);
            var fechaReporte    = ReporteXBRLUtil.obtenerValorHechoDefault("rel_news_Date", instancia, "");
            var ETIQUETA_DE     = estructuraReporte.ObtenValorEtiquetaReporte("ETIQUETA_DE");



            Section seccion = docBuilder.CurrentSection;

            seccion.PageSetup.DifferentFirstPageHeaderFooter = false;
            seccion.HeadersFooters.LinkToPrevious(false);
            seccion.HeadersFooters.Clear();
            docBuilder.MoveToHeaderFooter(HeaderFooterType.HeaderPrimary);

            Table tablaHead = docBuilder.StartTable();

            docBuilder.ParagraphFormat.SpaceAfter  = 0;
            docBuilder.ParagraphFormat.SpaceBefore = 0;
            docBuilder.CellFormat.ClearFormatting();
            ///Fila de año y trimestre
            docBuilder.InsertCell();
            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
            docBuilder.CellFormat.PreferredWidth = PreferredWidth.FromPercent(70);
            docBuilder.Font.Color = Color.Gray;
            docBuilder.Font.Bold  = false;
            docBuilder.Font.Size  = 9;
            docBuilder.Write(etiquetaReporte + " - " + claveEntidad);
            docBuilder.Font.Color = Color.Black;
            docBuilder.EndRow();

            docBuilder.InsertCell();
            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
            docBuilder.Font.Color = Color.Gray;
            docBuilder.Font.Size  = 8;
            docBuilder.Write(etiquetaFecha + " - " + fechaReporte);

            tablaHead.PreferredWidth = PreferredWidth.FromPercent(100);
            tablaHead.SetBorders(LineStyle.None, 0, Color.White);
            docBuilder.EndTable();

            docBuilder.MoveToHeaderFooter(HeaderFooterType.FooterPrimary);

            var leyendaReportes = System.Configuration.ConfigurationManager.AppSettings.Get("LeyendaReportes");

            if (!String.IsNullOrEmpty(leyendaReportes))
            {
                Table tablaPie = docBuilder.StartTable();
                docBuilder.InsertCell();
                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                docBuilder.Write(leyendaReportes);


                docBuilder.InsertCell();
                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Right;

                docBuilder.InsertField("PAGE", "");
                docBuilder.Write(" " + ETIQUETA_DE + " ");
                docBuilder.InsertField("NUMPAGES", "");
                tablaPie.SetBorders(LineStyle.None, 0, Color.Black);
                docBuilder.EndTable();
            }
            else
            {
                docBuilder.InsertField("PAGE", "");
                docBuilder.Write(" " + ETIQUETA_DE + " ");
                docBuilder.InsertField("NUMPAGES", "");
                docBuilder.CurrentParagraph.ParagraphFormat.Alignment = ParagraphAlignment.Right;
            }

            docBuilder.MoveToDocumentEnd();
        }
コード例 #22
0
        /// <summary>
        /// Imprime la sección correspondiente a los títulos de los elementos primarios enviados como parámetro, a 2 renglones
        /// </summary>
        /// <param name="p"></param>
        /// <param name="docBuilder"></param>
        /// <param name="instancia"></param>
        private void ImprimirTitulosGrupoPasivo(string[] elementosPrimarios, DocumentBuilder docBuilder, Viewer.Application.Dto.DocumentoInstanciaXbrlDto instancia, String idioma)
        {
            Color colorTitulo = Color.FromArgb(ColorTituloTabla[0], ColorTituloTabla[1], ColorTituloTabla[2]);

            var primerElementoSubtabla = true;

            foreach (var idElemento in elementosPrimarios)
            {
                docBuilder.InsertCell();

                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
                docBuilder.RowFormat.HeadingFormat   = true;

                docBuilder.CellFormat.Shading.BackgroundPatternColor = colorTitulo;
                docBuilder.CellFormat.PreferredWidth = PreferredWidth.Auto;
                docBuilder.Font.Color = Color.White;

                docBuilder.CellFormat.VerticalMerge   = CellMerge.First;
                docBuilder.CellFormat.HorizontalMerge = CellMerge.None;

                docBuilder.Write(ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT, idElemento, instancia));

                if (idElemento == ImportadorExportadorRol815100Bmv2014._idConceptoSubtabla)
                {
                    //Subtabla va mezclada
                    if (primerElementoSubtabla)
                    {
                        docBuilder.CellFormat.HorizontalMerge = CellMerge.First;
                        docBuilder.CellFormat.VerticalMerge   = CellMerge.None;
                        primerElementoSubtabla = false;
                        docBuilder.Write(ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT,
                                                                                 ImportadorExportadorRol815100Bmv2014._idDimensionIntervalo, instancia));
                    }
                    else
                    {
                        docBuilder.CellFormat.HorizontalMerge = CellMerge.Previous;
                    }
                }
            }
            docBuilder.EndRow();

            var iMiembroSubtabla = 0;

            foreach (var idElemento in elementosPrimarios)
            {
                docBuilder.InsertCell();

                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
                docBuilder.RowFormat.HeadingFormat   = true;

                docBuilder.CellFormat.Shading.BackgroundPatternColor = colorTitulo;
                docBuilder.CellFormat.PreferredWidth = PreferredWidth.Auto;
                docBuilder.Font.Color = Color.White;

                docBuilder.CellFormat.VerticalMerge   = CellMerge.Previous;
                docBuilder.CellFormat.HorizontalMerge = CellMerge.None;



                if (idElemento == ImportadorExportadorRol815100Bmv2014._idConceptoSubtabla)
                {
                    //Subtabla va mezclada

                    docBuilder.CellFormat.HorizontalMerge = CellMerge.None;
                    docBuilder.CellFormat.VerticalMerge   = CellMerge.None;

                    docBuilder.Write(ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT,
                                                                             ImportadorExportadorRol815100Bmv2014._miembrosIntervaloDeTiempo[iMiembroSubtabla++], instancia));
                }
            }
            docBuilder.EndRow();
        }
コード例 #23
0
        /// <summary>
        /// Crea y retorna el documento word en byte[].
        /// </summary>
        /// <param name="estruturaDeReporte"></param>
        /// <returns></returns>
        public byte[] ExportWordConsultaReporte(EstructuraReporteGenerico estruturaDeReporte)
        {
            Document word = null;

            word = new Document();

            try
            {
                DocumentBuilder docBuilder = new DocumentBuilder(word);
                docBuilder.CurrentSection.PageSetup.Orientation = Orientation.Portrait;
                docBuilder.CurrentSection.PageSetup.PaperSize   = Aspose.Words.PaperSize.Letter;

                docBuilder.CellFormat.Borders.LineStyle = Aspose.Words.LineStyle.Single;

                var numeroColumnas = estruturaDeReporte.ReporteGenericoPorRol.Count;

                foreach (var rol in estruturaDeReporte.ReporteGenericoPorRol)
                {
                    var columna = 0;

                    foreach (var columnaReporte in rol.ColumnasDelReporte)
                    {
                        var fecha         = columnaReporte.TipoDePeriodo == 1 ? Convert.ToDateTime(columnaReporte.FechaInstante.Date).ToString("dd/MM/yyyy") : Convert.ToDateTime(columnaReporte.FechaInicio.Date).ToString("dd/MM/yyyy") + " - " + Convert.ToDateTime(columnaReporte.FechaFin.Date).ToString("dd/MM/yyyy");
                        var moneda        = columnaReporte.Moneda != null && columnaReporte.Moneda.Length > 0 ? " - " + columnaReporte.Moneda : "";
                        var tituloSeccion = columnaReporte.Entidad + " - " + fecha + moneda;

                        this.EscribirTituloSeccion(docBuilder, tituloSeccion);



                        foreach (var concepto in rol.Conceptos)
                        {
                            if (concepto.Hechos[columna] != null)
                            {
                                List <String> nombreDimensiones = new List <string>();

                                if (concepto.Dimensiones != null && concepto.Dimensiones.Values.Count > 0)
                                {
                                    foreach (var estructuraDimensionReporte in concepto.Dimensiones.Values)
                                    {
                                        nombreDimensiones.Add(estructuraDimensionReporte.NombreDimension);
                                        nombreDimensiones.Add(estructuraDimensionReporte.NombreMiembro);
                                    }
                                }

                                docBuilder.CellFormat.PreferredWidth = PreferredWidth.FromPercent(0);

                                if (concepto != null && concepto.Hechos != null && concepto.Hechos.Length > 0 && concepto.Hechos[columna] != null && concepto.Hechos[columna].TipoDato.Contains("textBlockItemType") || (concepto.Hechos[columna].TipoDato.Contains("stringItemType") && concepto.Hechos[columna].Valor != null && concepto.Hechos[columna].Valor.Length > 20))
                                {
                                    this.EscribirConceptoPorRenglon(docBuilder, concepto.NombreConcepto, concepto.Hechos[columna].Valor != null ? concepto.Hechos[columna].Valor : "", nombreDimensiones);
                                }
                                else
                                {
                                    String valor = "";

                                    var tipoDeDato = concepto.Hechos[columna].TipoDato.Substring(concepto.Hechos[columna].TipoDato.LastIndexOf(':') + 1);

                                    if (concepto.Hechos[columna].Valor != null)
                                    {
                                        switch (tipoDeDato)
                                        {
                                        case "stringItemType":
                                        case "monthNumberItemType":
                                        case "siNoItemType":
                                        case "denominationOfTheIssueItemType":
                                            valor = concepto.Hechos[columna].Valor;
                                            break;

                                        case "monetaryItemType":
                                        case "decimalItemType":
                                        case "nonNegativeIntegerItemType":
                                        case "percentItemType":
                                            valor = ReporteXBRLUtil.formatoDecimal(Convert.ToDecimal(concepto.Hechos[columna].Valor), ReporteXBRLUtil.FORMATO_CANTIDADES_DECIMALES_AUX);
                                            break;

                                        case "booleanItemType":
                                            valor = concepto.Hechos[columna].Valor.Equals("true") ? "SI" : "NO";
                                            break;

                                        case "dateItemType":
                                            valor = Convert.ToDateTime(concepto.Hechos[columna].Valor).ToString("dd/MM/yyyy");
                                            break;

                                        default:
                                            valor = concepto.Hechos[columna].Valor;
                                            break;
                                        }
                                    }

                                    this.EscribirADosColumnas(docBuilder, concepto.NombreConcepto, valor, nombreDimensiones);
                                }
                            }
                        }

                        docBuilder.Writeln();
                        docBuilder.MoveToDocumentEnd();

                        if ((columna + 1) < rol.ColumnasDelReporte.Count)
                        {
                            docBuilder.InsertBreak(BreakType.PageBreak);
                        }

                        columna++;
                    }
                }
            }
            catch (Exception e)
            {
                LogUtil.Error(e);
            }

            return(guardarDocumentoComoWord(word));
        }
コード例 #24
0
        private void escribirTablaSerie(DocumentBuilder docBuilder, ReporteXBRLDTO estructuraReporte, DocumentoInstanciaXbrlDto instancia, HipercuboReporteDTO hipercubo)
        {
            docBuilder.Font.Size = TamanioLetraTituloTabla;
            docBuilder.Writeln();
            Table tablaDesglose = docBuilder.StartTable();

            docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.FromArgb(ColorTituloTabla[0], ColorTituloTabla[1], ColorTituloTabla[2]);
            docBuilder.ParagraphFormat.SpaceAfter  = 0;
            docBuilder.ParagraphFormat.SpaceBefore = 2;

            docBuilder.InsertCell();

            docBuilder.CellFormat.PreferredWidth = PreferredWidth.Auto;
            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
            docBuilder.Font.Name  = TipoLetraTituloConcepto;
            docBuilder.Font.Bold  = TituloConceptoNegrita;
            docBuilder.Font.Size  = TamanioLetraTituloTabla;
            docBuilder.Font.Color = Color.White;

            docBuilder.Write((String)estructuraReporte.ParametrosReporte["annext_SerieTypedAxis_HEADER"]);

            for (var indexTitulo = 0; indexTitulo < hipercubo.Titulos.Count; indexTitulo++)
            {
                docBuilder.CellFormat.PreferredWidth = PreferredWidth.FromPoints(AnchoPreferidoColumnaTitulos);
                var titulo = hipercubo.Titulos[indexTitulo];
                docBuilder.InsertCell();
                docBuilder.Write(titulo);
            }

            docBuilder.EndRow();
            docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.White;
            docBuilder.CellFormat.PreferredWidth = PreferredWidth.FromPoints(AnchoPreferidoColumnaDatos);
            docBuilder.Font.Size  = TamanioLetraContenidoTabla;
            docBuilder.Font.Color = Color.Black;

            foreach (var idConcepto in hipercubo.Hechos.Keys)
            {
                var matrizPlantillaContexto = hipercubo.Hechos[idConcepto];
                docBuilder.InsertCell();
                var nombreConcepto = ReporteXBRLUtil.obtenerEtiquetaConcepto(estructuraReporte.Lenguaje, ReporteXBRLUtil.ETIQUETA_DEFAULT, idConcepto, instancia);
                docBuilder.Font.Name = TipoLetraTituloConcepto;
                docBuilder.Font.Bold = false;
                docBuilder.Font.Size = TamanioLetraContenidoTabla;
                docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                docBuilder.Write(nombreConcepto);
                foreach (var idPlantillaContexto in matrizPlantillaContexto.Keys)
                {
                    var listaHechos = matrizPlantillaContexto[idPlantillaContexto];
                    for (var indexHecho = 0; indexHecho < listaHechos.Length; indexHecho++)
                    {
                        var hecho      = listaHechos[indexHecho];
                        var valorHecho = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                        docBuilder.InsertCell();
                        docBuilder.Font.Name = TipoLetraTextos;
                        docBuilder.Font.Bold = false;
                        docBuilder.Font.Size = TamanioLetraContenidoTabla;
                        docBuilder.ParagraphFormat.LeftIndent   = 0;
                        docBuilder.ParagraphFormat.Alignment    = ParagraphAlignment.Right;
                        docBuilder.CellFormat.VerticalAlignment = CellVerticalAlignment.Center;
                        docBuilder.Write(valorHecho);
                    }
                }
                docBuilder.EndRow();
            }
            docBuilder.EndTable();
            docBuilder.Writeln();
        }
コード例 #25
0
        ///
        /// (non-Javadoc)
        /// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#crearParametrosReporte(com.hh.xbrl.abax.viewer.application.dto.DocumentoInstanciaXbrlDto)
        ////
        public override void crearParametrosReporte(DocumentoInstanciaXbrlDto instancia)
        {
            base.crearParametrosReporte(instancia);

            String[] idConceptosMiembro = new String[] {
                "ifrs-full_ComponentsOfEquityAxis",
                "ifrs-full_IssuedCapitalMember",
                "ifrs-full_RetainedEarningsMember",
                "ifrs-full_OtherReservesMember",
                "ifrs-full_EquityAttributableToOwnersOfParentMember",
                "ifrs-full_NoncontrollingInterestsMember",
                "ifrs-full_EquityMember",

                "mx_ccd_OtherComprehensiveIncomeMember",
                "mx_deuda_OtherComprehensiveIncomeMember"
            };

            IDictionary <Object, Object> parametrosReporte = reporteXBRLDTO.ParametrosReporte;

            foreach (String idConcepto in idConceptosMiembro)
            {
                if (idConcepto.StartsWith("ifrs") || idConcepto.StartsWith(reporteXBRLDTO.PrefijoTaxonomia))
                {
                    parametrosReporte.Add(ReporteXBRLUtil.HEADER.Replace(ReporteXBRLUtil.TITULO, idConcepto), ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, null, idConcepto, instancia));
                }
            }

            reporteXBRLDTO.ParametrosReporte = parametrosReporte;
        }
        override public void exportarRolAWord(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte)
        {
            IList <ConceptoReporteDTO> listaConceptos = estructuraReporte.Roles[rolAExportar.Rol];

            String prefijoIdTaxo     = ReporteXBRLUtil.obtenerIdPrefijoDeTaxonomia(instancia);
            String numTrimestre      = obtenerValorNoNumerico(instancia, prefijoIdTaxo + ID_NUM_TRIMESTRE);
            String espacioNombresCCD = "http://www.cnbv.gob.mx/2015-06-30/ccd/full_ifrs_ccd_entry_point_2016-08-22";



            docBuilder.CurrentSection.PageSetup.Orientation = Orientation.Portrait;
            docBuilder.CurrentSection.PageSetup.PaperSize   = PaperSize.Letter;
            escribirEncabezado(docBuilder, instancia, estructuraReporte, true);
            imprimirTituloRol(docBuilder, rolAExportar);



            Table tablaActual = docBuilder.StartTable();

            docBuilder.ParagraphFormat.SpaceAfter  = 5;
            docBuilder.ParagraphFormat.SpaceBefore = 5;

            escribirADosColumnasConceptoValor(docBuilder, ID_NAME_OF_ENTITY, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_CLAVE_COTIZACION, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_EXPLICACION_EN_EL_CAMBIO, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_DESCRIPCION_NATURALEZA, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_DATE_OF_END, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_PERIODO_CUBIERTO, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_MONEDA_PRESENTACION, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, ID_GRADO_REDONDEO, rolAExportar, estructuraReporte);
            if (instancia.Taxonomia.ConceptosPorId.ContainsKey(prefijoIdTaxo + ID_ESTADOS_CONSOLIDADOS))
            {
                escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_ESTADOS_CONSOLIDADOS, rolAExportar, estructuraReporte);
            }

            escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_FIDEICOMISO_AVAL_GARANTE, rolAExportar, estructuraReporte);

            escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_NUM_FIDEICOMISO, rolAExportar, estructuraReporte);
            if (instancia.Taxonomia.ConceptosPorId.ContainsKey(prefijoIdTaxo + ID_FLUJO_EFECTIVO_METODO_INDIRECTO))
            {
                escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_FLUJO_EFECTIVO_METODO_INDIRECTO, rolAExportar, estructuraReporte);
            }

            escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_NUM_TRIMESTRE, rolAExportar, estructuraReporte);

            if (instancia.EspacioNombresPrincipal.Contains(espacioNombresCCD))
            {
                escribirADosColumnasConceptoValor(docBuilder, ID_REQUIERE_ANEXO_AA, rolAExportar, estructuraReporte);
            }

            if (TRIM_4D.Equals(numTrimestre))
            {
                escribirADosColumnasConceptoValor(docBuilder, prefijoIdTaxo + ID_FECHA_DE_OPINION, rolAExportar, estructuraReporte);
            }



            tablaActual.SetBorders(LineStyle.None, 0, Color.Black);
            tablaActual.SetBorder(BorderType.Horizontal, LineStyle.Single, .75, Color.DarkGray, true);
            tablaActual.SetBorder(BorderType.Bottom, LineStyle.Single, .75, Color.DarkGray, true);
            docBuilder.EndTable();
            docBuilder.InsertParagraph();

            escribirConceptoEnTablaNota(docBuilder, estructuraReporte, ID_INFO_A_REVELAR_SOBRE_INFO_GENERAL, listaConceptos);

            if (TRIM_4D.Equals(numTrimestre))
            {
                foreach (String idConcepto in ID_CONCEPTOS_4D)
                {
                    escribirConceptoEnTablaNota(docBuilder, estructuraReporte, prefijoIdTaxo + idConcepto, listaConceptos);
                }
            }
            //Reemplazar variables

            String consolidado = obtenerValorNoNumerico(instancia, prefijoIdTaxo + ID_ESTADOS_CONSOLIDADOS);

            String razonSocial = obtenerValorNoNumerico(instancia, ID_NAME_OF_ENTITY);

            if (consolidado != null)
            {
                if (CommonConstants.CADENAS_VERDADERAS.Contains(consolidado.ToLower().Trim()))
                {
                    consolidado = "Consolidado";
                }
                else
                {
                    consolidado = "No consolidado";
                }
            }
            else
            {
                consolidado = String.Empty;
            }

            docBuilder.Document.Range.Replace("#" + VARIABLE_CVE_COTIZACION, estructuraReporte.ClaveCotizacion, false, false);
            docBuilder.Document.Range.Replace("#" + VARIABLE_TRIMESTRE, numTrimestre, false, false);
            docBuilder.Document.Range.Replace("#" + VARIABLE_ANIO, estructuraReporte.Anio, false, false);
            docBuilder.Document.Range.Replace("#" + VARIABLE_RAZON_SOCIAL, razonSocial, false, false);
            docBuilder.Document.Range.Replace("#" + VARIABLE_CONSOLIDADO, consolidado, false, false);
            estructuraReporte.RazonSocial          = razonSocial;
            estructuraReporte.IndicadorConsolidado = consolidado;
        }
コード例 #27
0
        public static IList <DesgloseDeCreditosReporteDto> generarContenidoDeReporte(DocumentoInstanciaXbrlDto documentoInstancia, ReporteXBRLDTO reporteXBRLDTO, int ContadorNotasAlPie, out int outContadorNotasAlPie)
        {
            IList <DesgloseDeCreditosReporteDto> contenido = new List <DesgloseDeCreditosReporteDto>();
            var idioma = reporteXBRLDTO.Lenguaje;

            contadorTMP = ContadorNotasAlPie;

            String[] estructuraDelReporte = new String[] { "ifrs_mx-cor_20141205_BancariosSinopsis", "ifrs_mx-cor_20141205_ComercioExteriorBancarios",
                                                           "ifrs_mx-cor_20141205_ConGarantiaBancarios", "ifrs_mx-cor_20141205_BancaComercial", "ifrs_mx-cor_20141205_OtrosBancarios",
                                                           "ifrs_mx-cor_20141205_TotalBancarios", "ifrs_mx-cor_20141205_BursatilesYColocacionesPrivadasSinopsis",
                                                           "ifrs_mx-cor_20141205_BursatilesListadasEnBolsaQuirografarios", "ifrs_mx-cor_20141205_BursatilesListadasEnBolsaConGarantia",
                                                           "ifrs_mx-cor_20141205_ColocacionesPrivadasQuirografarios", "ifrs_mx-cor_20141205_ColocacionesPrivadasConGarantia",
                                                           "ifrs_mx-cor_20141205_TotalBursatilesListadasEnBolsaYColocacionesPrivadas",
                                                           "ifrs_mx-cor_20141205_OtrosPasivosCirculantesYNoCirculantesConCostoSinopsis",
                                                           "ifrs_mx-cor_20141205_OtrosPasivosCirculantesYNoCirculantesConCosto", "ifrs_mx-cor_20141205_TotalOtrosPasivosCirculantesYNoCirculantesConCosto",
                                                           "ifrs_mx-cor_20141205_ProveedoresSinopsis", "ifrs_mx-cor_20141205_Proveedores", "ifrs_mx-cor_20141205_TotalProveedores",
                                                           "ifrs_mx-cor_20141205_OtrosPasivosCirculantesYNoCirculantesSinCostoSinopsis",
                                                           "ifrs_mx-cor_20141205_OtrosPasivosCirculantesYNoCirculantesSinCosto", "ifrs_mx-cor_20141205_TotalOtrosPasivosCirculantesYNoCirculantesSinCosto",
                                                           "ifrs_mx-cor_20141205_TotalDeCreditos" };

            List <HechoDto> hechos              = new List <HechoDto>();
            List <String>   idsHechos           = new List <String>();
            IList <String>  idHechosPorConcepto = null;

            foreach (String idConcepto  in  estructuraDelReporte)
            {
                if (!idConcepto.EndsWith("Sinopsis"))
                {
                    if (documentoInstancia.HechosPorIdConcepto.ContainsKey(idConcepto))
                    {
                        idHechosPorConcepto = documentoInstancia.HechosPorIdConcepto[idConcepto];
                        idsHechos.AddRange(idHechosPorConcepto);
                    }
                }
            }

            if (documentoInstancia.HechosPorIdConcepto.ContainsKey("ifrs_mx-cor_20141205_InstitucionExtranjeraSiNo"))
            {
                idHechosPorConcepto = documentoInstancia.HechosPorIdConcepto["ifrs_mx-cor_20141205_InstitucionExtranjeraSiNo"];
                idsHechos.AddRange(idHechosPorConcepto);
            }

            if (documentoInstancia.HechosPorIdConcepto.ContainsKey("ifrs_mx-cor_20141205_FechaDeFirmaContrato"))
            {
                idHechosPorConcepto = documentoInstancia.HechosPorIdConcepto["ifrs_mx-cor_20141205_FechaDeFirmaContrato"];
                idsHechos.AddRange(idHechosPorConcepto);
            }

            if (documentoInstancia.HechosPorIdConcepto.ContainsKey("ifrs_mx-cor_20141205_FechaDeVencimiento"))
            {
                idHechosPorConcepto = documentoInstancia.HechosPorIdConcepto["ifrs_mx-cor_20141205_FechaDeVencimiento"];
                idsHechos.AddRange(idHechosPorConcepto);
            }

            if (documentoInstancia.HechosPorIdConcepto.ContainsKey("ifrs_mx-cor_20141205_TasaDeInteresYOSobretasa"))
            {
                idHechosPorConcepto = documentoInstancia.HechosPorIdConcepto["ifrs_mx-cor_20141205_TasaDeInteresYOSobretasa"];
                idsHechos.AddRange(idHechosPorConcepto);
            }

            IDictionary <String, List <String> > institucionesPorConcepto = new Dictionary <String, List <String> >();
            IDictionary <String, IDictionary <String, DesgloseDeCreditosReporteDto> > detalleDtoPorConcepto = new Dictionary <String, IDictionary <String, DesgloseDeCreditosReporteDto> >();

            foreach (String idHecho  in  idsHechos)
            {
                if (!documentoInstancia.HechosPorId.ContainsKey(idHecho))
                {
                    LogUtil.Error("Se solicitia un hecho que no existe en el documento {idHecho:[" + idHecho + "]}");
                    continue;
                }

                var hecho = documentoInstancia.HechosPorId[idHecho];
                if (!documentoInstancia.ContextosPorId.ContainsKey(hecho.IdContexto))
                {
                    LogUtil.Error("No existe el contexto definido para el hecho {idHecho:[" + idHecho + "], idContexto:[" + hecho.IdContexto + "]}");
                    continue;
                }
                var contexto = documentoInstancia.ContextosPorId[hecho.IdContexto];

                IDictionary <String, DesgloseDeCreditosReporteDto> detalleDtoPorInstitucion = null;
                if (!detalleDtoPorConcepto.ContainsKey(hecho.IdConcepto))
                {
                    detalleDtoPorInstitucion = new Dictionary <String, DesgloseDeCreditosReporteDto>();
                    detalleDtoPorConcepto.Add(hecho.IdConcepto, detalleDtoPorInstitucion);
                }
                else
                {
                    detalleDtoPorInstitucion = detalleDtoPorConcepto[hecho.IdConcepto];
                }

                hechos.Add(hecho);
                String idMiembroEjeDenominacion    = "";
                String idMiembroEjeIntervaloTiempo = "";
                String miembroTipificado           = "";
                foreach (DimensionInfoDto dimensionInfo  in  contexto.ValoresDimension)
                {
                    if (dimensionInfo.IdDimension.Equals("ifrs_mx-cor_20141205_InstitucionEje"))
                    {
                        miembroTipificado = dimensionInfo.ElementoMiembroTipificado;
                        if (!detalleDtoPorInstitucion.ContainsKey(miembroTipificado))
                        {
                            DesgloseDeCreditosReporteDto detalleInstitucionDto = new DesgloseDeCreditosReporteDto();
                            detalleInstitucionDto.Titulo = ReporteXBRLUtil.eliminaEtiquetas(miembroTipificado);
                            detalleDtoPorInstitucion.Add(miembroTipificado, detalleInstitucionDto);
                        }
                        if (!institucionesPorConcepto.ContainsKey(miembroTipificado))
                        {
                            List <String> idsConceptos = new List <String>();
                            idsConceptos.Add(hecho.IdConcepto);
                            institucionesPorConcepto.Add(miembroTipificado, idsConceptos);
                        }
                        else
                        {
                            if (!institucionesPorConcepto[miembroTipificado].Contains(hecho.IdConcepto))
                            {
                                institucionesPorConcepto[miembroTipificado].Add(hecho.IdConcepto);
                            }
                        }
                    }
                }
                foreach (DimensionInfoDto dimensionInfo  in  contexto.ValoresDimension)
                {
                    if (dimensionInfo.Explicita)
                    {
                        if (dimensionInfo.IdDimension.Equals("ifrs_mx-cor_20141205_DenominacionEje"))
                        {
                            idMiembroEjeDenominacion = dimensionInfo.IdItemMiembro;
                        }
                        else if (dimensionInfo.IdDimension.Equals("ifrs_mx-cor_20141205_IntervaloDeTiempoEje"))
                        {
                            idMiembroEjeIntervaloTiempo = dimensionInfo.IdItemMiembro;
                        }
                    }
                }

                if (hecho.IdConcepto.Equals("ifrs_mx-cor_20141205_InstitucionExtranjeraSiNo"))
                {
                    if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_TotalMonedasMiembro") &&
                        idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_TotalIntervalosMiembro"))
                    {
                        if (institucionesPorConcepto.ContainsKey(miembroTipificado))
                        {
                            foreach (String idConcepto in institucionesPorConcepto[miembroTipificado])
                            {
                                var intitucionExtranejraAux = CommonConstants.CADENAS_VERDADERAS.Contains(hecho.Valor.Trim().ToLower());
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].InstitucionExtranjera       = new HechoReporteDTO();
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].InstitucionExtranjera.Valor = intitucionExtranejraAux.ToString().ToLower();
                                obtenerNotasAlPie(hecho, detalleDtoPorConcepto[idConcepto][miembroTipificado].InstitucionExtranjera, reporteXBRLDTO);
                            }
                        }
                    }
                }
                else if (hecho.IdConcepto.Equals("ifrs_mx-cor_20141205_FechaDeFirmaContrato"))
                {
                    if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_TotalMonedasMiembro") &&
                        idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_TotalIntervalosMiembro"))
                    {
                        if (institucionesPorConcepto.ContainsKey(miembroTipificado))
                        {
                            foreach (String idConcepto in institucionesPorConcepto[miembroTipificado])
                            {
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaFirmaContrato       = new HechoReporteDTO();
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaFirmaContrato.Valor = hecho.Valor;
                                obtenerNotasAlPie(hecho, detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaFirmaContrato, reporteXBRLDTO);
                            }
                        }
                    }
                }
                else if (hecho.IdConcepto.Equals("ifrs_mx-cor_20141205_FechaDeVencimiento"))
                {
                    if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_TotalMonedasMiembro") &&
                        idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_TotalIntervalosMiembro"))
                    {
                        if (institucionesPorConcepto.ContainsKey(miembroTipificado))
                        {
                            foreach (String idConcepto in institucionesPorConcepto[miembroTipificado])
                            {
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaVencimiento       = new HechoReporteDTO();
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaVencimiento.Valor = hecho.Valor;
                                obtenerNotasAlPie(hecho, detalleDtoPorConcepto[idConcepto][miembroTipificado].FechaVencimiento, reporteXBRLDTO);
                            }
                        }
                    }
                }
                else if (hecho.IdConcepto.Equals("ifrs_mx-cor_20141205_TasaDeInteresYOSobretasa"))
                {
                    if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_TotalMonedasMiembro") &&
                        idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_TotalIntervalosMiembro"))
                    {
                        if (institucionesPorConcepto.ContainsKey(miembroTipificado))
                        {
                            foreach (String idConcepto in institucionesPorConcepto[miembroTipificado])
                            {
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].TasaInteres       = new HechoReporteDTO();
                                detalleDtoPorConcepto[idConcepto][miembroTipificado].TasaInteres.Valor = hecho.Valor;
                                obtenerNotasAlPie(hecho, detalleDtoPorConcepto[idConcepto][miembroTipificado].TasaInteres, reporteXBRLDTO);
                            }
                        }
                    }
                }
                else
                {
                    if (detalleDtoPorConcepto.ContainsKey(hecho.IdConcepto) && detalleDtoPorConcepto[hecho.IdConcepto].ContainsKey(miembroTipificado))
                    {
                        var elementoTipificadoPorConcepto = detalleDtoPorConcepto[hecho.IdConcepto][miembroTipificado];
                        if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_MonedaNacionalMiembro"))
                        {
                            if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_AnoActualMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalAnioActual = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalAnioActual.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalAnioActual.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalAnioActual, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta1AnoMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalUnAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalUnAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalUnAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalUnAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta2AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalDosAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalDosAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalDosAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalDosAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta3AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalTresAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalTresAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalTresAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalTresAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta4AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalCuatroAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalCuatroAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalCuatroAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalCuatroAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta5AnosOMasMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaNacionalCincoMasAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaNacionalCincoMasAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaNacionalCincoMasAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaNacionalCincoMasAnio, reporteXBRLDTO);
                            }
                        }
                        else if (idMiembroEjeDenominacion.Equals("ifrs_mx-cor_20141205_MonedaExtranjeraMiembro"))
                        {
                            if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_AnoActualMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraAnioActual = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraAnioActual.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraAnioActual.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraAnioActual, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta1AnoMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraUnAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraUnAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraUnAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraUnAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta2AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraDosAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraDosAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraDosAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraDosAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta3AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraTresAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraTresAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraTresAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraTresAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta4AnosMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraCuatroAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraCuatroAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraCuatroAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraCuatroAnio, reporteXBRLDTO);
                            }
                            else if (idMiembroEjeIntervaloTiempo.Equals("ifrs_mx-cor_20141205_Hasta5AnosOMasMiembro"))
                            {
                                elementoTipificadoPorConcepto.MonedaExtranjeraCincoMasAnio = new HechoReporteDTO();
                                elementoTipificadoPorConcepto.MonedaExtranjeraCincoMasAnio.ValorNumerico   = hecho.ValorNumerico;
                                elementoTipificadoPorConcepto.MonedaExtranjeraCincoMasAnio.ValorFormateado = ReporteXBRLUtil.formatoDecimal(hecho.ValorNumerico, ReporteXBRLUtil.FORMATO_CANTIDADES_MONETARIAS);
                                obtenerNotasAlPie(hecho, elementoTipificadoPorConcepto.MonedaExtranjeraCincoMasAnio, reporteXBRLDTO);
                            }
                        }
                    }
                    else
                    {
                        LogUtil.Error("No se encontro el elemento detalleDtoPorConcepto: {IdConcepto:[" + hecho.IdConcepto + "], miembroTipificado:[" + miembroTipificado + "]}");
                    }
                }
            }

            foreach (String idConcepto  in  estructuraDelReporte)
            {
                if (idConcepto.EndsWith("Sinopsis"))
                {
                    DesgloseDeCreditosReporteDto detalleDto = new DesgloseDeCreditosReporteDto();
                    detalleDto.Titulo = DesgloseDeCreditosHelper.obtenerEtiquetaDeConcepto(documentoInstancia.Taxonomia, idConcepto,
                                                                                           idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT);
                    detalleDto.TituloAbstracto = true;
                    contenido.Add(detalleDto);
                }
                else
                {
                    DesgloseDeCreditosReporteDto detalleDto = new DesgloseDeCreditosReporteDto();

                    detalleDto.Titulo = DesgloseDeCreditosHelper.obtenerEtiquetaDeConcepto(documentoInstancia.Taxonomia, idConcepto,
                                                                                           idioma, ReporteXBRLUtil.ETIQUETA_DEFAULT);
                    detalleDto.TituloAbstracto = true;
                    contenido.Add(detalleDto);

                    DesgloseDeCreditosReporteDto detalleTotalDto = null;
                    if (detalleDtoPorConcepto.ContainsKey(idConcepto))
                    {
                        foreach (String miembroInstitucion in detalleDtoPorConcepto[idConcepto].Keys)
                        {
                            if (detalleDtoPorConcepto[idConcepto][miembroInstitucion].Titulo.Equals("TOTAL"))
                            {
                                detalleTotalDto = detalleDtoPorConcepto[idConcepto][miembroInstitucion];
                            }
                            else
                            {
                                contenido.Add(detalleDtoPorConcepto[idConcepto][miembroInstitucion]);
                            }
                        }
                    }

                    if (detalleTotalDto != null)
                    {
                        detalleTotalDto.Total = true;
                        contenido.Add(detalleTotalDto);
                    }
                }
            }

            outContadorNotasAlPie = contadorTMP;
            contadorTMP           = 0;

            return(contenido);
        }
コード例 #28
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);
        }
コード例 #29
0
        private IList <ConceptoReporteDTO> llenarRol800003(IList <ConceptoReporteDTO> conceptos, DocumentoInstanciaXbrlDto instancia)
        {
            foreach (ConceptoReporteDTO concepto  in  conceptos)
            {
                HechoReporteDTO hechoReporte = null;

                llenarConcepto(concepto, instancia);

                IDictionary <String, HechoReporteDTO> hechosReporte = concepto.Hechos;

                if (!concepto.Abstracto && hechosReporte != null)
                {
                    if (hechosReporte.ContainsKey("cierre_trim_actual"))
                    {
                        hechoReporte       = hechosReporte["cierre_trim_actual"];
                        hechoReporte.Valor = ReporteXBRLUtil.obtenerValorHecho(concepto.IdConcepto, instancia);
                    }
                    else
                    {
                        IList <String> hechos;
                        if (!instancia.HechosPorIdConcepto.TryGetValue(concepto.IdConcepto, out hechos))
                        {
                            //var detalleError = CreaDetalleError(instancia, "No fue posible obtener el listado de hechos para el concepto \"" + concepto.IdConcepto + "\".");
                            //detalleError.Add("ConceptoError", concepto);
                            //LogUtil.Error(detalleError);
                            continue;
                        }

                        if (hechos != null)
                        {
                            foreach (String idHecho  in  hechos)
                            {
                                String fecha = null;

                                HechoDto    hecho;
                                ContextoDto contexto;

                                if (instancia.HechosPorId.TryGetValue(idHecho, out hecho) &&
                                    instancia.ContextosPorId.TryGetValue(hecho.IdContexto, out contexto) &&
                                    contexto.ContieneInformacionDimensional)
                                {
                                    //log.info(hecho.Valor);
                                    if (contexto.Periodo.Tipo == PeriodoDto.Instante)
                                    {
                                        fecha = DateReporteUtil.formatoFechaEstandar(contexto.Periodo.FechaInstante);
                                        String fechaCierrreTrimestreActual;
                                        String idItemMiembroContexto = contexto.ValoresDimension[0].IdItemMiembro;
                                        if (reporteXBRLDTO.PeriodosReporte.TryGetValue("cierre_trim_actual", out fechaCierrreTrimestreActual) &&
                                            fecha.Equals(fechaCierrreTrimestreActual) &&
                                            concepto.Hechos.TryGetValue(idItemMiembroContexto, out hechoReporte))
                                        {
                                            llenarHecho(concepto, hecho, hechoReporte);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(conceptos);
        }
コード例 #30
0
        /// <summary>
        /// (non-Javadoc)
        /// </summary>
        ///  @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#crearParametrosReporte(com.hh.xbrl.abax.viewer.application.dto.DocumentoInstanciaXbrlDto)
        public override void crearParametrosReporte(DocumentoInstanciaXbrlDto instancia)
        {
            base.crearParametrosReporte(instancia);

            String[] idConceptosMiembro = new String[] {
                "ifrs-full_ComponentsOfEquityAxis",
                "ifrs-full_IssuedCapitalMember",
                "ifrs-full_SharePremiumMember",
                "ifrs-full_TreasurySharesMember",
                "ifrs-full_RetainedEarningsMember",
                "ifrs-full_RevaluationSurplusMember",
                "ifrs-full_ReserveOfExchangeDifferencesOnTranslationMember",
                "ifrs-full_ReserveOfCashFlowHedgesMember",
                "ifrs-full_ReserveOfGainsAndLossesOnHedgingInstrumentsThatHedgeInvestmentsInEquityInstrumentsMember",
                "ifrs-full_ReserveOfChangeInValueOfTimeValueOfOptionsMember",
                "ifrs-full_ReserveOfChangeInValueOfForwardElementsOfForwardContractsMember",
                "ifrs-full_ReserveOfChangeInValueOfForeignCurrencyBasisSpreadsMember",
                "ifrs-full_ReserveOfGainsAndLossesOnFinancialAssetsMeasuredAtFairValueThroughOtherComprehensiveIncomeMember",
                "ifrs-full_ReserveOfGainsAndLossesOnRemeasuringAvailableforsaleFinancialAssetsMember",
                "ifrs-full_ReserveOfSharebasedPaymentsMember",
                "ifrs-full_ReserveOfRemeasurementsOfDefinedBenefitPlansMember",
                "ifrs-full_AmountRecognisedInOtherComprehensiveIncomeAndAccumulatedInEquityRelatingToNoncurrentAssetsOrDisposalGroupsHeldForSaleMember",
                "ifrs-full_ReserveOfGainsAndLossesFromInvestmentsInEquityInstrumentsMember",
                "ifrs-full_ReserveOfChangeInFairValueOfFinancialLiabilityAttributableToChangeInCreditRiskOfLiabilityMember",
                "ifrs-full_ReserveForCatastropheMember",
                "ifrs-full_ReserveForEqualisationMember",
                "ifrs-full_ReserveOfDiscretionaryParticipationFeaturesMember",
                "ifrs_mx-cor_20141205_OtrosResultadosIntegralesMiembro",
                "ifrs-full_OtherReservesMember",
                "ifrs-full_EquityAttributableToOwnersOfParentMember",
                "ifrs-full_NoncontrollingInterestsMember",
                "ifrs-full_EquityMember",

                "ifrs_mx-cor_20141205_MonedasEje",
                "ifrs_mx-cor_20141205_DolaresMiembro",
                "ifrs_mx-cor_20141205_DolaresContravalorPesosMiembro",
                "ifrs_mx-cor_20141205_OtrasMonedasContravalorDolaresMiembro",
                "ifrs_mx-cor_20141205_OtrasMonedasContravalorPesosMiembro",
                "ifrs_mx-cor_20141205_TotalDePesosMiembro",

                "ifrs_mx-cor_20141205_InstitucionEje",
                "ifrs_mx-cor_20141205_InstitucionExtranjeraSiNo",
                "ifrs_mx-cor_20141205_FechaDeFirmaContrato",
                "ifrs_mx-cor_20141205_FechaDeVencimiento",
                "ifrs_mx-cor_20141205_TasaDeInteresYOSobretasa",
                "ifrs_mx-cor_20141205_DenominacionEje",
                "ifrs_mx-cor_20141205_MonedaNacionalMiembro",
                "ifrs_mx-cor_20141205_IntervaloDeTiempoEje",
                "ifrs_mx-cor_20141205_MonedaExtranjeraMiembro",
                "ifrs_mx-cor_20141205_AnoActualMiembro",
                "ifrs_mx-cor_20141205_Hasta1AnoMiembro",
                "ifrs_mx-cor_20141205_Hasta2AnosMiembro",
                "ifrs_mx-cor_20141205_Hasta3AnosMiembro",
                "ifrs_mx-cor_20141205_Hasta4AnosMiembro",
                "ifrs_mx-cor_20141205_Hasta5AnosOMasMiembro",

                "ifrs_mx-cor_20141205_PrincipalesProductosOLineaDeProductosPartidas",
                "ifrs_mx-cor_20141205_TipoDeIngresoEje",
                "ifrs_mx-cor_20141205_PrincipalesMarcasEje",
                "ifrs_mx-cor_20141205_PrincipalesProductosOLineaDeProductosEje",
                "ifrs_mx-cor_20141205_IngresosNacionalesMiembro",
                "ifrs_mx-cor_20141205_IngresosPorExportacionMiembro",
                "ifrs_mx-cor_20141205_IngresosDeSubsidiariasEnElExtranjeroMiembro",
                "ifrs_mx-cor_20141205_IngresosTotalesMiembro"
            };

            IDictionary <Object, Object> parametrosReporte = reporteXBRLDTO.ParametrosReporte;

            foreach (String idConcepto in  idConceptosMiembro)
            {
                parametrosReporte.Add((idConcepto + "_HEADER"), ReporteXBRLUtil.obtenerEtiquetaConcepto(idioma, null, idConcepto, instancia));
            }

            reporteXBRLDTO.ParametrosReporte = parametrosReporte;
        }