/// <summary>
/// Asigna el valor de una celda en una hoja en base a un renglón y columna
/// </summary>
/// <param name="hoja">Hoja donde se asignará el valor de la celda</param>
/// <param name="renglon">Número de renglón</param>
/// <param name="columna">Número de columna</param>
/// <param name="valor">Valor a asignar</param>
/// <param name="tipoCelda">Tipo de celda a crear</param>
/// <param name="hecho">Hecho asignado a esta celda</param>
public static void AsignarValorCelda(ISheet hoja, int renglon, int columna, string valor, CellType tipoCelda, HechoDto hecho, Boolean asignarComentarios = true)
{
if (hoja.LastRowNum < renglon)
{
hoja.CreateRow(renglon);
}
var celda = hoja.GetRow(renglon).GetCell(columna, MissingCellPolicy.CREATE_NULL_AS_BLANK);
celda.SetCellType(tipoCelda);
if (CellType.Numeric == tipoCelda)
{
double valorDouble = 0;
if (Double.TryParse(valor, NumberStyles.Any, CultureInfo.InvariantCulture, out valorDouble))
{
celda.SetCellValue(valorDouble);
}
else
{
celda.SetCellValue(valor);
}
}
else
{
celda.SetCellValue(valor);
}
if (asignarComentarios)
{
AgregarComentarioCelda(hoja, celda, hecho);
}
}
/// <summary>
/// Pinta los campos de persona responsable.
/// </summary>
/// <param name="docBuilder">Constructor del documento.</param>
/// <param name="estructuraReporte">Estructura del reporte</param>
public void PintaCamposTablaFirmaArticulo13(DocumentBuilder docBuilder, ReporteXBRLDTO estructuraReporte)
{
var diccionarioFiguraResponsable = GeneraDiccionarioPersonasResponsables(estructuraReporte);
var indexFiguraResponsable = 0;
var leyendaArticulo13 = "";
IList <String> listaIdHechoFirmaLeyenda13 = null;
if (estructuraReporte.Instancia.HechosPorIdConcepto.TryGetValue("ar_pros_IssuanceUnderArt13OfTheCUELegend", out listaIdHechoFirmaLeyenda13))
{
var idHechoFirmas = listaIdHechoFirmaLeyenda13.First();
HechoDto hechoFirmas = null;
if (estructuraReporte.Instancia.HechosPorId.TryGetValue(idHechoFirmas, out hechoFirmas))
{
leyendaArticulo13 = hechoFirmas.Valor;
}
}
foreach (var idItemMiembroFiguraResponsable in diccionarioFiguraResponsable.Keys)
{
if (indexFiguraResponsable > 0)
{
docBuilder.InsertBreak(BreakType.PageBreak);
}
indexFiguraResponsable++;
var listaInstituciones = diccionarioFiguraResponsable[idItemMiembroFiguraResponsable];
var contieneLeyendaArt13 = false;
foreach (var institucionArt13 in listaInstituciones)
{
if (institucionArt13.ContieneFirmasLeyendaArt13)
{
contieneLeyendaArt13 = true;
break;
}
}
if (!contieneLeyendaArt13)
{
continue;
}
//ImprimirTituloFiguraResponsable(idItemMiembroFiguraResponsable, docBuilder, estructuraReporte);
for (var indexInstitucion = 0; indexInstitucion < listaInstituciones.Count; indexInstitucion++)
{
var institucionPersonaResponsable = listaInstituciones[indexInstitucion];
if (!institucionPersonaResponsable.ContieneFirmasLeyendaArt13)
{
continue;
}
if (indexInstitucion > 0)
{
docBuilder.InsertBreak(BreakType.PageBreak);
}
ImprimirLeyenda(leyendaArticulo13, docBuilder);
ImprimirTituloInstitucion(institucionPersonaResponsable.Institucion, docBuilder);
var listaMiembrosOriginal = institucionPersonaResponsable.Miembros;
var listaMiembros = new List <PersonaResponsableMiembro431000DTO>();
foreach (var mienbroOriginal in listaMiembrosOriginal)
{
if (mienbroOriginal.FirmaArticulo13)
{
listaMiembros.Add(mienbroOriginal);
}
}
for (var indexMiembro = 0; indexMiembro < listaMiembros.Count; indexMiembro += 2)
{
var listaMiembrosTabla = new List <PersonaResponsableMiembro431000DTO>();
listaMiembrosTabla.Add(listaMiembros[indexMiembro]);
var siguienteIndice = (indexMiembro + 1);
if (siguienteIndice < listaMiembros.Count)
{
listaMiembrosTabla.Add(listaMiembros[siguienteIndice]);
}
ImprimirMiembrosPersonasResponsables(listaMiembrosTabla, docBuilder);
}
}
}
}
/// <summary>
/// Crea un Hecho a partir de su representación en el modelo de instancia
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="hechoDto"></param>
/// <param name="listaTiposDato"></param>
/// <returns></returns>
public static Hecho CrearHechoDb(DocumentoInstancia instanciaDb, HechoDto hechoDto, List <TipoDato> listaTiposDato, DocumentoInstanciaXbrlDto documentoInstancia)
{
var hechoDb = new Hecho
{
IdConcepto = hechoDto.IdConcepto,
Concepto = hechoDto.NombreConcepto,
EspacioNombres = hechoDto.EspacioNombres,
IdRef = hechoDto.Id,
EsTupla = hechoDto.EsTupla,
IdInterno = hechoDto.Consecutivo
};
//Si el hecho DTO no tiene espacio de nombres y concepto, entonces intentar buscarlo de la taxonomía:
var tipoDatoXbrl = hechoDto.TipoDatoXbrl;
var tipoDato = hechoDto.TipoDato;
if ((String.IsNullOrEmpty(hechoDto.NombreConcepto) || String.IsNullOrEmpty(hechoDto.EspacioNombres)) && documentoInstancia.Taxonomia != null)
{
if (documentoInstancia.Taxonomia.ConceptosPorId.ContainsKey(hechoDto.IdConcepto))
{
hechoDb.Concepto = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].Nombre;
hechoDb.EspacioNombres = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].EspacioNombres;
if (String.IsNullOrEmpty(tipoDatoXbrl) || String.IsNullOrEmpty(tipoDato))
{
tipoDatoXbrl = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDatoXbrl;
tipoDato = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDato;
}
}
else
{
return(null);
}
}
if ((String.IsNullOrWhiteSpace(tipoDatoXbrl) || String.IsNullOrWhiteSpace(tipoDato)) && documentoInstancia.Taxonomia != null)
{
if (documentoInstancia.Taxonomia.ConceptosPorId.ContainsKey(hechoDto.IdConcepto))
{
tipoDatoXbrl = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDatoXbrl;
tipoDato = documentoInstancia.Taxonomia.ConceptosPorId[hechoDto.IdConcepto].TipoDato;
}
}
if (hechoDto.TuplaPadre != null)
{
hechoDb.IdInternoTuplaPadre = hechoDto.TuplaPadre.Consecutivo;
}
if (!hechoDto.EsTupla)
{
hechoDb.Valor = hechoDto.Valor;
if (hechoDto.EsFraccion)
{
//TODO: agregar 2 campos mas a la tabla
}
//Buscar el contexto
var ctxDb = instanciaDb.Contexto.FirstOrDefault(x => x.Nombre.Equals(hechoDto.IdContexto));
if (ctxDb != null)
{
hechoDb.IdContexto = ctxDb.IdContexto;
}
//Buscar unidad
var unidadDb = instanciaDb.Unidad.FirstOrDefault(x => x.IdRef.Equals(hechoDto.IdUnidad));
if (unidadDb != null)
{
hechoDb.IdUnidad = unidadDb.IdUnidad;
}
if (!hechoDto.DecimalesEstablecidos && !hechoDto.PrecisionEstablecida)
{
hechoDto.Decimales = ConstantesGenerales.VALOR_DECIMALES_DEFAULT;
}
if (hechoDto.DecimalesEstablecidos)
{
hechoDb.Precision = null;
hechoDb.Decimales = hechoDto.Decimales;
}
if (hechoDto.PrecisionEstablecida)
{
hechoDb.Decimales = null;
hechoDb.Precision = hechoDto.Precision;
}
//Buscar el tipo de dato
var tipoDatoCatalogo = listaTiposDato.FirstOrDefault(x => x.Nombre.Equals(tipoDato));
if (tipoDatoCatalogo != null)
{
hechoDb.IdTipoDato = tipoDatoCatalogo.IdTipoDato;
}
else
{
tipoDatoCatalogo = listaTiposDato.FirstOrDefault(x => x.Nombre.Equals(tipoDatoXbrl));
if (tipoDatoCatalogo != null)
{
hechoDb.IdTipoDato = tipoDatoCatalogo.IdTipoDato;
}
}
}
hechoDb.IdDocumentoInstancia = instanciaDb.IdDocumentoInstancia;
return(hechoDb);
}
/// <summary>
/// Convierte los registros de los Hechos de un documento de instancia en base de datos
/// a su representación en DTO
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="instanciaXbrlDto"></param>
private static void CargarHechos(DocumentoInstancia instanciaDb, DocumentoInstanciaXbrlDto instanciaXbrlDto)
{
var listaGeneralHechos = new List <HechoDto>();
foreach (var hechoDb in instanciaDb.Hecho)
{
var hechoDto = new HechoDto
{
Id = hechoDb.IdRef,
IdConcepto = hechoDb.IdConcepto,
Valor = hechoDb.Valor,
NombreConcepto = hechoDb.Concepto,
EspacioNombres = hechoDb.EspacioNombres,
EsTupla = hechoDb.EsTupla,
Consecutivo = hechoDb.IdInterno != null ? hechoDb.IdInterno.Value : 0,
ConsecutivoPadre = hechoDb.IdInternoTuplaPadre != null ? hechoDb.IdInternoTuplaPadre.Value : 0,
CambioValorComparador = false,
};
//Precision y decimales
if (!String.IsNullOrEmpty(hechoDb.Decimales))
{
hechoDto.Decimales = hechoDb.Decimales;
}
if (!String.IsNullOrEmpty(hechoDb.Precision))
{
hechoDto.Precision = hechoDb.Precision;
}
if (hechoDb.TipoDato != null)
{
hechoDto.TipoDato = hechoDb.TipoDato.Nombre;
hechoDto.EsNumerico = hechoDb.TipoDato.EsNumerico;
hechoDto.NoEsNumerico = !hechoDto.EsNumerico;
hechoDto.EsFraccion = hechoDb.TipoDato.EsFraccion;
}
//Unidad
hechoDto.IdUnidad = hechoDb.Unidad != null ? hechoDb.Unidad.IdRef : null;
//Contexto
hechoDto.IdContexto = hechoDb.Contexto != null ? hechoDb.Contexto.Nombre : null;
if (!instanciaXbrlDto.HechosPorIdConcepto.ContainsKey(hechoDto.IdConcepto))
{
instanciaXbrlDto.HechosPorIdConcepto.Add(hechoDto.IdConcepto, new List <string>());
}
if (!instanciaXbrlDto.HechosPorId.ContainsKey(hechoDto.IdConcepto))
{
instanciaXbrlDto.HechosPorId.Add(hechoDto.Id, hechoDto);
}
instanciaXbrlDto.HechosPorIdConcepto[hechoDto.IdConcepto].Add(hechoDto.Id);
listaGeneralHechos.Add(hechoDto);
}
//Asociar estructura de tuplas
var tuplas = listaGeneralHechos.Where(x => x.EsTupla).ToList();
var diccTuplas = new Dictionary <long, HechoDto>();
foreach (var tupla in tuplas)
{
tupla.Hechos = new List <String>();
diccTuplas.Add(tupla.Consecutivo, tupla);
}
var hechosHijo = listaGeneralHechos.Where(x => x.ConsecutivoPadre > 0).ToList();
//Asociar estructura de tuplas
foreach (var hijo in hechosHijo)
{
if (diccTuplas.ContainsKey(hijo.ConsecutivoPadre))
{
var tupla = diccTuplas[hijo.ConsecutivoPadre];
tupla.Hechos.Add(hijo.Id);
hijo.TuplaPadre = tupla;
}
}
}
/// <summary>
/// Parse a XBRL fact to JBRL fact.
/// </summary>
/// <param name="factXBRL">Fact to be parse.</param>
/// <param name="document">Document owner of the fact.</param>
/// <returns>JBRL fact.</returns>
public static FactJBRL Parse(
HechoDto factXBRL,
DocumentoInstanciaXbrlDto document,
String reportId,
String reportRecordId,
DateTime registrationDate,
IDictionary <String, String> extraParams,
String replacementId = null)
{
var factJbrl = new FactJBRL();
factJbrl.value = factXBRL.Valor;
factJbrl.conceptId = factXBRL.IdConcepto;
factJbrl.reportId = reportId;
factJbrl.reportRecordId = reportRecordId;
factJbrl.registrationDate = registrationDate;
ConceptoDto concept;
if (document.Taxonomia.ConceptosPorId.TryGetValue(factXBRL.IdConcepto, out concept))
{
factJbrl.conceptLabel = GetConceptLabel(concept);
factJbrl.dataType = concept.TipoDato;
}
else
{
return(null);
}
ContextoDto context;
factJbrl.dimensionMap = new Dictionary <String, String>();
if (extraParams != null)
{
foreach (var paramId in extraParams.Keys)
{
factJbrl.dimensionMap[paramId] = extraParams[paramId];
}
}
if (document.ContextosPorId.TryGetValue(factXBRL.IdContexto, out context))
{
factJbrl.dimensionMap["entity"] = context.Entidad.Id;
if (context.Periodo.Tipo.Equals(PeriodoDto.Instante))
{
factJbrl.dimensionMap["periodInstantDate"] = factJbrl.ParseString(context.Periodo.FechaInstante);
factJbrl.dimensionMap["periodMainDate"] = factJbrl.dimensionMap["periodInstantDate"];
}
else if (context.Periodo.Tipo.Equals(PeriodoDto.Duracion))
{
factJbrl.dimensionMap["periodStartDate"] = factJbrl.ParseString(context.Periodo.FechaInicio);
factJbrl.dimensionMap["periodEndDate"] = factJbrl.ParseString(context.Periodo.FechaFin);
factJbrl.dimensionMap["periodMainDate"] = factJbrl.dimensionMap["periodEndDate"];
}
factJbrl.dimensionMap["isDimensional"] = context.ContieneInformacionDimensional.ToString().ToLower();
var listOfdimensionsXbrl = context.ValoresDimension == null || context.ValoresDimension.Count == 0 ? context.Entidad.ValoresDimension : context.ValoresDimension;
if (listOfdimensionsXbrl != null)
{
foreach (var dimensionXbrl in listOfdimensionsXbrl)
{
var dimensionId = "xbrlDim_" + dimensionXbrl.IdDimension;
var member = GetDimensionMember(dimensionXbrl, document);
factJbrl.dimensionMap[dimensionId] = member;
}
}
}
else
{
return(null);
}
UnidadDto unit;
if (!String.IsNullOrEmpty(factXBRL.IdUnidad) && document.UnidadesPorId.TryGetValue(factXBRL.IdUnidad, out unit))
{
factJbrl.dimensionMap["unit"] = GetUnitValue(unit);
}
if (!String.IsNullOrEmpty(factXBRL.Decimales))
{
factJbrl.dimensionMap["decimals"] = factXBRL.Decimales;
}
if (!String.IsNullOrEmpty(factXBRL.Precision))
{
factJbrl.dimensionMap["precision"] = factXBRL.Precision;
}
var isChunk = false;
var value = factJbrl.value;
if (!String.IsNullOrWhiteSpace(value) && value.Length > ConstBlockStoreHechos.MAX_STRING_VALUE_LENGTH)
{
isChunk = true;
}
factJbrl.isChunk = isChunk;
factJbrl.contextId = factJbrl.GetContextHash();
factJbrl.factId = factJbrl.GeneraHashId();
if (!string.IsNullOrEmpty(replacementId))
{
factJbrl.replacementId = replacementId;
factJbrl.isReplaced = true;
}
return(factJbrl);
}
/// <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));
}
}
/// <summary>
/// Importa los datos de un grupo de hechos que corresponden a un tipo de pasivo en específico
/// </summary>
private void ImportarGrupoTipoPasivo(ISheet hojaAImportar, int renglonTipoPasivo, string tipoPasivoActual, DocumentoInstanciaXbrlDto instancia,
IDefinicionPlantillaXbrl plantillaDocumento, Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, IDictionary <string, string> secuenciasAsignadas,
IList <string> etiquetasConceptosMiembro)
{
var hechosDeTipoPasivo = ObtenerHechosPorDimensionYMiembro(instancia, plantillaDocumento, _idDimensionTipoPasivo, tipoPasivoActual);
int iCol = _columnaInicioDatos;
int iRenglon = renglonTipoPasivo;
string[] listaPrimarios = null;
if (_miembrosBancarios.Contains(tipoPasivoActual))
{
listaPrimarios = _elementosPrimariosBancarios;
}
if (_miembrosBursatiles.Contains(tipoPasivoActual))
{
listaPrimarios = _elementosPrimariosBursatiles;
}
if (_miembrosOtros.Contains(tipoPasivoActual))
{
listaPrimarios = _elementosPrimariosOtros;
}
if (_idItemMiembroGranTotal.Equals(tipoPasivoActual))
{
listaPrimarios = _elementosPrimariosGranTotal;
}
if (_miembrosTipoPasivoTotales.Contains(tipoPasivoActual))
{
int iMiembroSubtabla = 0;
var dimensiones = new List <DimensionInfoDto>()
{
new DimensionInfoDto()
{
Explicita = true,
IdDimension = _idDimensionTipoPasivo,
IdItemMiembro = tipoPasivoActual
}
};
var contextoTotales = BuscarOCrearContexto(instancia, plantillaDocumento, dimensiones, _idDimensionSecuencia, null, secuenciasAsignadas);
foreach (var elementoPrimario in listaPrimarios)
{
if (_elementosPrimariosTotal.Contains(elementoPrimario))
{
var valorImportar = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
if (!String.IsNullOrEmpty(valorImportar))
{
HechoDto hechoActualizar = null;
if (elementoPrimario.Equals(_idConceptoSubtabla))
{
var dimensionesSubtabla = new List <DimensionInfoDto>();
dimensionesSubtabla.AddRange(dimensiones);
dimensionesSubtabla.Add(new DimensionInfoDto()
{
Explicita = true,
IdDimension = _idDimensionIntervalo,
IdItemMiembro = _miembrosIntervaloDeTiempo[iMiembroSubtabla]
});
var contextoSubtabla = BuscarOCrearContexto(instancia, plantillaDocumento, dimensionesSubtabla, _idDimensionSecuencia, null, secuenciasAsignadas);
var listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, hechosDeTipoPasivo, elementoPrimario, null);
listaHechos = FiltrarHechosPorDimensionYMiembro(instancia, listaHechos, _idDimensionIntervalo, _miembrosIntervaloDeTiempo[iMiembroSubtabla++]);
if (listaHechos.Count > 0)
{
hechoActualizar = listaHechos[0];
}
else
{
hechoActualizar = CrearHecho(instancia, plantillaDocumento, elementoPrimario, contextoSubtabla);
}
}
else
{
var listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, hechosDeTipoPasivo, elementoPrimario, null);
if (listaHechos.Count > 0)
{
hechoActualizar = listaHechos[0];
}
else
{
hechoActualizar = CrearHecho(instancia, plantillaDocumento, elementoPrimario, contextoTotales);
}
}
if (hechoActualizar != null)
{
ActualizarValorHecho(resumenImportacion, hechoActualizar, valorImportar, plantillaDocumento, instancia, hojaAImportar, iRenglon, iCol);
}
}
}
iCol++;
}
}
else
{
//Inicio de un grupo de detalle de pasivos
iRenglon++;
var dimensiones = new List <DimensionInfoDto>()
{
new DimensionInfoDto()
{
Explicita = true,
IdDimension = _idDimensionTipoPasivo,
IdItemMiembro = tipoPasivoActual
}
};
bool finGrupo = false;
while (!finGrupo)
{
int iMiembroSubtabla = 0;
//Determinar la secuencia
string secuencia = null;
var nombrePasivo = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, _columnaInicioDatos);
if (!String.IsNullOrEmpty(nombrePasivo))
{
secuencia = BuscarSecuenciaDePasivo(instancia, hechosDeTipoPasivo, nombrePasivo);
if (secuencia == null)
{
secuencia = ObtenerSiguienteSecuencia(secuenciasAsignadas);
}
var contextoDestino = BuscarOCrearContexto(instancia, plantillaDocumento, dimensiones, _idDimensionSecuencia, secuencia, secuenciasAsignadas);
iCol = _columnaInicioDatos;
foreach (var elementoPrimario in listaPrimarios)
{
var valorImportar = ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, iCol);
if (!String.IsNullOrEmpty(valorImportar))
{
HechoDto hechoActualizar = null;
if (elementoPrimario.Equals(_idConceptoSubtabla))
{
var dimensionesSubtabla = new List <DimensionInfoDto>();
dimensionesSubtabla.AddRange(dimensiones);
dimensionesSubtabla.Add(new DimensionInfoDto()
{
Explicita = true,
IdDimension = _idDimensionIntervalo,
IdItemMiembro = _miembrosIntervaloDeTiempo[iMiembroSubtabla]
});
var contextoSubtabla = BuscarOCrearContexto(instancia, plantillaDocumento, dimensionesSubtabla, _idDimensionSecuencia, secuencia, secuenciasAsignadas);
var listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, hechosDeTipoPasivo, elementoPrimario, secuencia);
listaHechos = FiltrarHechosPorDimensionYMiembro(instancia, listaHechos, _idDimensionIntervalo, _miembrosIntervaloDeTiempo[iMiembroSubtabla++]);
if (listaHechos.Count > 0)
{
hechoActualizar = listaHechos[0];
}
else
{
hechoActualizar = CrearHecho(instancia, plantillaDocumento, elementoPrimario, contextoSubtabla);
}
}
else
{
var listaHechos = ObtenerHechosPorElementoPrimarioYSecuencia(instancia, hechosDeTipoPasivo, elementoPrimario, secuencia);
if (listaHechos.Count > 0)
{
hechoActualizar = listaHechos[0];
}
else
{
hechoActualizar = CrearHecho(instancia, plantillaDocumento, elementoPrimario, contextoDestino);
}
}
if (hechoActualizar != null)
{
ActualizarValorHecho(resumenImportacion, hechoActualizar, valorImportar, plantillaDocumento, instancia, hojaAImportar, iRenglon, iCol);
}
}
iCol++;
}
}
iRenglon++;
finGrupo = iRenglon > hojaAImportar.LastRowNum ||
etiquetasConceptosMiembro.Contains(ExcelUtil.ObtenerValorCelda(hojaAImportar, iRenglon, _columnaTituloTipoPasivo));
}
}
}
/// <summary>
/// Genera un listado de los conceptos con la relacion de sus dimensiones
/// </summary>
/// <param name="taxonomia">Objeto de taxonomía utilizado para obtener etiquetas de presentación</param>
/// <param name="documentoInstanciaXbrlDto"></param>
/// <param name="concepto">concepto a procesar</param>
/// <param name="uriRolPresentacion"></param>
/// <param name="idioma">Idioma de presentación</param>
/// <param name="columnas">lista de columnas que tiene el reporte</param>
/// <param name="nombreconcepto">nombre del concepto que se mostrar en el reporte</param>
/// <param name="indentacion">Nivel del concepto</param>
/// <returns></returns>
private IList <EstructuraConceptoReporte> BuscarConceptosConDimensiones(TaxonomiaDto taxonomia, DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto,
ConceptoDto concepto, string uriRolPresentacion, string idioma, List <EstructuraColumnaReporte> columnas, string nombreconcepto, int indentacion, bool agruparPorUnidad)
{
List <EstructuraConceptoReporte> listaDeEstructurasConceptos = new List <EstructuraConceptoReporte>();
if (!(concepto.EsAbstracto != null && concepto.EsAbstracto.Value))
{
var hechoIdsEncontrados = new List <string>();
if (documentoInstanciaXbrlDto.HechosPorIdConcepto.ContainsKey(concepto.Id))
{
hechoIdsEncontrados.AddRange(documentoInstanciaXbrlDto.HechosPorIdConcepto[concepto.Id]);
}
if (hechoIdsEncontrados.Count() == 0)
{
var combinacionDimensiones = new Dictionary <string, EstructuraDimensionReporte>();
listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = indentacion,
EsAbstracto = concepto.EsAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = combinacionDimensiones
});
return(listaDeEstructurasConceptos);
}
else
{
foreach (var hechoId in hechoIdsEncontrados)
{
HechoDto hecho = documentoInstanciaXbrlDto.HechosPorId[hechoId];
List <DimensionInfoDto> listaDimensionesTotales = new List <DimensionInfoDto>();
ContextoDto contexto = documentoInstanciaXbrlDto.ContextosPorId[hecho.IdContexto];
if (contexto.ValoresDimension != null)
{
listaDimensionesTotales.AddRange(contexto.ValoresDimension);
}
if (contexto.Entidad.ValoresDimension != null)
{
listaDimensionesTotales.AddRange(contexto.Entidad.ValoresDimension);
}
AgregarDimensionesDefault(listaDimensionesTotales, taxonomia, concepto.Id, uriRolPresentacion);
EstructuraConceptoReporte estructuraEncontrada = null;
var estructuraDimensionesBuscada = CrearEstructuraDimensiones(listaDimensionesTotales, taxonomia, idioma);
foreach (var estConceptoActual in listaDeEstructurasConceptos)
{
if (EsMismaCombinacionDeDimensiones(estConceptoActual.Dimensiones, estructuraDimensionesBuscada))
{
estructuraEncontrada = estConceptoActual;
break;
}
}
//Si no se encontró la combinación de dimensiones, crear nueva
if (estructuraEncontrada == null)
{
estructuraEncontrada = new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = indentacion,
EsAbstracto = concepto.EsAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = estructuraDimensionesBuscada
};
listaDeEstructurasConceptos.Add(estructuraEncontrada);
}
int posicion = BuscarIndexColumna(documentoInstanciaXbrlDto, columnas, hecho, agruparPorUnidad);
if (posicion != -1)
{
estructuraEncontrada.Hechos[posicion] = new EstructuraHechoReporte();
estructuraEncontrada.Hechos[posicion].HechoId = hecho.Id;
estructuraEncontrada.Hechos[posicion].Valor = hecho.Valor;
estructuraEncontrada.Hechos[posicion].ValorNumerico = hecho.ValorNumerico;
estructuraEncontrada.Hechos[posicion].ValorRedondeado = hecho.ValorRedondeado;
estructuraEncontrada.Hechos[posicion].EsNumerico = hecho.EsNumerico;
}
}
}
}
else
{
listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = indentacion,
EsAbstracto = concepto.EsAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = new Dictionary <string, EstructuraDimensionReporte>()
});
}
return(listaDeEstructurasConceptos);
}
/// <summary>
/// Busca el indice de la relación periodo del hecho con las columnas generadas
/// </summary>
/// <param name="documentoInstanciaXbrlDto">Modelo DTO</param>
/// <param name="columnas">lista de columnas que tiene el reporte</param>
/// <param name="hecho">objeto hechoDTO </param>
/// <returns></returns>
private int BuscarIndexColumna(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto, List <EstructuraColumnaReporte> columnas, HechoDto hecho, bool agruparPorUnidad)
{
var contexto = documentoInstanciaXbrlDto.ContextosPorId[hecho.IdContexto];
for (int idCol = 0; idCol < columnas.Count; idCol++)
{
var columna = columnas[idCol];
var unidadHecho = hecho.IdUnidad != null ? documentoInstanciaXbrlDto.UnidadesPorId[hecho.IdUnidad] : (UnidadDto)null;
if (columna.Entidad.Equals(contexto.Entidad.Id))
{
if ((columna.FechaInicio.Equals(contexto.Periodo.FechaInicio) &&
columna.FechaFin.Equals(contexto.Periodo.FechaFin) &&
columna.FechaInstante.Equals(contexto.Periodo.FechaInstante)))
{
if (agruparPorUnidad)
{
if (String.IsNullOrEmpty(columna.MonedaId))
{
if (unidadHecho == null)
{
return(idCol);
}
}
else
{
//Si columna tiene unidad y hecho tiene unidad, verificar si son compatibles
if (unidadHecho != null && unidadHecho.EsEquivalente(documentoInstanciaXbrlDto.UnidadesPorId[columna.MonedaId]))
{
return(idCol);
}
}
}
else
{
return(idCol);
}
}
}
}
return(-1);
}
