/// <summary>
/// Determina si existe información relacionada con esta tabla.
/// </summary>
/// <param name="conceptoPartidas">Concepto de partidas a evaluar.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <returns>Si contiene información</returns>
private Boolean ContieneInformacion(EstructuraFormatoDto conceptoPartidas, DocumentoInstanciaXbrlDto instancia)
{
var contieneInformacion = false;
foreach (var partida in conceptoPartidas.SubEstructuras)
{
IList <String> idsHechosPartida;
if (instancia.HechosPorIdConcepto.TryGetValue(partida.IdConcepto, out idsHechosPartida))
{
foreach (var idHecho in idsHechosPartida)
{
HechoDto hechoPartida;
if (instancia.HechosPorId.TryGetValue(idHecho, out hechoPartida))
{
if (hechoPartida != null && !String.IsNullOrEmpty(hechoPartida.Valor))
{
contieneInformacion = true;
break;
}
}
}
if (contieneInformacion)
{
break;
}
}
}
return(contieneInformacion);
}
public EstructuraFormatoDto ObtenEstructura(ConceptoReporteDTO conceptoOrigen, DocumentoInstanciaXbrlDto instancia, IndiceReporteDTO rolAExportar)
{
EstructuraFormatoDto estructuraRequerida = null;
var listaEstructurasHipercubos = new List <EstructuraFormatoDto>();
var rolPresentacion = instancia.Taxonomia.RolesPresentacion.Where(x => x.Uri.Equals(rolAExportar.Uri)).FirstOrDefault();
var conceptosTaxonomia = instancia.Taxonomia.ConceptosPorId;
if (rolPresentacion != null)
{
var estructurasAnalizar = new List <EstructuraFormatoDto>(rolPresentacion.Estructuras);
for (var indiceEstructrua = 0; indiceEstructrua < estructurasAnalizar.Count; indiceEstructrua++)
{
var estructura = estructurasAnalizar[indiceEstructrua];
if (estructura.SubEstructuras != null && estructura.SubEstructuras.Count > 0)
{
if (estructura.IdConcepto.Equals(conceptoOrigen.IdConcepto))
{
estructuraRequerida = estructura;
break;
}
estructurasAnalizar.AddRange(estructura.SubEstructuras);
}
}
}
return(estructuraRequerida);
}
public override void EvaluaEstructuraConcepto(EstructuraFormatoDto estructura, int tabuladores, IList <ConceptoReporteDTO> listaConceptos, String idRol)
{
List <String> idExcluyente = new List <String>()
{
"annext_UnpaidBalanceOfTheAssetsGroupedInArrearsAtTheEndOfThePeriodAbstract",
"annext_CurrentMonth",
"annext_LastMonth",
"annext_NumberOfAssetsGroupedInArrearsAtTheEndOfThePeriodAbstract",
"annext_NumberOfAssetsCurrentMonth",
"annext_NumberOfAssetsLastMonth",
};
//LogUtil.Info("tabuladores:" + tabuladores + ", idConcepto: " + estructura.IdConcepto);
if (!reporteXBRLDTO.Instancia.Taxonomia.ConceptosPorId.ContainsKey(estructura.IdConcepto))
{
throw new NullReferenceException("No existe el contexto [" + estructura.IdConcepto + "] en la taxonomía.");
}
var concepto = reporteXBRLDTO.Instancia.Taxonomia.ConceptosPorId[estructura.IdConcepto];
var hechosReporte = new Dictionary <string, HechoReporteDTO>();
if (!reporteXBRLDTO.ConfiguracionReporte.PeriodosPorRol.ContainsKey(idRol) || (concepto.EsMiembroDimension ?? false) || concepto.EsHipercubo || (concepto.EsDimension ?? false))
{
return;
}
foreach (var idPeriodo in reporteXBRLDTO.ConfiguracionReporte.PeriodosPorRol[idRol])
{
if ((!idPeriodo.Equals("periodo_actual") && idExcluyente.Contains(concepto.Id)) || (idPeriodo.Equals("periodo_actual") && !idExcluyente.Contains(concepto.Id)))
{
hechosReporte.Add(idPeriodo, new HechoReporteDTO());
}
}
var conceptoReporte = new ConceptoReporteDTO()
{
IdConcepto = concepto.Id,
Abstracto = concepto.EsAbstracto ?? false,
Etiqueta = estructura.RolEtiquetaPreferido,
Numerico = concepto.EsTipoDatoNumerico,
Tabuladores = tabuladores * reporteXBRLDTO.ConfiguracionReporte.EstilosReporte.MultiploTabuladores,
TipoDato = concepto.TipoDato,
Hechos = hechosReporte,
AtributosAdicionales = concepto.AtributosAdicionales
};
listaConceptos.Add(conceptoReporte);
var listaSubEstructuras = estructura.SubEstructuras;
if (listaSubEstructuras != null && listaSubEstructuras.Count() > 0)
{
var tabuladoresItera = tabuladores++;
foreach (var subEstructura in listaSubEstructuras)
{
EvaluaEstructuraConcepto(subEstructura, tabuladoresItera, listaConceptos, idRol);
}
}
}
/// <summary>
/// Recorre el árbol de estructuras y los agrega a la lista plana de estructuras
/// </summary>
/// <param name="listaConceptos">Lista a llenar</param>
/// <param name="estructura">Estructura a agregar</param>
private static void AgregarNodoEstructura(List <ConceptoDto> listaConceptos, EstructuraFormatoDto estructura, TaxonomiaDto taxonomia)
{
if (estructura.IdConcepto != null && taxonomia.ConceptosPorId.ContainsKey(estructura.IdConcepto))
{
if (!listaConceptos.Any(x => x.Id.Equals(estructura.IdConcepto)))
{
listaConceptos.Add(taxonomia.ConceptosPorId[estructura.IdConcepto]);
}
}
if (estructura.SubEstructuras != null)
{
foreach (var subEstructura in estructura.SubEstructuras)
{
AgregarNodoEstructura(listaConceptos, subEstructura, taxonomia);
}
}
}
/// <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);
}
}
}
/// <summary>
/// Metodo recursivo que procesa los conceptos del rol actual y genera un listado de conceptos con sus hechos y dimensiones
/// </summary>
/// <param name="documentoInstanciaXbrlDto">Modelo DTO</param>
/// <param name="uriRolPresentacion">uri del rol a procesar</param>
/// <param name="listaConceptos">lista que contiene los conceptos procesados</param>
/// <param name="estructura">contiene el concepto a procesar</param>
/// <param name="taxonomia">Objeto de taxonomía utilizado para obtener etiquetas de presentación</param>
/// <param name="idioma">Idioma de presentación</param>
/// <param name="indentacion">Nivel del concepto</param>
/// <param name="columnas">lista de columnas que tiene el reporte</param>
/// <param name="listaDeConceptosEnHiperCubos">lista de conceptos que el rol a procesar tiene en hipercubos</param>
private void AgregarNodoEstructura(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, string uriRolPresentacion, List <EstructuraConceptoReporte> listaConceptos, EstructuraFormatoDto estructura,
TaxonomiaDto taxonomia, string idioma, int indentacion, List <EstructuraColumnaReporte> columnas, IEnumerable <string> listaDeConceptosEnHiperCubos, bool agruparPorUnidad, IEnumerable <string> conceptosIdPermitidos)
{
if (!conceptosIdPermitidos.Contains(estructura.IdConcepto))
{
return;
}
string nombreconcepto = string.Empty;
var concepto = taxonomia.ConceptosPorId[estructura.IdConcepto];
if (string.IsNullOrEmpty(estructura.RolEtiquetaPreferido))
{
nombreconcepto = UtilAbax.ObtenerEtiqueta(taxonomia, estructura.IdConcepto, Etiqueta.RolEtiqueta, idioma);
}
else
{
nombreconcepto = UtilAbax.ObtenerEtiqueta(taxonomia, estructura.IdConcepto,
estructura.RolEtiquetaPreferido, idioma);
}
if (listaDeConceptosEnHiperCubos.Contains(estructura.IdConcepto))
{
IList <EstructuraConceptoReporte> conceptosConDimension = BuscarConceptosConDimensiones(taxonomia, documentoInstanciaXbrlDto, concepto, uriRolPresentacion, idioma, columnas, nombreconcepto, indentacion, agruparPorUnidad);
if (conceptosConDimension.Any())
{
listaConceptos.AddRange(conceptosConDimension);
}
}
else
{
var hechoSinDimension = ObtenerPrimerHechoSinDimension(documentoInstanciaXbrlDto, concepto, uriRolPresentacion, idioma, columnas, agruparPorUnidad);
listaConceptos.Add(new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = indentacion,
EsAbstracto = concepto.EsAbstracto,
Hechos = hechoSinDimension,
Dimensiones = new Dictionary <string, EstructuraDimensionReporte>()
});
}
if (estructura.SubEstructuras != null)
{
indentacion++;
foreach (var subEstructura in estructura.SubEstructuras)
{
AgregarNodoEstructura(documentoInstanciaXbrlDto, uriRolPresentacion, listaConceptos, subEstructura, taxonomia, idioma, indentacion, columnas, listaDeConceptosEnHiperCubos, agruparPorUnidad, conceptosIdPermitidos);
}
indentacion--;
}
}
