public void CreaSeccion(ConceptoReporteDTO conceptoOrigen, DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte, IExportadorRolDocumentoInstancia exportadorOrigen)
        {
            var         exportadorBase = (ExportadorGeneralProspecto)exportadorOrigen;
            var         hecho          = exportadorBase.ObtenPrimerHechoPorIdConcepto(instancia, "rel_news_RelevantEventContent");
            ContextoDto contexto;

            if (instancia.ContextosPorId.TryGetValue(hecho.IdContexto, out contexto))
            {
                var elementoDimension = contexto.ValoresDimension.First();
                var etiqueta          = "Tipo de evento relevante";//exportadorBase.ObtenEtiquetaConcepto(elementoDimension.IdDimension, instancia, estructuraReporte.Lenguaje);
                var miembro           = exportadorBase.ObtenEtiquetaConcepto(elementoDimension.IdItemMiembro, instancia, estructuraReporte.Lenguaje);

                AplicarEstilosEtiquetaNota(docBuilder, exportadorBase);
                docBuilder.Write(etiqueta);
                EliminaEstilosLinea(docBuilder, exportadorBase);

                AplicarEstilosValorNotaInicio(docBuilder, exportadorBase);
                WordUtil.InsertHtml(docBuilder, elementoDimension.IdDimension + ":" + hecho.Id, miembro, false, true);
                AplicarEstilosValorNotaFin(docBuilder, exportadorBase);
            }
            ConceptoDto concepto;

            if (instancia.Taxonomia.ConceptosPorId.TryGetValue(hecho.IdConcepto, out concepto))
            {
                var etiquetaHecho = exportadorBase.ObtenEtiquetaConcepto(hecho.IdConcepto, instancia, estructuraReporte.Lenguaje);
                AplicarEstilosEtiquetaNota(docBuilder, exportadorBase);
                docBuilder.Write(etiquetaHecho);
                EliminaEstilosLinea(docBuilder, exportadorBase);

                AplicarEstilosValorNotaInicio(docBuilder, exportadorBase);
                exportadorBase.EscribirValorHecho(docBuilder, estructuraReporte, hecho, concepto);
                AplicarEstilosValorNotaFin(docBuilder, exportadorBase);
            }
        }
        /// <summary>
        /// Inserta los elementos de la leyenda para el prospecto definitivo.
        /// </summary>
        /// <param name="docBuilder">Constructor del documento.</param>
        /// <param name="instancia">Documento de instancia.</param>
        /// <param name="estructuraReporte">Estructura del reporte.</param>
        private void InsertarLeyendaProspectoDefinitivo(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, ReporteXBRLDTO estructuraReporte)
        {
            var    hechoDocumentoDefinitivo = ObtenPrimerHechoPorIdConcepto(instancia, "ar_pros_DefinitiveDocument");
            var    nombreTipoReporte        = "Prospecto";
            String idTipoReporte;

            if (instancia.ParametrosConfiguracion.TryGetValue("tipoReporte", out idTipoReporte))
            {
                if (idTipoReporte.Equals("su"))
                {
                    nombreTipoReporte = "Suplemento";
                }
                else if (idTipoReporte.Equals("fo"))
                {
                    nombreTipoReporte = "Folleto";
                }
            }
            docBuilder.Writeln();
            docBuilder.Writeln();
            docBuilder.Writeln();
            docBuilder.Writeln();
            docBuilder.Writeln();
            docBuilder.Writeln();

            if (hechoDocumentoDefinitivo != null && !String.IsNullOrEmpty(hechoDocumentoDefinitivo.Valor))
            {
                if (hechoDocumentoDefinitivo.Valor.Equals("SI"))
                {
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
                    docBuilder.Writeln(nombreTipoReporte + " Definitivo");
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                }
                else
                {
                    docBuilder.Font.Color = Color.Red;
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
                    docBuilder.Writeln(nombreTipoReporte);
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                }
            }
            var hechoLeyenda = ObtenPrimerHechoPorIdConcepto(instancia, "ar_pros_LegendProspectusSupplementBrochure");

            if (hechoDocumentoDefinitivo != null && !String.IsNullOrEmpty(hechoDocumentoDefinitivo.Valor))
            {
                ConceptoDto concepto;
                if (instancia.Taxonomia.ConceptosPorId.TryGetValue(hechoLeyenda.IdConcepto, out concepto))
                {
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Justify;
                    WordUtil.InsertHtml(docBuilder, hechoLeyenda.IdConcepto + ":" + hechoLeyenda.Id,
                                        PARRAFO_HTML_NOTAS + (hechoLeyenda.Valor) + "</p>", false, true);
                    docBuilder.Writeln();
                }
            }
            docBuilder.Font.Color = Color.Black;
            docBuilder.InsertBreak(BreakType.PageBreak);
        }
        public ReplaceAction Replacing(ReplacingArgs args)
        {
            ArrayList runs = FindAndSplitMatchRuns(args);

            _documentBuilder.MoveTo((Run)runs[runs.Count - 1]);

            foreach (Run run in runs)
            {
                run.Remove();
            }
            var concepto = _documentoInstancia.Taxonomia.ConceptosPorId[HechoInstancia.IdConcepto];

            if (concepto.EsTipoDatoNumerico)
            {
                //Si es monetario, escribir el formato
                if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
                {
                    _documentBuilder.Write("$ ");
                }
                double valorDouble = 0;
                if (Double.TryParse(HechoInstancia.Valor, NumberStyles.Any, CultureInfo.InvariantCulture,
                                    out valorDouble))
                {
                    _documentBuilder.Write(valorDouble.ToString("#,##0.00"));
                }
                else
                {
                    _documentBuilder.Write(HechoInstancia.Valor);
                }
            }
            else if (
                concepto.TipoDato.Contains(
                    TiposDatoXBRL.TextBlockItemType) ||
                this._plantilla.ConceptoSeComportaComoTextBlockItem(concepto.Id))
            {
                WordUtil.InsertHtml(_documentBuilder, concepto.Id + ":" + HechoInstancia.Id, HechoInstancia.Valor, true);
            }
            else
            {
                _documentBuilder.Write(HechoInstancia.Valor);
            }


            // Signal to the replace engine to do nothing because we have already done all what we wanted.
            return(ReplaceAction.Skip);
        }
        /// <summary>
        /// Imprieme el texto de leyenda.
        /// </summary>
        /// <param name="leyenda">Texto a imprimir</param>
        /// <param name="docBuilder">Constructor del documento.</param>
        private void ImprimirLeyenda(String leyenda, DocumentBuilder docBuilder)
        {
            docBuilder.Font.Name = TipoLetraTituloRol;
            docBuilder.Font.Bold = false;
            docBuilder.Font.Size = 12;
            docBuilder.ParagraphFormat.StyleIdentifier = StyleIdentifier.Normal;
            docBuilder.ParagraphFormat.Alignment       = ParagraphAlignment.Justify;
            docBuilder.Font.Color = Color.Black;

            WordUtil.InsertHtml(docBuilder, "leyenda", "<p style=\"font-family:Arial;font-size: 12pt; text-align:justify;\" >" + leyenda + "</p>", false);



            docBuilder.InsertParagraph();
            docBuilder.ParagraphFormat.StyleIdentifier = StyleIdentifier.Normal;
            docBuilder.Writeln();
        }
        /// <summary>
        /// Inserta el logotipo de la emisora.
        /// </summary>
        /// <param name="docBuilder">Constructor del documento.</param>
        /// <param name="instancia">Documento de instancia.</param>
        /// <param name="estructuraReporte">Dto con información general del reporte.</param>
        private void IsertaLogotipoDeEmisora(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, ReporteXBRLDTO estructuraReporte)
        {
            var idConcepto    = "ar_pros_IssuerLogo";
            var hechoLogotipo = ObtenPrimerHechoPorIdConcepto(instancia, idConcepto);

            if (hechoLogotipo != null && !String.IsNullOrEmpty(hechoLogotipo.Valor))
            {
                ConceptoDto concepto;
                if (instancia.Taxonomia.ConceptosPorId.TryGetValue(idConcepto, out concepto))
                {
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Center;
                    WordUtil.InsertHtml(docBuilder, hechoLogotipo.IdConcepto + ":" + hechoLogotipo.Id,
                                        PARRAFO_HTML_NOTAS + (hechoLogotipo.Valor) + "</p>", false, true);
                    docBuilder.Writeln();
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Justify;
                }
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Exporta al documento de word el hecho del concepto para el trimestre actual, agrega el titulo y el contenido
        /// los hechos sin valor no son exportados
        /// </summary>
        /// <param name="estructura">Estructura actual a exportar</param>
        /// <param name="docBuilder">Clase auxiliar para la creación de contenido en Word</param>
        /// <param name="instancia">Documento de instancia a exportar</param>
        /// <param name="rol">Rol exportado</param>
        /// <param name="plantillaDocumento">Plantilla de documento exportado</param>
        private void ExportarEstructuraRol(EstructuraFormatoDto estructura, DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, string rol,
                                           IDefinicionPlantillaXbrl plantillaDocumento, DateTime fechaInicio, DateTime fechaFin, string claveIdioma)
        {
            var hechos = instancia.BuscarHechos(estructura.IdConcepto, null, null, fechaInicio, fechaFin, null);

            if (hechos.Count > 0 && hechos[0].Valor != null && !String.IsNullOrEmpty(hechos[0].Valor.Trim()))
            {
                if (String.IsNullOrEmpty(claveIdioma))
                {
                    claveIdioma = "es";
                }
                var etqs        = instancia.Taxonomia.ConceptosPorId[estructura.IdConcepto].Etiquetas[claveIdioma];
                var rolEtiqueta = String.IsNullOrEmpty(estructura.RolEtiquetaPreferido)
                    ? Etiqueta.RolEtiqueta
                    : estructura.RolEtiquetaPreferido;
                var etiqueta = instancia.Taxonomia.ConceptosPorId[estructura.IdConcepto].Nombre;
                if (etqs.ContainsKey(rolEtiqueta))
                {
                    etiqueta = etqs[rolEtiqueta].Valor;
                }

                var font = docBuilder.Font;
                font.Size = 8;
                font.Bold = true;
                font.Name = "Arial";

                docBuilder.Writeln(etiqueta);
                docBuilder.InsertParagraph();
                font.Bold = false;

                WordUtil.InsertHtml(docBuilder, estructura.IdConcepto + ":" + hechos[0].Id, hechos[0].Valor, true);

                docBuilder.InsertParagraph();
                docBuilder.Writeln("");
            }
            if (estructura.SubEstructuras != null)
            {
                foreach (var subestructura in estructura.SubEstructuras)
                {
                    ExportarEstructuraRol(subestructura, docBuilder, instancia, rol, plantillaDocumento, fechaInicio, fechaFin, claveIdioma);
                }
            }
        }
        override public void exportarRolAWord(DocumentBuilder docBuilder, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte)
        {
            docBuilder.CurrentSection.PageSetup.Orientation = Orientation.Portrait;
            docBuilder.CurrentSection.PageSetup.PaperSize   = PaperSize.Letter;
            docBuilder.CurrentSection.PageSetup.LeftMargin  = 40;
            docBuilder.CurrentSection.PageSetup.RightMargin = 40;

            //escribirEncabezado(docBuilder, instancia, estructuraReporte, true);
            imprimirTituloRol(docBuilder, rolAExportar);

            docBuilder.Font.Name  = TipoLetraTextos;
            docBuilder.Font.Bold  = false;
            docBuilder.Font.Size  = TamanioLetraTextos;
            docBuilder.Font.Color = Color.Black;
            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;

            foreach (String i in estructuraReporte.NotasAlPie.Keys)
            {
                var kv   = (KeyValuePair <Int32, String>)estructuraReporte.NotasAlPie[i];
                var nota = limpiarBloqueTexto(kv.Value);

                if (Regex.IsMatch(nota, "&lt;") || Regex.IsMatch(nota, "&gt;"))
                {
                    nota = HttpUtility.HtmlDecode(nota);
                }
                else
                {
                    nota = REGEXP_SALTO_LINEA.Replace(nota, "<br/>");
                }

                docBuilder.InsertHyperlink("[" + kv.Key + "] " + FLECHA_ARRIBA, MARCADOR_LINK_NOTAALPIE + kv.Key + "]", true);
                docBuilder.StartBookmark(MARCADOR_NOTAALPIE + kv.Key + "]");
                WordUtil.InsertHtml(docBuilder, "nn", PARRAFO_HTML_NOTAS + nota + "</p>", false, true);


                docBuilder.EndBookmark(MARCADOR_NOTAALPIE + kv.Key + "]");
            }
        }
Ejemplo n.º 8
0
        private void PintaTablaDimensionSerie(DocumentBuilder docBuilder, String valor, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar, ReporteXBRLDTO estructuraReporte, ConceptoReporteDTO concepto)
        {
            docBuilder.Writeln();
            // var listaConseptosReportes = estructuraReporte.Hipercubos;
            foreach (var dato in estructuraReporte.Hipercubos)
            {
                var      variable = dato;
                string[] d        = variable.Key.Split(new string[] { "Table" }, StringSplitOptions.None);
                string   conceptoHipercuboTable = (d[0]);

                if (conceptoHipercuboTable == valor && !Evaluador.Contains(variable.Key))
                {
                    ConceptoReporteDTO primerConcepto = null;

                    if (!estructuraReporte.Roles.ContainsKey(rolAExportar.Rol))
                    {
                        throw new IndexOutOfRangeException("No existe el rol [" + rolAExportar.Rol + "] dentro del listado de roles del reporte.");
                    }
                    if (estructuraReporte.Roles.ContainsKey(rolAExportar.Rol))
                    {
                        if (!concepto.Abstracto)
                        {
                            primerConcepto = concepto;
                            break;
                        }
                    }

                    var hipercubo = variable;


                    Table tablaActual = docBuilder.StartTable();
                    Color colorTitulo = Color.FromArgb(ColorTituloTabla[0], ColorTituloTabla[1], ColorTituloTabla[2]);
                    docBuilder.ParagraphFormat.SpaceAfter  = 0;
                    docBuilder.ParagraphFormat.SpaceBefore = 2;

                    //docBuilder.InsertCell();
                    // docBuilder.EndRow();
                    docBuilder.CellFormat.Shading.BackgroundPatternColor = colorTitulo;
                    docBuilder.Font.Color = Color.White;
                    docBuilder.Font.Size  = TamanioLetraContenidoTabla;

                    docBuilder.InsertCell();

                    docBuilder.CellFormat.Shading.BackgroundPatternColor = colorTitulo;
                    docBuilder.CellFormat.PreferredWidth = PreferredWidth.Auto;
                    docBuilder.Font.Color = Color.White;
                    establecerFuenteTituloCampo(docBuilder);
                    docBuilder.Font.Size = TamanioLetraTituloTabla;
                    docBuilder.Write("Serie [Eje]");
                    docBuilder.CellFormat.HorizontalMerge = CellMerge.None;

                    if (hipercubo.Value.Titulos.Count > 0)
                    {
                        for (var indexTitulo = 0; indexTitulo < hipercubo.Value.Titulos.Count; indexTitulo++)
                        {
                            var titulo = hipercubo.Value.Titulos[indexTitulo];
                            docBuilder.InsertCell();
                            docBuilder.Write(titulo);
                        }
                        docBuilder.EndRow();
                    }



                    establecerFuenteTituloCampo(docBuilder);
                    docBuilder.Font.Size = TamanioLetraTituloTabla;

                    int fila = 0;


                    if (concepto.Abstracto)
                    {
                        fila = +1;

                        for (int iCell = 0; iCell < fila; iCell++)
                        {
                            docBuilder.InsertCell();
                            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                        }
                    }
                    if (concepto.Abstracto)
                    {
                        docBuilder.Bold       = true;
                        docBuilder.Font.Color = Color.White;
                        docBuilder.CellFormat.Shading.BackgroundPatternColor = colorTitulo;

                        docBuilder.ParagraphFormat.LeftIndent = (concepto.Tabuladores < 0 ? concepto.Tabuladores : 0);
                        docBuilder.ParagraphFormat.Alignment  = ParagraphAlignment.Left;
                        docBuilder.Write(concepto.Valor);
                        docBuilder.InsertCell();
                        docBuilder.EndRow();
                        //  tituloAbstracto.Add(concepto.Valor);
                    }
                    else
                    {
                        docBuilder.Bold = false;
                    }


                    docBuilder.CellFormat.Shading.BackgroundPatternColor = Color.White;
                    docBuilder.CellFormat.PreferredWidth = PreferredWidth.Auto;
                    docBuilder.Font.Color = Color.Black;
                    docBuilder.Bold       = false;
                    foreach (var idConcepto in hipercubo.Value.Hechos.Keys)
                    {
                        var matrizPlantillaContexto = hipercubo.Value.Hechos[idConcepto];
                        docBuilder.InsertCell();
                        var nombreConcepto =
                            DesgloseDeCreditosHelper.obtenerEtiquetaDeConcepto(instancia.Taxonomia, idConcepto, "es", ReporteXBRLUtil.ETIQUETA_DEFAULT);
                        docBuilder.Write(nombreConcepto);
                        ConceptoHiper.Add(idConcepto);

                        foreach (var idPlantillaContexto in matrizPlantillaContexto.Keys)
                        {
                            docBuilder.CellFormat.WrapText       = true;
                            docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                            var listaHechos = matrizPlantillaContexto[idPlantillaContexto];
                            for (var indexHecho = 0; indexHecho < listaHechos.Length; indexHecho++)
                            {
                                var hecho      = listaHechos[indexHecho];
                                var valorHecho = hecho.Valor;

                                docBuilder.InsertCell();
                                if (hecho.NoEsNumerico)
                                {
                                    docBuilder.CellFormat.WrapText       = true;
                                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                                }
                                else
                                {
                                    docBuilder.CellFormat.WrapText       = false;
                                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Right;
                                }


                                if ((hecho != null && !String.IsNullOrWhiteSpace(hecho.Valor)) && instancia.Taxonomia.ConceptosPorId.ContainsKey(hecho.IdConcepto))
                                {
                                    var conceptoHecho = instancia.Taxonomia.ConceptosPorId[hecho.IdConcepto];
                                    if (conceptoHecho.TipoDato.Contains(TIPO_DATO_TEXT_BLOCK))
                                    {
                                        WordUtil.InsertHtml(docBuilder, hecho.IdConcepto + ":" + hecho.Id, PARRAFO_HTML_NOTAS_Texblock + valorHecho + "</p>", false, true);

                                        //docBuilder.InsertHtml(PARRAFO_HTML_NOTAS_Texblock + limpiarBloqueTexto(valorHecho) + "</p>", true);
                                    }
                                    else
                                    {
                                        docBuilder.Writeln(valorHecho);
                                    }
                                }
                            }
                        }

                        docBuilder.EndRow();
                    }


                    establecerBordesGrisesTabla(tablaActual);
                    docBuilder.EndTable();
                    docBuilder.Writeln();
                    docBuilder.Writeln();
                    Evaluador.Add(variable.Key);
                    break;
                }
            }
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Pinta el contenido de una celda para un concepto simple.
        /// </summary>
        /// <param name="docBuilder">Constructor del documenot.</param>
        /// <param name="celda">Celda que se pretende presentar.</param>
        /// <param name="tarjeta">Tarjeta con el valor de la celda.</param>
        /// <param name="exportadorOrigen">Exportador original.</param>
        /// <param name="estructuraReporte">Dto con información general del reporte.</param>
        private void PintaCeldaConceptoSimple(
            DocumentBuilder docBuilder,
            CeldasPresentacionHipercuboDto celda,
            IDictionary <string, HechoDto> tarjeta,
            ExportadorRolDocumentoBase exportadorOrigen,
            ReporteXBRLDTO estructuraReporte)
        {
            HechoDto hecho;
            var      texto  = String.Empty;
            var      esHtml = false;

            if (tarjeta.TryGetValue(celda.IdConcepto, out hecho))
            {
                esHtml = hecho.TipoDato.Contains(ExportadorRolDocumentoBase.TIPO_DATO_TEXT_BLOCK);
                texto  = hecho.Valor ?? String.Empty;
            }
            if (celda.AgregarEnIndice)
            {
                AsignaEstilosParaIndice(docBuilder, exportadorOrigen);
            }
            if (celda.Colspan > 1)
            {
                var newCells = celda.Colspan - 1;
                docBuilder.InsertCell();
                docBuilder.CellFormat.HorizontalMerge = CellMerge.First;
                if (!esHtml)
                {
                    if (!WordUtil.EsRTF(texto))
                    {
                        docBuilder.Write(texto);
                    }
                    else
                    {
                        var lastIndex = texto.Length < 1000 ? texto.Length - 1 : 1000;
                        docBuilder.Write(texto.Substring(0, lastIndex));
                    }
                    EvaluaPresentarEnlaceArchivo(texto, docBuilder, celda, tarjeta, estructuraReporte);
                }
                else
                {
                    WordUtil.InsertHtml(docBuilder, ":celda", "<div style=\"font-family:Arial;font-size: 6pt;\">" + texto + "</div>", false);
                }
                for (var index = 0; index < newCells; index++)
                {
                    docBuilder.InsertCell();
                    docBuilder.CellFormat.HorizontalMerge = CellMerge.Previous;
                }
            }
            else
            {
                docBuilder.InsertCell();
                docBuilder.CellFormat.HorizontalMerge = CellMerge.None;
                if (!esHtml)
                {
                    docBuilder.Write(texto);
                    EvaluaPresentarEnlaceArchivo(texto, docBuilder, celda, tarjeta, estructuraReporte);
                }
                else
                {
                    WordUtil.InsertHtml(docBuilder, ":celda", "<div style=\"font-family:Arial;font-size: 6pt;\">" + texto + "</div>", false);
                }
            }
            if (celda.AgregarEnIndice)
            {
                EliminaEstilosParaIndice(docBuilder, exportadorOrigen);
            }
        }
        /// <summary>
        /// Pinta el contenido de un cubo ya organizado en una tabla de Word
        /// </summary>

        private void PintaTablaCubo(
            HipercuboReporteDTO hipercubo,
            DocumentoInstanciaXbrlDto instancia,
            ReporteXBRLDTO estructuraReporte,
            DocumentBuilder docBuilder,
            ConceptoReporteDTO concepto,
            IndiceReporteDTO rolAExportar,
            ExportadorRolDocumentoBase exportadorOrigen)
        {
            var matrizHechosPlantillaContexto = hipercubo.Utileria.ReordenaConjutosPorExplicitaImplicitaTituloConcepto(hipercubo.Hechos, hipercubo.Titulos);
            var matrizHechosTitulo            = matrizHechosPlantillaContexto.Values.First();

            var colorTitulo = exportadorOrigen.ObtenColorTitulo();

            docBuilder.ParagraphFormat.SpaceAfter  = 0;
            docBuilder.ParagraphFormat.SpaceBefore = 2;

            foreach (var tituloSerie in matrizHechosTitulo.Keys)
            {
                var tablaActual = docBuilder.StartTable();
                PintaFilaSubTitulo(tituloSerie, docBuilder, 2, exportadorOrigen);
                var hechosPorConcepto = matrizHechosTitulo[tituloSerie];
                foreach (var idConcepto in hechosPorConcepto.Keys)
                {
                    if (!ConceptosAplican.Contains(idConcepto))
                    {
                        continue;
                    }
                    var etiquetaConcepto =
                        DesgloseDeCreditosHelper
                        .obtenerEtiquetaDeConcepto(
                            instancia.Taxonomia, idConcepto,
                            estructuraReporte.Lenguaje,
                            ReporteXBRLUtil.ETIQUETA_DEFAULT);
                    AsignaEstilosConcepto(docBuilder, exportadorOrigen);
                    docBuilder.Bold = true;
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Left;
                    docBuilder.InsertCell();
                    docBuilder.Write(etiquetaConcepto);
                    docBuilder.InsertCell();
                    docBuilder.Bold = false;
                    docBuilder.ParagraphFormat.Alignment = ParagraphAlignment.Right;
                    var hecho = hechosPorConcepto[idConcepto];
                    if (hecho != null && !String.IsNullOrWhiteSpace(hecho.Valor) && instancia.Taxonomia.ConceptosPorId.ContainsKey(hecho.IdConcepto))
                    {
                        var conceptoHecho = instancia.Taxonomia.ConceptosPorId[hecho.IdConcepto];
                        if (conceptoHecho.TipoDato.Contains(ExportadorRolDocumentoBase.TIPO_DATO_TEXT_BLOCK))
                        {
                            WordUtil.InsertHtml(docBuilder, hecho.IdConcepto + ":" +
                                                hecho.Id, ExportadorRolDocumentoBase.PARRAFO_HTML_NOTAS_Texblock + hecho.Valor + "</p>", false, true);
                        }
                        else
                        {
                            exportadorOrigen.EscribirValorHecho(docBuilder, estructuraReporte, hecho, instancia.Taxonomia.ConceptosPorId[hecho.IdConcepto]);
                        }
                    }
                    docBuilder.EndRow();
                }
                exportadorOrigen.establecerBordesGrisesTabla(tablaActual);
                docBuilder.EndTable();
                docBuilder.Writeln();
                docBuilder.Writeln();
            }
        }