/// <summary>
/// Determina si el periodo dado es equivalente a la plantilla actual.
/// </summary>
/// <param name="periodo">Periodo que se pretende comparar.</param>
/// <param name="definicionPlantilla">Definicion de la plantilla para inicializar las variables del periodo.</param>
/// <returns>Si el contexto aplica para la plantilla actual.</returns>
public bool EsEquivalente(PeriodoDto periodo, IDefinicionPlantillaXbrl definicionPlantilla)
{
if (periodo.Tipo != Tipo)
{
return(false);
}
if (!VariablesEvaluadas)
{
EvaluaVariablesPlantilla(definicionPlantilla);
}
if (Tipo == PeriodoDto.Instante && FechaInstante != null)
{
if (!FechaInstante.Equals(periodo.FechaInstante) &&
!((DateTime)FechaInstante).ToUniversalTime().Equals(periodo.FechaInstante))
{
return(false);
}
}
if (Tipo == PeriodoDto.Duracion && FechaInicio != null && FechaFin != null)
{
if (!FechaInicio.Equals(periodo.FechaInicio) &&
!((DateTime)FechaInicio).ToUniversalTime().Equals(periodo.FechaInicio))
{
return(false);
}
if (!FechaFin.Equals(periodo.FechaFin) &&
!((DateTime)FechaFin).ToUniversalTime().Equals(periodo.FechaFin))
{
return(false);
}
}
return(true);
}
/// <summary>
/// (non-Javadoc)
/// </summary>
/// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#newInstance()
public override ReporteBuilder newInstance(IDefinicionPlantillaXbrl plantilla)
{
ReporteBuilder builder = new ReporteIFRSXBRLBuilder2019();
builder.Cache = Cache;
return(builder);
}
///
/// (non-Javadoc)
/// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#newInstance(java.lang.String)
////
public override ReporteBuilder newInstance(IDefinicionPlantillaXbrl plantilla, String idioma)
{
ReporteBuilder builder = new ReporteFIDUXBRLBuilder(idioma);
builder.Cache = Cache;
return(builder);
}
/// <summary>
/// Genera un diccionario con los contextos por columna para las calificaciones.
/// </summary>
/// <param name="conceptoMiembro">Concepto miembro de las calificadoras.</param>
/// <param name="diccionarioContextosSerie">Diccionario con los contextos por serie.</param>
/// <param name="hipercuboUtil"></param>
/// <param name="instancia">Documento de instancia a evaluar.</param>
/// <param name="plantillaDocumento">Plantilla del documento de instancia.</param>
/// <returns></returns>
private IDictionary <int, Dto.ContextoDto> GeneraContextosCalificaciones(
ConceptoDto conceptoMiembro,
IDictionary <int, Dto.ContextoDto> diccionarioContextosSerie,
EvaluadorHipercuboUtil hipercuboUtil,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantillaDocumento)
{
var contextosColumna = new Dictionary <int, Dto.ContextoDto>();
try
{
PlantillaContextoDto plantillaContextoDto = null;
if (!hipercuboUtil.configuracion.PlantillasContextos.TryGetValue(conceptoMiembro.Nombre, out plantillaContextoDto))
{
LogUtil.Error("No existe una definición de plantilla con el identificador \"" + conceptoMiembro.Nombre + "\".");
return(contextosColumna);
}
foreach (var indexColumn in diccionarioContextosSerie.Keys)
{
var contextoSerie = diccionarioContextosSerie[indexColumn];
var dimensiones = contextoSerie.ValoresDimension;
var contextoCalificacion = plantillaContextoDto.GeneraContexto(instancia, plantillaDocumento, dimensiones);
plantillaDocumento.InyectarContextoADocumentoInstancia(contextoCalificacion);
contextosColumna.Add(indexColumn, contextoCalificacion);
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
}
return(contextosColumna);
}
/// <summary>
/// Inicializa los valores de las fehcas.
/// </summary>
/// <param name="definicionPlantilla">Definición de la plantilla con las variables a evaluar.</param>
public void EvaluaVariablesPlantilla(IDefinicionPlantillaXbrl definicionPlantilla)
{
if (Tipo == PeriodoDto.Instante)
{
FechaInstante = ParseVariableFecha(VariableFechaInstante, definicionPlantilla);
IdGrupoFechas = definicionPlantilla.ObtenerVariablePorId(VariableFechaInstante);
if (IdGrupoFechas == null)
{
throw new NullReferenceException("No existe la variable " + VariableFechaInstante + " para la fecha instante en la definición de plantilla.");
}
}
if (Tipo == PeriodoDto.Duracion)
{
FechaInicio = ParseVariableFecha(VariableFechaInicio, definicionPlantilla);
FechaFin = ParseVariableFecha(VariableFechaFin, definicionPlantilla);
var valorFechaInicio = definicionPlantilla.ObtenerVariablePorId(VariableFechaInicio);
var valorFechaFin = definicionPlantilla.ObtenerVariablePorId(VariableFechaFin);
if (valorFechaInicio == null)
{
throw new NullReferenceException("No existe la variable " + VariableFechaInicio + " para la fecha inicio la definición de plantilla.");
}
if (valorFechaFin == null)
{
throw new NullReferenceException("No existe la variable " + VariableFechaFin + " para la fecha fin la definición de plantilla.");
}
IdGrupoFechas = valorFechaInicio + "_" + valorFechaFin;
}
VariablesEvaluadas = true;
}
/// <summary>
/// Contructor que inicializa en base a la ruta del archivo de configuración.
/// </summary>
/// <param name="configPath"></param>
public EvaluadorHipercuboUtil(string configPath, DocumentoInstanciaXbrlDto documentoInstancia, IDefinicionPlantillaXbrl definicionPlantilla)
{
var assembly = Assembly.GetExecutingAssembly();
using (Stream stream = assembly.GetManifestResourceStream(configPath))
{
if (stream != null)
{
using (StreamReader reader = new StreamReader(stream))
{
string result = reader.ReadToEnd();
configuracion = JsonConvert.DeserializeObject <ConfiguracionReporteHipercuboDto>(result);
}
}
else
{
throw new NullReferenceException("No fue posible localizar el recurso: " + configPath);
}
}
this.documentoInstancia = documentoInstancia;
this.definicionPlantilla = definicionPlantilla;
consultaDocumentoInstanciaUtil = new ConsultaDocumentoInstanciaUtil(documentoInstancia, definicionPlantilla);
Init();
}
/// <summary>
/// Carga los datos de una hoja de cálculo y aplica los valores encontrados al documento de instancia
/// </summary>
/// <param name="hojaImportar">Hoja de cálculo a importar</param>
/// <param name="hojaPlantilla">Hoja de cálculo de la plantilla</param>
/// <param name="instancia">Documento de instancia destino</param>
/// <param name="informeErrores">Lista de de informe de errores</param>
/// <param name="plantillaDocumento"></param>
private void ImportarHojaDeCalculo(ISheet hojaImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
ResumenProcesoImportacionExcelDto resumenImportacion,
IDefinicionPlantillaXbrl plantillaDocumento)
{
var rolUri = plantillaDocumento.ObtenerRolDeAlias(hojaPlantilla.SheetName);
if (rolUri != null)
{
try
{
//Si el rol tiene implementación específica utilizarla, si no, utilizar el importador genérico de plantilla
var idSpringImportador = plantillaDocumento.ObtenerIdSpringDefinicionElementosPlantillaDeRol(rolUri);
if (ObtenerApplicationContext().ContainsObject("importador_" + idSpringImportador))
{
var importadorRol = (IImportadorExportadorRolDocumento)ObtenerApplicationContext().GetObject("importador_" + idSpringImportador);
importadorRol.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
}
else
{
ImportadorRolPlantillaGenerico.ImportarDatosDeHojaExcel(hojaImportar, hojaPlantilla, instancia, rolUri, resumenImportacion, plantillaDocumento);
}
}
catch (Exception ex)
{
LogUtil.Error(ex);
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
IdRol = rolUri,
Mensaje = "Ocurrió un error al importar el rol : " + rolUri + " : " + ex.Message
});
}
}
}
/// <summary>
/// Actualiza el valor de un hecho en el documento de instancia
/// </summary>
/// <param name="resumenImportacion"></param>
/// <param name="hechoActualizar"></param>
/// <param name="valorImportar"></param>
/// <param name="plantillaDocumento"></param>
private void ActualizarValorHecho(Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, HechoDto hechoActualizar, string valorImportar,
IDefinicionPlantillaXbrl plantillaDocumento, DocumentoInstanciaXbrlDto instancia, ISheet hojaImportar, int iRenglon, int columna)
{
var concepto = instancia.Taxonomia.ConceptosPorId[hechoActualizar.IdConcepto];
if (!ActualizarValor(concepto, valorImportar, hechoActualizar, plantillaDocumento))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, concepto.Id),
hojaImportar.SheetName,
iRenglon.ToString(),
"0",
valorImportar);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoActualizar.IdConcepto,
IdHecho = hechoActualizar.Id,
ValorImportado = valorImportar,
HojaExcel = hojaImportar.SheetName,
Renglon = iRenglon,
Columna = columna
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, hechoActualizar.Id));
}
}
public override ReporteBuilder newInstance(IDefinicionPlantillaXbrl plantilla, string idioma)
{
ReporteBuilder builder = new ReporteAnualProspectoXBRLBuilder(idioma);
builder.Cache = Cache;
builder.plantilla = plantilla;
return builder;
}
/// <summary>
/// (non-Javadoc)
/// </summary>
/// @see com.bmv.spread.xbrl.reportes.builder.ReporteBuilder#newInstance(java.lang.String)
override public ReporteBuilder newInstance(IDefinicionPlantillaXbrl plantilla, String idioma)
{
ReporteBuilder builder = new ReporteEventosRelevantesBuilder(idioma);
builder.Cache = Cache;
return(builder);
}
public override ReporteBuilder newInstance(IDefinicionPlantillaXbrl plantilla)
{
ReporteBuilder builder = new ReporteAnexoTXBRLBuilder();
builder.Cache = Cache;
builder.plantilla = plantilla;
return(builder);
}
/// <summary>
/// Genera los contextos de la serie.
/// </summary>
/// <param name="idDimension">Identificador de la idmensión evaluada.</param>
/// <param name="rowImportar">Fila a iterar.</param>
/// <param name="indiceColumnaInicio">Columna donde inicia la iteración.</param>
/// <param name="hipercuboUtil">Utilería con la información del hipercubo.</param>
/// <param name="resumenImportacion">Resumen de la importación para agregar errores en caso de presentarse.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantillaDocumento">Plantilla del documento.</param>
/// <param name="claveIdioma"></param>
/// <returns>Diccionario con los identificadores de contexto por columna.</returns>
private IDictionary <int, Dto.ContextoDto> GeneraContextosSeries(
String idDimension,
IRow rowImportar,
int indiceColumnaInicio,
EvaluadorHipercuboUtil hipercuboUtil,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantillaDocumento,
string claveIdioma)
{
var nombreConcepto = ObtenEtiquetaConcepto(idDimension, instancia.Taxonomia, claveIdioma);
var contextosColumna = new Dictionary <int, Dto.ContextoDto>();
PlantillaDimensionInfoDto plantillaDimension = null;
if (!hipercuboUtil.configuracion.PlantillaDimensiones.TryGetValue(idDimension, out plantillaDimension))
{
LogUtil.Error("No existe una definición de plantilla con el identificador \"" + idDimension + "\".");
return(contextosColumna);
}
PlantillaContextoDto plantillaContexto = hipercuboUtil.configuracion.PlantillasContextos.Values.First();
var seriesEvaluadas = new Dictionary <String, int>();
for (var indexSerie = indiceColumnaInicio; indexSerie <= rowImportar.LastCellNum; indexSerie++)
{
var celdaSerie = rowImportar.GetCell(indexSerie);
if (celdaSerie != null && !celdaSerie.CellType.Equals(CellType.Blank))
{
var nombreSerie = ExcelUtil.ObtenerValorCelda(celdaSerie.CellType, celdaSerie);
if (String.IsNullOrWhiteSpace(nombreSerie))
{
continue;
}
if (seriesEvaluadas.ContainsKey(nombreSerie))
{
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
Mensaje = "No fue posible agregar la serie \"" + nombreSerie +
"\", de la hoja \"" + nombreHoja +
"\" renglon \"" + rowImportar.RowNum.ToString() + "\" columna \"" + celdaSerie.ColumnIndex.ToString() +
"\", debido a que este nombre de serie ya fué indicado previamente en la columna \"" + seriesEvaluadas[nombreSerie] + "\".",
});
continue;
}
var miembroDimensionSerie = plantillaDimension.CreaMiembroDimension(nombreSerie);
var listaDimensiones = new List <DimensionInfoDto>()
{
miembroDimensionSerie
};
var contexto = plantillaContexto.GeneraContexto(instancia, plantillaDocumento, listaDimensiones);
plantillaDocumento.InyectarContextoADocumentoInstancia(contexto);
contextosColumna.Add(celdaSerie.ColumnIndex, contexto);
seriesEvaluadas.Add(nombreSerie, celdaSerie.ColumnIndex);
}
}
return(contextosColumna);
}
/// <summary>
/// Crea un nuevo hecho en el documento de instancia basado en los parámetros enviados.
/// </summary>
/// <returns></returns>
private HechoDto CrearHecho(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, string idConcepto,
ContextoDto contextoDestino)
{
HechoDto hechoNuevo = null;
ConceptoDto concepto = instancia.Taxonomia.ConceptosPorId[idConcepto];
UnidadDto unidadDestino = null;
if (concepto.EsTipoDatoNumerico)
{
//Si es moentario
var listaMedidas = new List <MedidaDto>();
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
{
listaMedidas.Add(new MedidaDto()
{
EspacioNombres = plantillaDocumento.ObtenerVariablePorId("medida_http___www_xbrl_org_2003_iso4217"),
Nombre = plantillaDocumento.ObtenerVariablePorId("medida_MXN")
});
}
else
{
//Unidad pure
listaMedidas.Add(new MedidaDto()
{
EspacioNombres = plantillaDocumento.ObtenerVariablePorId("medida_http___www_xbrl_org_2003_instance"),
Nombre = plantillaDocumento.ObtenerVariablePorId("medida_pure")
});
}
var unidades = instancia.BuscarUnidades(Unit.Medida, listaMedidas, null);
if (unidades == null || unidades.Count == 0)
{
unidadDestino = new UnidadDto()
{
Id = "U" + Guid.NewGuid().ToString(),
Tipo = Unit.Medida,
Medidas = listaMedidas
};
instancia.UnidadesPorId.Add(unidadDestino.Id, unidadDestino);
}
else
{
unidadDestino = unidades[0];
}
}
hechoNuevo = instancia.CrearHecho(concepto.Id, unidadDestino != null ? unidadDestino.Id : null, contextoDestino.Id, "A" + Guid.NewGuid().ToString());
if (concepto.EsTipoDatoNumerico)
{
hechoNuevo.Decimales = _valorDecimalesHechos;
}
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo);
return(hechoNuevo);
}
/// <summary>
/// Constructor de la clase.
/// </summary>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantillaDocumento">Plantilla de definición.</param>
public ConfiguracionReporteExcel427000(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, ResumenProcesoImportacionExcelDto resumenImportacion)
{
Instancia = instancia;
PlantillaDocumento = plantillaDocumento;
ListaConceptosMiembro = new List <ConceptoDto>();
DiccionarioConceptosPorColumna = new Dictionary <int, ConceptoDto>();
NombreHoja = String.Empty;
ResumenImportacion = resumenImportacion;
DiccionarioUnidadesPorIdConcepto = new Dictionary <String, UnidadDto>();
DiccionarioDecimalesPorIdConcepto = new Dictionary <String, String>();
}
/// <summary>
/// Genera los hechos de la fila indicada.
/// </summary>
/// <param name="fila">Fila que se pretende evaluar.</param>
/// <param name="concepto">Concepto que se pretende evaluar.</param>
/// <param name="diccionarioContextos">Diccionario de contextos.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantilla">Plantilla de documento.</param>
/// <param name="resumenImportacion">Resume de importación.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
public void GeneraHechos(
IRow fila,
ConceptoDto concepto,
IDictionary <int, Dto.ContextoDto> diccionarioContextos,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantilla,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja)
{
UnidadDto unidad = ObtenUniadConcepto(concepto, instancia, plantilla);
var idUnidad = unidad == null ? null : unidad.Id;
foreach (var indexColumna in diccionarioContextos.Keys)
{
ICell celda = null;
try
{
celda = fila.GetCell(indexColumna);
String valorHecho = String.Empty;
if (celda != null && !celda.CellType.Equals(CellType.Blank))
{
valorHecho = ExcelUtil.ObtenerValorCelda(celda.CellType, celda);
}
if (String.IsNullOrEmpty(valorHecho))
{
continue;
}
var contexto = diccionarioContextos[indexColumna];
CreaHecho(
valorHecho,
concepto,
contexto,
idUnidad,
instancia,
plantilla,
resumenImportacion,
nombreHoja,
fila.RowNum,
celda.ColumnIndex);
}
catch (Exception ex)
{
LogUtil.Error(ex);
var columnaCelda = (celda == null ? 0 : celda.ColumnIndex);
resumenImportacion.InformeErrores.Add(new InformeErrorImportacion()
{
Mensaje = "Error al obtener el valor de la celda en la fila \"" + fila.RowNum +
"\" columna \"" + columnaCelda +
"\" de la hoja \"" + nombreHoja +
"\".(" + ex.Message + ")"
});
}
}
}
/// <summary>
/// Crea un nuevo hecho.
/// </summary>
/// <param name="valor">Valor del hecho.</param>
/// <param name="concepto">Concepto del hecho.</param>
/// <param name="contexto">Contexto del hecho.</param>
/// <param name="idUnidad">Identificador de la unidad.</param>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantilla">Plantilla del documento.</param>
/// <param name="resumenImportacion">Detalle de la importación.</param>
/// <param name="nombreHoja">Nombre de la hoja.</param>
/// <param name="numeroFila">Indice de la fila.</param>
/// <param name="numeroColumna">Indice de la columna.</param>
private void CreaHecho(
String valor,
ConceptoDto concepto,
Dto.ContextoDto contexto,
String idUnidad,
DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantilla,
ResumenProcesoImportacionExcelDto resumenImportacion,
String nombreHoja,
int numeroFila,
int numeroColumna)
{
var idHecho = "A" + Guid.NewGuid().ToString();
var hechoNuevo = instancia.CrearHecho(concepto.Id, idUnidad, contexto.Id, idHecho);
if (concepto.EsTipoDatoNumerico)
{
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
{
hechoNuevo.Decimales = "-3";
}
else
{
hechoNuevo.Decimales = "0";
}
}
if (!ActualizarValor(concepto, valor, hechoNuevo, plantilla))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, concepto.Id),
nombreHoja,
numeroFila.ToString(),
numeroColumna.ToString(),
valor);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoNuevo.IdConcepto,
IdHecho = hechoNuevo.Id,
ValorImportado = valor,
HojaExcel = nombreHoja,
Renglon = numeroFila,
Columna = numeroColumna
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, hechoNuevo.Id));
}
plantilla.InyectaHechoADocumentoInstancia(hechoNuevo);
}
/// <summary>
/// Obtiene la fecha indicada.
/// </summary>
/// <param name="idVariableFecha">Identificador de la variable con la fecha requerida.</param>
/// <param name="definicionPlantilla">Plantilla con la definición de las variables.</param>
/// <returns>Fecha obtenida.</returns>
private DateTime ParseVariableFecha(string idVariableFecha, IDefinicionPlantillaXbrl definicionPlantilla)
{
var cadenaFecha = definicionPlantilla.ObtenerVariablePorId(idVariableFecha);
if (cadenaFecha == null)
{
throw new NullReferenceException("No existe un valor para el dientrificador de varialbe \"" + idVariableFecha + "\"");
}
var fecha = new DateTime();
DateUtil.ParseDate(cadenaFecha, DateUtil.YMDateFormat, out fecha);
return(fecha);
}
/// <summary>
/// Genera un contexto con la información definida en la plantilla.
/// </summary>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="definicionPlantilla">Plantilla donde se obtendran las variables para la generación del contexto.</param>
/// <param name="listaDimensiones">Lista de dimensiones que se aplican al contexto.</param>
/// <returns></returns>
public ContextoDto GeneraContexto(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl definicionPlantilla, IList <DimensionInfoDto> listaDimensiones = null)
{
var periodo = this.Periodo.GeneraPeriodo(definicionPlantilla);
var entidadAuxiliar = instancia.EntidadesPorId.Values.First();
var entidad = new EntidadDto()
{
ContieneInformacionDimensional = false,
EsquemaId = entidadAuxiliar.EsquemaId,
Id = entidadAuxiliar.Id,
};
var diccionarioMiembrosdimensio = new Dictionary <String, DimensionInfoDto>();
if (listaDimensiones != null)
{
foreach (var itemDimension in listaDimensiones)
{
if (!diccionarioMiembrosdimensio.ContainsKey(itemDimension.IdDimension))
{
diccionarioMiembrosdimensio.Add(itemDimension.IdDimension, itemDimension);
}
}
}
if (ValoresDimension != null)
{
foreach (var valorDimension in ValoresDimension)
{
if (!diccionarioMiembrosdimensio.ContainsKey(valorDimension.IdDimension))
{
diccionarioMiembrosdimensio.Add(valorDimension.IdDimension, valorDimension);
}
}
}
var dimensiones = new List <DimensionInfoDto>();
foreach (var miembro in diccionarioMiembrosdimensio.Values)
{
dimensiones.Add(miembro);
}
var contexto = new ContextoDto()
{
Id = "C" + Guid.NewGuid().ToString(),
Periodo = periodo,
Entidad = entidad,
ContieneInformacionDimensional = this.ContieneInformacionDimensional,
ValoresDimension = dimensiones
};
return(contexto);
}
/// <summary>
/// Genera un periodo en base a la definición de la palntilla de hipercubo.
/// </summary>
/// <param name="definicionPlantilla">Definición de la plantilla.</param>
/// <returns>Periodo generado.</returns>
public PeriodoDto GeneraPeriodo(IDefinicionPlantillaXbrl definicionPlantilla)
{
if (!VariablesEvaluadas)
{
EvaluaVariablesPlantilla(definicionPlantilla);
}
var periodo = new PeriodoDto()
{
Tipo = this.Tipo,
FechaInstante = FechaInstante == null ? DateTime.MinValue : ((DateTime)FechaInstante).ToUniversalTime(),
FechaInicio = FechaInicio == null ? DateTime.MinValue : ((DateTime)FechaInicio).ToUniversalTime(),
FechaFin = FechaFin == null ? DateTime.MinValue : ((DateTime)FechaFin).ToUniversalTime()
};
return(periodo);
}
/// <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>
/// Inicializa el mapeo a utiliza en la importación
/// </summary>
/// <param name="instancia"></param>
/// <param name="plantillaDocumento"></param>
/// <param name="rol"></param>
private void Inicializar(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, string uriRol)
{
_mapeoMiembrosDimension = new Dictionary <string, string>();
foreach (var idMiembro in MIEMBROS_DIMENSION_FIGURA)
{
if (instancia.Taxonomia.ConceptosPorId.ContainsKey(idMiembro))
{
var concepto = instancia.Taxonomia.ConceptosPorId[idMiembro];
foreach (var idioma in concepto.Etiquetas.Values)
{
foreach (var idiomaRol in idioma.Values)
{
_mapeoMiembrosDimension.Add(idiomaRol.Valor.Trim(), idMiembro);
}
}
}
}
}
/// <summary>
/// Utilería para el filtrado y consumo de inofmración de un documento de instancia.
/// </summary>
/// <param name="documentoInstancia">Documento de instancia con la informacón a consumir.</param>
/// <param name="definicionPlantilla">Definición de la plantillla con variables requeridas para el filtrado.</param>
public ConsultaDocumentoInstanciaUtil(DocumentoInstanciaXbrlDto documentoInstancia, IDefinicionPlantillaXbrl definicionPlantilla)
{
this.documentoInstancia = documentoInstancia;
this.definicionPlantilla = definicionPlantilla;
}
public void ExportarRolADocumentoWord(Document word, Section seccionActual, DocumentoInstanciaXbrlDto instancia, string rol, IDefinicionPlantillaXbrl plantillaDocumento, string claveIdioma)
{
//Buscar el la tabla []
Table tabla800005 = null;
NodeCollection allTables = seccionActual.GetChildNodes(NodeType.Table, true);
foreach (Table table in allTables)
{
if (table.Range.Text.Contains("Ingresos nacionales [miembro]") || table.Range.Text.Contains("National income [member]"))
{
tabla800005 = table;
break;
}
}
if (tabla800005 != null)
{
DateTime fechaInicio = DateTime.MinValue;
DateTime fechaFin = DateTime.MinValue;
//Trimestre actual
if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_09_30"), out fechaFin)
&&
XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01"), out fechaInicio))
{
var todasLasMarcas = new DimensionInfoDto()
{
Explicita = false,
IdDimension = _idDimensionMarcas,
ElementoMiembroTipificado = String.Format(_templateTypedMemeberMarcas, _todasLasMarcas)
};
var todosLosProductos = new DimensionInfoDto()
{
Explicita = false,
IdDimension = _idDimensionProductos,
ElementoMiembroTipificado = String.Format(_templateTypedMemeberProducto, _todosLosProductos)
};
var combinacionesMarcaProducto = ObtenerCombinacionesDimensionesMarcaProducto(instancia, fechaInicio, fechaFin);
var iRenglon = _renglonWordInicioHechos;
var renglonInicioHechos = tabla800005.Rows[_renglonWordInicioHechos];
foreach (var combinacion in combinacionesMarcaProducto)
{
var renglonNuevo = (Row)renglonInicioHechos.Clone(true);
tabla800005.InsertBefore(renglonNuevo, renglonInicioHechos);
renglonNuevo.Cells[0].FirstParagraph.AppendChild(new Run(word, ObtenerNombreMarcaOProducto(combinacion[0])));
renglonNuevo.Cells[0].FirstParagraph.Runs[0].Font.Name = "Arial";
renglonNuevo.Cells[0].FirstParagraph.Runs[0].Font.Size = 6;
renglonNuevo.Cells[1].FirstParagraph.AppendChild(new Run(word, ObtenerNombreMarcaOProducto(combinacion[1])));
renglonNuevo.Cells[1].FirstParagraph.Runs[0].Font.Name = "Arial";
renglonNuevo.Cells[1].FirstParagraph.Runs[0].Font.Size = 6;
var dimensionTipoIngreso = new DimensionInfoDto()
{
Explicita = true,
};
var listaDimensiones = new List <DimensionInfoDto>
{
combinacion[0],
combinacion[1],
dimensionTipoIngreso
};
for (var iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
{
dimensionTipoIngreso.IdDimension = _idDimensionTipoIngresos;
dimensionTipoIngreso.IdItemMiembro = _elementosMiembroTipoIngreso[iCol - _columnaInicioHechos];
var hecho = instancia.BuscarHechos(_idElementoPrimarioIngresos, null, null, fechaInicio,
fechaFin, listaDimensiones);
if (hecho != null && hecho.Count > 0)
{
string valor = "$ ";
double valorDouble = 0;
if (Double.TryParse(hecho[0].Valor, NumberStyles.Any, CultureInfo.InvariantCulture,
out valorDouble))
{
valor += valorDouble.ToString("#,##0.00");
}
else
{
valor = hecho[0].Valor;
}
renglonNuevo.Cells[iCol].FirstParagraph.AppendChild(new Run(word, valor));
renglonNuevo.Cells[iCol].FirstParagraph.Runs[0].Font.Name = "Arial";
renglonNuevo.Cells[iCol].FirstParagraph.Runs[0].Font.Size = 6;
}
}
iRenglon++;
}
var renglonTotal = tabla800005.LastRow;
for (var iCol = _columnaInicioHechos; iCol <= _columnaFinHechos; iCol++)
{
var tipoIngreso = new DimensionInfoDto()
{
Explicita = true,
IdDimension = _idDimensionTipoIngresos,
IdItemMiembro = _elementosMiembroTipoIngreso[iCol - _columnaInicioHechos]
};
var hecho = instancia.BuscarHechos(_idElementoPrimarioIngresos, null, null, fechaInicio,
fechaFin, new List <DimensionInfoDto>()
{
todasLasMarcas, todosLosProductos, tipoIngreso
});
if (hecho != null && hecho.Count > 0)
{
string valor = "$ ";
double valorDouble = 0;
if (Double.TryParse(hecho[0].Valor, NumberStyles.Any, CultureInfo.InvariantCulture,
out valorDouble))
{
valor += valorDouble.ToString("#,##0.00");
}
else
{
valor = hecho[0].Valor;
}
renglonTotal.Cells[iCol].FirstParagraph.AppendChild(new Run(word, valor));
renglonTotal.Cells[iCol].FirstParagraph.Runs[0].Font.Name = "Arial";
renglonTotal.Cells[iCol].FirstParagraph.Runs[0].Font.Size = 6;
}
}
}
}
}
private void ActualizarValorHecho(ConceptoDto concepto, string valorCelda, List <DimensionInfoDto> dimensiones,
DateTime fechaInicio, DateTime fechaFin, string qNameEntidad, DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento,
AbaxXBRLCore.Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, ISheet hojaImportar, int iRenglon, int columna)
{
if (String.IsNullOrEmpty(valorCelda))
{
return;
}
var fechaDefault = plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01");
List <HechoDto> hechosAActualizar = new List <HechoDto>();
var hechos = instancia.BuscarHechos(concepto.Id, null, null, fechaInicio, fechaFin, dimensiones);
if (hechos.Count > 0)
{
hechosAActualizar.AddRange(hechos);
}
else
{
var qNameCompleto = XmlUtil.ParsearQName(qNameEntidad);
ContextoDto contextoDestino = null;
var tipoPeriodo = concepto.TipoPeriodo.Equals(EtiquetasXBRLConstantes.Instant) ? Period.Instante : Period.Duracion;
var contextos = instancia.BuscarContexto(qNameEntidad,
tipoPeriodo, fechaInicio, fechaFin, dimensiones);
if (contextos == null || contextos.Count == 0)
{
contextoDestino = new ContextoDto()
{
Entidad = new EntidadDto()
{
ContieneInformacionDimensional = false,
EsquemaId = qNameCompleto.Namespace,
Id = qNameCompleto.Name
},
ContieneInformacionDimensional = dimensiones.Count > 0,
ValoresDimension = dimensiones,
Periodo = new PeriodoDto()
{
Tipo = tipoPeriodo,
FechaInicio = fechaInicio,
FechaFin = fechaFin,
FechaInstante = fechaFin
},
Id = "C" + Guid.NewGuid().ToString()
};
plantillaDocumento.InyectarContextoADocumentoInstancia(contextoDestino);
}
else
{
contextoDestino = contextos[0];
}
UnidadDto unidadDestino = null;
if (concepto.EsTipoDatoNumerico)
{
var listaMedidas = new List <MedidaDto>()
{
new MedidaDto()
{
EspacioNombres = plantillaDocumento.ObtenerVariablePorId("medida_http___www_xbrl_org_2003_iso4217"),
Nombre = plantillaDocumento.ObtenerVariablePorId("medida_MXN")
}
};
var unidades = instancia.BuscarUnidades(Unit.Medida, listaMedidas, null);
if (unidades == null || unidades.Count == 0)
{
unidadDestino = new UnidadDto()
{
Id = "U" + Guid.NewGuid().ToString(),
Tipo = Unit.Medida,
Medidas = listaMedidas
};
instancia.UnidadesPorId.Add(unidadDestino.Id, unidadDestino);
}
else
{
unidadDestino = unidades[0];
}
}
var hechoNuevo = instancia.CrearHecho(concepto.Id, unidadDestino != null ? unidadDestino.Id : null, contextoDestino.Id, "A" + Guid.NewGuid().ToString());
if (concepto.EsTipoDatoNumerico)
{
hechoNuevo.Valor = "0";
hechoNuevo.Decimales = _valorDecimalesHechos;
}
hechosAActualizar.Add(hechoNuevo);
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoNuevo);
}
foreach (var hechoActualizar in hechosAActualizar)
{
var conceptoImportar = instancia.Taxonomia.ConceptosPorId[hechoActualizar.IdConcepto];
if (!UtilAbax.ActualizarValorHecho(conceptoImportar, hechoActualizar, valorCelda, fechaDefault))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id),
hojaImportar.SheetName,
iRenglon.ToString(),
columna.ToString(),
valorCelda);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new AbaxXBRLCore.Common.Dtos.InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoActualizar.IdConcepto,
IdHecho = hechoActualizar.Id,
ValorImportado = valorCelda,
HojaExcel = hojaImportar.SheetName,
Renglon = iRenglon,
Columna = columna
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id));
}
}
}
public void ImportarDatosDeHojaExcel(ISheet hojaAImportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia,
string rol, ResumenProcesoImportacionExcelDto resumenImportacion, IDefinicionPlantillaXbrl plantillaDocumento)
{
var maxRow = hojaPlantilla.LastRowNum;
var fechaDefault = plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01");
var idiomaDefault = instancia.Taxonomia != null && instancia.Taxonomia.IdiomasTaxonomia != null && instancia.Taxonomia.IdiomasTaxonomia.Keys.Count > 0 ?
instancia.Taxonomia.IdiomasTaxonomia.Keys.First() : String.Empty;
for (var iRenglon = 0; iRenglon <= maxRow; iRenglon++)
{
var renglon = hojaPlantilla.GetRow(iRenglon);
if (renglon != null)
{
var maxCol = renglon.LastCellNum;
for (var iCol = 0; iCol <= maxCol; iCol++)
{
var valorHechoPlantilla = ExcelUtil.ObtenerValorCelda(renglon, iCol);
if (!String.IsNullOrEmpty(valorHechoPlantilla) && valorHechoPlantilla.StartsWith(PREFIJO_CELDA_HECHO_PLANTILLA) &&
valorHechoPlantilla.Length > PREFIJO_CELDA_HECHO_PLANTILLA.Length)
{
var idHechoPlantilla = valorHechoPlantilla.Substring(PREFIJO_CELDA_HECHO_PLANTILLA.Length);
var valorCeldaImportar = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
if (!String.IsNullOrEmpty(valorCeldaImportar))
{
//Buscar el hecho de plantilla en el documento de instancia
var hechoInstancia =
plantillaDocumento.BuscarHechoPlantillaEnHechosDocumentoInstancia(
idHechoPlantilla);
//Si el hecho no existe crearlo en base a la plantilla
if (hechoInstancia == null)
{
hechoInstancia =
plantillaDocumento.CrearHechoAPartirDeIdDefinicionPlantilla(
idHechoPlantilla);
if (hechoInstancia != null)
{
hechoInstancia.NotasAlPie = ExcelUtil.ObtenerComentariosCelda(renglon, iCol, idiomaDefault);
plantillaDocumento.InyectaHechoADocumentoInstancia(hechoInstancia);
}
}
if (hechoInstancia != null)
{
var conceptoImportar = instancia.Taxonomia.ConceptosPorId[hechoInstancia.IdConcepto];
if (!UtilAbax.ActualizarValorHecho(conceptoImportar, hechoInstancia, valorCeldaImportar, fechaDefault))
{
resumenImportacion.AgregarErrorFormato(
UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id),
hojaAImportar.SheetName,
iRenglon.ToString(),
iCol.ToString(),
valorCeldaImportar);
}
else
{
resumenImportacion.TotalHechosImportados++;
var hechoImportado = new InformacionHechoImportadoExcelDto()
{
IdConcepto = hechoInstancia.IdConcepto,
IdHecho = hechoInstancia.Id,
ValorImportado = valorCeldaImportar,
HojaExcel = hojaAImportar.SheetName,
Renglon = iRenglon,
Columna = iCol
};
resumenImportacion.AgregarHechoImportado(hechoImportado, UtilAbax.ObtenerEtiqueta(instancia.Taxonomia, conceptoImportar.Id));
}
}
}
}
}
}
}
}
public ReemplazarHechoDocumentoHandler(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantilla, DocumentBuilder docBuilder)
{
this._documentoInstancia = instancia;
this._plantilla = plantilla;
this._documentBuilder = docBuilder;
}
public virtual void ExportarRolADocumentoWord(Document word, Section seccionActual, DocumentoInstanciaXbrlDto instancia, string rol, IDefinicionPlantillaXbrl plantillaDocumento, string claveIdioma)
{
var docBuilder = new DocumentBuilder(word);
var handlerReemplazar = new ReemplazarHechoDocumentoHandler(instancia, plantillaDocumento, docBuilder);
var rangoDoc = seccionActual.Range;
foreach (var hechosPlantilla in plantillaDocumento.DefinicionesDeElementosPlantillaPorRol[rol].HechosPlantillaPorId)
{
var hechoInstancia =
plantillaDocumento.BuscarHechoPlantillaEnHechosDocumentoInstancia(hechosPlantilla.Key);
if (hechoInstancia != null)
{
//Usar el handler solo para text block
var concepto = instancia.Taxonomia.ConceptosPorId[hechoInstancia.IdConcepto];
if (concepto.TipoDato.Contains(TiposDatoXBRL.TextBlockItemType))
{
handlerReemplazar.IdHechoPlantilla = hechosPlantilla.Key;
handlerReemplazar.HechoInstancia = hechoInstancia;
rangoDoc.Replace(new Regex("(?:" + hechosPlantilla.Key + ")"), handlerReemplazar, false);
}
else if (concepto.EsTipoDatoNumerico)
{
var valor = "";
//Si es monetario, escribir el formato
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.MonetaryItemType))
{
valor = "$ ";
}
double valorDouble = 0;
if (Double.TryParse(hechoInstancia.Valor, NumberStyles.Any, CultureInfo.InvariantCulture,
out valorDouble))
{
valor += valorDouble.ToString("#,##0.00");
}
else
{
valor = hechoInstancia.Valor;
}
rangoDoc.Replace(hechosPlantilla.Key, valor, false, false);
}
else if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.BooleanItemType))
{
//Si el concepto es de tipo boolean, transformar el valor de salida a si y no
var valorFinal = hechoInstancia.Valor;
if (!String.IsNullOrEmpty(valorFinal))
{
if (CommonConstants.CADENAS_VERDADERAS.Contains(valorFinal.Trim().ToLower()))
{
valorFinal = CommonConstants.SI;
}
else
{
valorFinal = CommonConstants.NO;
}
}
else
{
valorFinal = CommonConstants.NO;
}
rangoDoc.Replace(hechosPlantilla.Key, valorFinal, false, false);
}
else
{
//rangoDoc.Replace(hechosPlantilla.Key, hechoInstancia.Valor, false, false);
handlerReemplazar.IdHechoPlantilla = hechosPlantilla.Key;
handlerReemplazar.HechoInstancia = hechoInstancia;
rangoDoc.Replace(new Regex("(?:" + hechosPlantilla.Key + ")"), handlerReemplazar, false);
}
}
else
{
rangoDoc.Replace(hechosPlantilla.Key, "", false, false);
}
}
}
public void ExportarDatosDeHojaExcel(ISheet hojaAExportar, ISheet hojaPlantilla, DocumentoInstanciaXbrlDto instancia, string rol, IDefinicionPlantillaXbrl plantillaDocumento, String idioma)
{
var numRenglones = hojaPlantilla.LastRowNum;
for (var iRenglon = 0; iRenglon <= numRenglones; iRenglon++)
{
var renglon = hojaPlantilla.GetRow(iRenglon);
if (renglon != null)
{
var numCols = renglon.LastCellNum;
for (var iCol = 0; iCol <= numCols; iCol++)
{
var valorHechoPlantilla = ExcelUtil.ObtenerValorCelda(hojaPlantilla, iRenglon, iCol);
if (!String.IsNullOrEmpty(valorHechoPlantilla) &&
valorHechoPlantilla.StartsWith(PREFIJO_CELDA_HECHO_PLANTILLA) &&
valorHechoPlantilla.Length > PREFIJO_CELDA_HECHO_PLANTILLA.Length)
{
//Celda con valor de hecho plantilla
var idHechoPlantilla = valorHechoPlantilla.Substring(PREFIJO_CELDA_HECHO_PLANTILLA.Length);
var hechoInstancia = plantillaDocumento.BuscarHechoPlantillaEnHechosDocumentoInstancia(idHechoPlantilla);
if (hechoInstancia != null)
{
var concepto = instancia.Taxonomia.ConceptosPorId[hechoInstancia.IdConcepto];
//Si existe hecho, asignar valor
//Si la celda es de tipo boolean, transformar el valor de salida a si y no
var valorFinal = hechoInstancia.Valor;
if (concepto.TipoDatoXbrl.Contains(TiposDatoXBRL.BooleanItemType))
{
if (!String.IsNullOrEmpty(valorFinal))
{
if (CommonConstants.CADENAS_VERDADERAS.Contains(valorFinal.Trim().ToLower()))
{
valorFinal = CommonConstants.SI;
}
else
{
valorFinal = CommonConstants.NO;
}
}
else
{
valorFinal = CommonConstants.NO;
}
}
ExcelUtil.AsignarValorCelda(hojaAExportar, iRenglon, iCol, valorFinal,
concepto.EsTipoDatoNumerico ? CellType.Numeric : CellType.String, hechoInstancia);
}
}
}
}
}
}
/// <summary>
/// Genera una plantilla con el formato para las firmas.
/// </summary>
/// <param name="instancia">Documento de instancia.</param>
/// <param name="plantilla">Plantilla de la taxonomía.</param>
/// <param name="idioma">Idioma utilizado.</param>
/// <returns>Flujo con el PDF para las fimras.</returns>
public Stream GeneraDocumentoFirmasArticulo13(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantilla, String idioma = "es")
{
var documento = new Aspose.Words.Document();
var builder = new DocumentBuilder(documento);
var estructuraReporte = new ReporteXBRLDTO()
{
Instancia = instancia,
Plantilla = plantilla,
Lenguaje = idioma
};
PintaCamposTablaFirmaArticulo13(builder, estructuraReporte);
var streamSalida = new MemoryStream();
var savePdf = new Aspose.Words.Saving.PdfSaveOptions()
{
UseHighQualityRendering = true
};
documento.Save(streamSalida, SaveFormat.Docx);
return(streamSalida);
}
public override void ExportarRolADocumentoWord(Document word, Section seccionActual, DocumentoInstanciaXbrlDto instancia, string rol, IDefinicionPlantillaXbrl plantillaDocumento, string claveIdioma)
{
//Escribir los titulos de las notas y después el contenido de la nota
var docBuilder = new DocumentBuilder(word);
docBuilder.MoveTo(seccionActual.Body.LastParagraph);
var rolPresentacion = instancia.Taxonomia.RolesPresentacion.FirstOrDefault(x => x.Uri.Equals(RolPresentacion));
DateTime fechaInicio = DateTime.MinValue;
DateTime fechaFin = DateTime.MinValue;
//Trimestre actual
if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_09_30"), out fechaFin)
&&
XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_01_01"),
out fechaInicio))
{
if (rolPresentacion != null)
{
foreach (var estructura in rolPresentacion.Estructuras)
{
ExportarEstructuraRol(estructura, docBuilder, instancia, rol, plantillaDocumento, fechaInicio, fechaFin, claveIdioma);
}
}
}
}
