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;
 }
Beispiel #2
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();
            }
        }
Beispiel #3
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);
        }
        /// <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;
        }
        /// <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));
        }
Beispiel #6
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);
        }
Beispiel #7
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();
        }
        /// <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();
                    }
                }
            }
        }