/// <summary>
/// Obtiene el contenido del valor de secuencia de un contexto con la dimension Typed indicada
/// en el parámetro
/// </summary>
/// <param name="contexto"></param>
/// <param name="_idDimensionSecuencia"></param>
/// <returns></returns>
private string ObtenerSecuenciaDeContexto(ContextoDto contextoDto, string idDimension)
{
var dimensionesContexto = new List <DimensionInfoDto>();
if (contextoDto.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoDto.ValoresDimension);
}
if (contextoDto.Entidad.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoDto.Entidad.ValoresDimension);
}
foreach (var dimActual in dimensionesContexto)
{
if (idDimension.Equals(dimActual.IdDimension))
{
if (dimActual.ElementoMiembroTipificado != null)
{
int startIndex = dimActual.ElementoMiembroTipificado.IndexOf('>');
int endIndex = dimActual.ElementoMiembroTipificado.LastIndexOf('<');
if (startIndex >= 0 && endIndex >= 0 && endIndex > startIndex)
{
return(dimActual.ElementoMiembroTipificado.Substring(startIndex + 1, endIndex - startIndex - 1).Trim());
}
}
}
}
return(null);
}
/// <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);
}
private IList <ConceptoReporteDTO> llenarRol301100(IList <ConceptoReporteDTO> conceptos, DocumentoInstanciaXbrlDto instancia)
{
foreach (ConceptoReporteDTO concepto in conceptos)
{
HechoReporteDTO hechoReporte = null;
llenarConcepto(concepto, instancia);
if (concepto.Abstracto)
{
continue;
}
if (!concepto.Hechos.ContainsKey("periodo_actual"))
{
IList <String> hechos;
if (!instancia.HechosPorIdConcepto.TryGetValue(concepto.IdConcepto, out hechos))
{
continue;
}
if (hechos != null)
{
foreach (String idHecho in hechos)
{
String fecha = null;
HechoDto hecho = instancia.HechosPorId[idHecho];
ContextoDto contexto = instancia.ContextosPorId[hecho.IdContexto];
if (contexto.ContieneInformacionDimensional)
{
//log.info(hecho.Valor);
if (contexto.Periodo.Tipo == PeriodoDto.Instante)
{
fecha = DateReporteUtil.formatoFechaEstandar(contexto.Periodo.FechaInstante);
if ((fecha.Equals(reporteXBRLDTO.PeriodosReporte["periodo_actual"])) &&
concepto.Hechos.ContainsKey(contexto.ValoresDimension[0].IdItemMiembro))
{
hechoReporte = concepto.Hechos[contexto.ValoresDimension[0].IdItemMiembro];
llenarHecho(concepto, hecho, hechoReporte);
}
}
}
}
}
}
else
{
hechoReporte = concepto.Hechos["periodo_actual"];
obtenerHecho(concepto, hechoReporte, instancia);
}
}
return(conceptos);
}
/// <summary>
/// Propone un nuevo nombre de contexto en base a fechas y dimensiones del mismo
/// </summary>
/// <param name="ctxNuevo">Contexto creado</param>
/// <param name="instancia">Instancia actual</param>
/// <returns></returns>
public static String CrearContextoID(ContextoDto ctxNuevo, DocumentoInstanciaXbrlDto instancia)
{
String nombreCtx = ProponerNombreContexto(ctxNuevo, instancia);
long ixContexto = 0;
while (instancia.ContextosPorId.ContainsKey(nombreCtx + (ixContexto > 0 ? "_" + ixContexto : "")))
{
ixContexto++;
}
return(nombreCtx + (ixContexto > 0 ? "_" + ixContexto : ""));
}
/// <summary>
/// Genera nombre legible de contexto
/// </summary>
/// <param name="ctxNuevo">Contexto origen</param>
/// <returns>Nombre propuesto</returns>
private static string ProponerNombreContexto(ContextoDto ctxNuevo, DocumentoInstanciaXbrlDto instancia)
{
StringBuilder sb = new StringBuilder();
sb.Append("ctx");
//tipo de periodo - fechas
if (ctxNuevo.Periodo.Tipo == PeriodoDto.ParaSiempre)
{
sb.Append("_porSiempre");
}
else if (ctxNuevo.Periodo.Tipo == PeriodoDto.Duracion)
{
sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInicio) + "_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaFin));
}
else
{
sb.Append("_" + XmlUtil.ToUnionDateTimeString(ctxNuevo.Periodo.FechaInstante));
}
//Dimensiones
var dimTotales = new List <DimensionInfoDto>();
if (ctxNuevo.ValoresDimension != null)
{
dimTotales.AddRange(ctxNuevo.ValoresDimension);
}
if (ctxNuevo.Entidad.ValoresDimension != null)
{
dimTotales.AddRange(ctxNuevo.Entidad.ValoresDimension);
}
foreach (var dimension in dimTotales)
{
if (dimension.Explicita)
{
sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdItemMiembro].Nombre);
}
else
{
if (String.IsNullOrEmpty(dimension.ElementoMiembroTipificado))
{
sb.Append("_" + instancia.Taxonomia.ConceptosPorId[dimension.IdDimension].Nombre);
}
else
{
sb.Append("_" + ReporteXBRLUtil.eliminaEtiquetas(dimension.ElementoMiembroTipificado));
}
}
}
return(sb.ToString());
}
/// <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>
/// Determina si un contexto es palicable a los parametros dados.
/// </summary>
/// <param name="contexto">Contexto a evaluar.</param>
/// <param name="periodo">Plantilla del periodo.</param>
/// <param name="entidad"></param>
/// <param name="miembrosDimension">Diccionario con los miembros de dimensión a evaluar.</param>
/// <returns>Si el contexto aplica para los parametros dados.</returns>
public bool ContextoAplicable(ContextoDto contexto, PlantillaPeriodoDto periodo, EntidadDto entidad, IDictionary <string, string> miembrosDimension)
{
var valido = false;
if (periodo.EsEquivalente(contexto.Periodo, definicionPlantilla))
{
var entidadContexto = contexto.Entidad;
if (entidad == null ||
(entidad.EsquemaId.Equals(entidadContexto.EsquemaId) &&
entidad.Id.Equals(entidadContexto.Id) &&
entidad.ContieneInformacionDimensional == entidadContexto.ContieneInformacionDimensional))
{
if (miembrosDimension != null)
{
var valoresDimension = contexto.ContieneInformacionDimensional ? contexto.ValoresDimension :
entidadContexto.ContieneInformacionDimensional ? entidadContexto.ValoresDimension : null;
if (valoresDimension != null)
{
var correspondenMiembros = true;
foreach (var dimensionContexto in valoresDimension)
{
var qNameDimension = dimensionContexto.QNameDimension;
var idMiembroContexto = dimensionContexto.Explicita ?
dimensionContexto.QNameItemMiembro :
dimensionContexto.ElementoMiembroTipificado;
string idMiembroPlantilla;
if (miembrosDimension.TryGetValue(qNameDimension, out idMiembroPlantilla))
{
if (!idMiembroPlantilla.Equals(idMiembroContexto))
{
correspondenMiembros = false;
}
}
}
if (correspondenMiembros)
{
valido = true;
}
}
else
{
valido = true;
}
}
}
}
return(valido);
}
/// <summary>
/// Filtra un conjunto de hechos por el contenido de un item miembro de una dimensión en específico
/// </summary>
/// <param name="instancia"></param>
/// <param name="listaHechos"></param>
/// <param name="_idDimensionIntervalo"></param>
/// <param name="p"></param>
/// <returns></returns>
private IList <HechoDto> FiltrarHechosPorDimensionYMiembro(DocumentoInstanciaXbrlDto instancia, IList <HechoDto> listaHechos, string idDimension, string idItemMiembro)
{
var hechosFinales = new List <HechoDto>();
ContextoDto contexto = null;
foreach (var hechoActual in listaHechos)
{
contexto = instancia.ContextosPorId[hechoActual.IdContexto];
if (ContieneDimension(idDimension, idItemMiembro, contexto))
{
hechosFinales.Add(hechoActual);
}
}
return(hechosFinales);
}
/// <summary>
/// Crea una llave de fechas para el contexto dado.
/// </summary>
/// <param name="contexto">Contexto a evaluar.</param>
/// <returns>Llave generada en base al periodo.</returns>
public static String GeneraLlaveFechasContexto(ContextoDto contexto)
{
string llaveFechas = null;
if (contexto.Periodo.Tipo == PeriodoDto.Instante)
{
llaveFechas = Common.Util.DateUtil.ToFormatString(contexto.Periodo.FechaInstante.ToUniversalTime(), Common.Util.DateUtil.YMDateFormat);
}
else
{
llaveFechas = Common.Util.DateUtil.ToFormatString(contexto.Periodo.FechaInicio.ToUniversalTime(), Common.Util.DateUtil.YMDateFormat) +
ConstantesGenerales.Underscore_String
+ Common.Util.DateUtil.ToFormatString(contexto.Periodo.FechaFin.ToUniversalTime(), Common.Util.DateUtil.YMDateFormat);
}
return(llaveFechas);
}
public void ImportarDatosDeHojaExcel(NPOI.SS.UserModel.ISheet hojaAImportar, NPOI.SS.UserModel.ISheet hojaPlantilla, Dto.DocumentoInstanciaXbrlDto instancia, string rol, Common.Dtos.ResumenProcesoImportacionExcelDto resumenImportacion, Model.IDefinicionPlantillaXbrl plantillaDocumento)
{
DateTime fechaEvento = DateTime.MinValue;
int numeroRenglonActual = RENGLON_INICIO_DATOS;
var qNameEntidad = plantillaDocumento.ObtenerVariablePorId("esquemaEntidad") + ":" +
plantillaDocumento.ObtenerVariablePorId("nombreEntidad");
ContextoDto contextoDestinoSimple = null;
ContextoDto contextoDestinoDimension = null;
if (XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2016_10_12"), out fechaEvento))
{
contextoDestinoSimple = ObtenerContextoDestino(instancia, plantillaDocumento, qNameEntidad, fechaEvento, new List <DimensionInfoDto>());
ActualizarValorHecho(instancia, "rel_ev_Ticker", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
ActualizarValorHecho(instancia, "rel_ev_Date", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
ActualizarValorHecho(instancia, "rel_ev_BusinessName", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
ActualizarValorHecho(instancia, "rel_ev_Place", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
ActualizarValorHecho(instancia, "rel_ev_Subject", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
if (!instancia.EspacioNombresPrincipal.Contains("fondos"))
{
ActualizarValorHecho(instancia, "rel_ev_ForeignMarket", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoSimple, plantillaDocumento, resumenImportacion);
}
var valorTipoEvento = ExcelUtil.ObtenerValorCelda(hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS);
var idConceptoTipoEvento = BuscarTipoEvento(valorTipoEvento, instancia);
if (idConceptoTipoEvento != null)
{
DimensionInfoDto dimInfo = new DimensionInfoDto()
{
Explicita = true,
IdDimension = "rel_ev_RelevantEventTypesAxis",
QNameDimension = instancia.Taxonomia.ConceptosPorId["rel_ev_RelevantEventTypesAxis"].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId["rel_ev_RelevantEventTypesAxis"].Nombre,
IdItemMiembro = idConceptoTipoEvento,
QNameItemMiembro = instancia.Taxonomia.ConceptosPorId[idConceptoTipoEvento].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idConceptoTipoEvento].Nombre
};
contextoDestinoDimension = ObtenerContextoDestino(instancia, plantillaDocumento, qNameEntidad, fechaEvento, new List <DimensionInfoDto>()
{
dimInfo
});
ActualizarValorHecho(instancia, "rel_ev_RelevantEventContent", hojaAImportar, numeroRenglonActual++, COLUMNA_DATOS, contextoDestinoDimension, plantillaDocumento, resumenImportacion);
}
}
}
/// <summary>
/// Organiza un listado de hechos que contienen información dimensional de secuencia
/// </summary>
/// <param name="hechosDeTipoPasivo"></param>
/// <returns></returns>
private IDictionary <string, IList <HechoDto> > OrganizarHechosPorSecuencia(DocumentoInstanciaXbrlDto instancia, IList <HechoDto> hechosDeTipoPasivo)
{
ContextoDto contexto = null;
String secuencia = null;
var hechosAgrupados = new Dictionary <string, IList <HechoDto> >();
foreach (var hecho in hechosDeTipoPasivo)
{
contexto = instancia.ContextosPorId[hecho.IdContexto];
secuencia = ObtenerSecuenciaDeContexto(contexto, ImportadorExportadorRol815100Bmv2014._idDimensionSecuencia);
if (secuencia != null)
{
if (!hechosAgrupados.ContainsKey(secuencia))
{
hechosAgrupados[secuencia] = new List <HechoDto>();
}
hechosAgrupados[secuencia].Add(hecho);
}
}
return(hechosAgrupados);
}
/// <summary>
/// Crea un objeto de contexto para base de datos (sin relaciones) en base a su representación
/// en DTO
/// </summary>
/// <param name="contextoOrigen"></param>
/// <returns></returns>
public static Contexto CrearContextoDb(ContextoDto contextoOrigen)
{
var ctxDb = new Contexto
{
Escenario = ObtenerInformacionDimensional(contextoOrigen.ValoresDimension),
Nombre = contextoOrigen.Id,
PorSiempre = contextoOrigen.Periodo.Tipo == Period.ParaSiempre,
TipoContexto = contextoOrigen.Periodo.Tipo,
IdentificadorEntidad = contextoOrigen.Entidad.Id,
EsquemaEntidad = contextoOrigen.Entidad.EsquemaId,
Segmento = ObtenerInformacionDimensional(contextoOrigen.Entidad.ValoresDimension)
};
if (contextoOrigen.Periodo.Tipo == Period.Instante)
{
ctxDb.Fecha = contextoOrigen.Periodo.FechaInstante;
}
if (contextoOrigen.Periodo.Tipo == Period.Duracion)
{
ctxDb.FechaInicio = contextoOrigen.Periodo.FechaInicio;
ctxDb.FechaFin = contextoOrigen.Periodo.FechaFin;
}
return(ctxDb);
}
/// <summary>
/// Verifica si el contexto contiene la secuencia buscada en sus valores dimensionales (dimension typed)
/// </summary>
/// <param name="contextoDto"></param>
/// <param name="secuencia"></param>
/// <returns></returns>
private bool ContextoContieneSecuencia(ContextoDto contextoDto, string idDimension, string secuencia)
{
var dimensionesContexto = new List <DimensionInfoDto>();
if (contextoDto.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoDto.ValoresDimension);
}
if (contextoDto.Entidad.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoDto.Entidad.ValoresDimension);
}
foreach (var dimActual in dimensionesContexto)
{
if (idDimension.Equals(dimActual.IdDimension))
{
if (dimActual.ElementoMiembroTipificado != null && dimActual.ElementoMiembroTipificado.Contains(">" + secuencia + "<"))
{
return(true);
}
}
}
return(false);
}
/// <summary>
/// Toma los valores del contexto para generar su plantilla.
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public PlantillaContextoDto Deserialize(ContextoDto input)
{
Periodo = new PlantillaPeriodoDto().Deserialize(input.Periodo);
ContieneInformacionDimensional = input.ContieneInformacionDimensional;
return(this);
}
/// <summary>
/// Busca un contexto en el documento de instancia considerando las dimensiones enviadas, lo crea en caso de no encontrarlo
/// </summary>
/// <param name="instancia"></param>
/// <param name="plantillaDocumento"></param>
/// <param name="qNameEntidad"></param>
/// <param name="fechaEvento"></param>
/// <param name="list"></param>
/// <returns></returns>
private ContextoDto ObtenerContextoDestino(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, string qNameEntidad,
DateTime fechaEvento, List <DimensionInfoDto> dimensiones)
{
ContextoDto contextoDestino = null;
foreach (var contextoActual in instancia.ContextosPorId.Values)
{
if (dimensiones != null && dimensiones.Count > 0)
{
if (contextoActual.ValoresDimension != null && contextoActual.ValoresDimension.Count > 0)
{
contextoDestino = contextoActual;
contextoDestino.ValoresDimension[0].IdItemMiembro = dimensiones[0].IdItemMiembro;
contextoDestino.ValoresDimension[0].QNameItemMiembro = dimensiones[0].QNameItemMiembro;
break;
}
}
else
{
if (contextoActual.ValoresDimension == null || contextoActual.ValoresDimension.Count == 0)
{
contextoDestino = contextoActual;
break;
}
}
}
if (contextoDestino != null)
{
if (!(contextoDestino.Periodo.Tipo == Period.Instante && contextoDestino.Periodo.FechaInstante.CompareTo(fechaEvento) == 0))
{
contextoDestino = null;
}
}
if (contextoDestino == null)
{
List <DimensionInfoDto> dimensionesFinales = null;
if (dimensiones != null && dimensiones.Count > 0)
{
dimensionesFinales = new List <DimensionInfoDto>();
dimensionesFinales.AddRange(dimensiones);
}
contextoDestino = new ContextoDto()
{
Entidad = new EntidadDto()
{
ContieneInformacionDimensional = false,
EsquemaId = plantillaDocumento.ObtenerVariablePorId("esquemaEntidad"),
Id = plantillaDocumento.ObtenerVariablePorId("nombreEntidad")
},
ContieneInformacionDimensional = dimensiones.Count > 0,
ValoresDimension = dimensionesFinales,
Periodo = new PeriodoDto()
{
Tipo = Period.Instante,
FechaInicio = fechaEvento,
FechaFin = fechaEvento,
FechaInstante = fechaEvento
},
Id = "C" + Guid.NewGuid().ToString()
};
plantillaDocumento.InyectarContextoADocumentoInstancia(contextoDestino);
}
return(contextoDestino);
}
/// <summary>
/// Busca o crea un contexto con las características requeridas
/// </summary>
/// <returns></returns>
private ContextoDto BuscarOCrearContexto(DocumentoInstanciaXbrlDto instancia, IDefinicionPlantillaXbrl plantillaDocumento, IList <DimensionInfoDto> dimensiones,
String idDimensionSecuencia, String secuenciaBuscada, IDictionary <string, string> secuenciasAsignadas)
{
ContextoDto ctxDestino = null;
foreach (var ctx in instancia.ContextosPorId.Values)
{
//Verificar los contextos con 2 y 3 dimensiojnes
if (ctx.ValoresDimension != null && ctx.ValoresDimension.Count == (dimensiones.Count + 1))
{
var encontrado = true;
foreach (var dimBuscada in dimensiones)
{
if (!ContieneDimension(dimBuscada.IdDimension, dimBuscada.IdItemMiembro, ctx))
{
encontrado = false;
break;
}
}
if (encontrado)
{
if (secuenciaBuscada != null)
{
if (ContextoContieneSecuencia(ctx, idDimensionSecuencia, secuenciaBuscada))
{
ctxDestino = ctx;
break;
}
else
{
encontrado = false;
}
}
else
{
ctxDestino = ctx;
break;
}
}
}
}
if (ctxDestino == null)
{
var dimensionesFinales = new List <DimensionInfoDto>();
foreach (var dimBuscada in dimensiones)
{
dimensionesFinales.Add(new DimensionInfoDto()
{
Explicita = dimBuscada.Explicita,
IdDimension = dimBuscada.IdDimension,
QNameDimension = instancia.Taxonomia.ConceptosPorId[dimBuscada.IdDimension].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[dimBuscada.IdDimension].Nombre,
IdItemMiembro = dimBuscada.IdItemMiembro,
QNameItemMiembro = instancia.Taxonomia.ConceptosPorId[dimBuscada.IdItemMiembro].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[dimBuscada.IdItemMiembro].Nombre
});
}
var secuenciaFinal = secuenciaBuscada;
if (secuenciaFinal == null)
{
secuenciaFinal = ObtenerSiguienteSecuencia(secuenciasAsignadas);
}
dimensionesFinales.Add(new DimensionInfoDto()
{
Explicita = false,
IdDimension = idDimensionSecuencia,
QNameDimension = instancia.Taxonomia.ConceptosPorId[idDimensionSecuencia].EspacioNombres + ":" + instancia.Taxonomia.ConceptosPorId[idDimensionSecuencia].Nombre,
ElementoMiembroTipificado = String.Format(_elementoTypedSecuencia, secuenciaFinal)
});
DateTime fechaInstante = DateTime.MinValue;
XmlUtil.ParsearUnionDateTime(plantillaDocumento.ObtenerVariablePorId("fecha_2015_09_30"), out fechaInstante);
ctxDestino = new ContextoDto()
{
Entidad = new EntidadDto()
{
ContieneInformacionDimensional = false,
EsquemaId = plantillaDocumento.ObtenerVariablePorId("esquemaEntidad"),
Id = plantillaDocumento.ObtenerVariablePorId("nombreEntidad")
},
ContieneInformacionDimensional = dimensionesFinales.Count > 0,
ValoresDimension = dimensionesFinales,
Periodo = new PeriodoDto()
{
Tipo = PeriodoDto.Instante,
FechaInicio = DateTime.MinValue,
FechaFin = DateTime.MinValue,
FechaInstante = fechaInstante
},
Id = "C_AA" + Guid.NewGuid().ToString()
};
plantillaDocumento.InyectarContextoADocumentoInstancia(ctxDestino);
secuenciasAsignadas[secuenciaFinal] = ctxDestino.Id;
}
return(ctxDestino);
}
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));
}
}
}
/// <summary>
/// Verifica si el contexto contiene la información de dimensión y miembro enviada como paráemtro
/// </summary>
/// <param name="_idDimensionTipoPasivo"></param>
/// <param name="tipoPasivoActual"></param>
/// <param name="contextoActual"></param>
/// <returns></returns>
private bool ContieneDimension(string idDimensionBuscada, string idMiembroBuscado, ContextoDto contextoActual)
{
var dimensionesContexto = new List <DimensionInfoDto>();
if (contextoActual.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoActual.ValoresDimension);
}
if (contextoActual.Entidad.ValoresDimension != null)
{
dimensionesContexto.AddRange(contextoActual.Entidad.ValoresDimension);
}
foreach (var dimActual in dimensionesContexto)
{
if (idDimensionBuscada.Equals(dimActual.IdDimension) && idMiembroBuscado.Equals(dimActual.IdItemMiembro))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Verifica si un contexto cumple con las condiciones del fitro.
/// </summary>
/// <param name="contexto">Contexto que será evaluado.</param>
/// <param name="filtro">Filtro con las condiciones a evaluar.</param>
/// <returns>Si el contexto cumple o no con las condiciones de filtrado.</returns>
private Boolean ContenidoEnGruposExactosDimensionesFiltro(ContextoDto contexto, FiltroHechosDto filtro)
{
if (!contexto.ContieneInformacionDimensional && !contexto.Entidad.ContieneInformacionDimensional)
{
return(false);
}
var grupoDimensionesContexto = (contexto.ValoresDimension != null && contexto.ValoresDimension.Count > 0) ?
contexto.ValoresDimension : contexto.Entidad.ValoresDimension;
if (grupoDimensionesContexto == null || grupoDimensionesContexto.Count == 0)
{
return(false);
}
var contenido = false;
for (var index = 0; index < filtro.ConjuntosExactosDimensiones.Count; index++)
{
var matchGroup = true;
var dimensionGroup = filtro.ConjuntosExactosDimensiones[index];
if (dimensionGroup == null || dimensionGroup.Count != grupoDimensionesContexto.Count)
{
continue;
}
for (var indexDimContext = 0; indexDimContext < grupoDimensionesContexto.Count; indexDimContext++)
{
var dimConteined = false;
var dimensionContexto = grupoDimensionesContexto[indexDimContext];
for (var indexGroup = 0; indexGroup < dimensionGroup.Count; indexGroup++)
{
var dimensionFilter = dimensionGroup[indexGroup];
if (dimensionFilter.QNameDimension != dimensionContexto.QNameDimension)
{
continue;
}
if (dimensionFilter.Explicita != dimensionContexto.Explicita)
{
continue;
}
if (dimensionFilter.QNameItemMiembro != null && dimensionFilter.QNameItemMiembro != dimensionContexto.QNameItemMiembro)
{
continue;
}
if (dimensionFilter.ElementoMiembroTipificado != null && dimensionFilter.ElementoMiembroTipificado != dimensionContexto.ElementoMiembroTipificado)
{
continue;
}
dimConteined = true;
break;
}
if (!dimConteined)
{
matchGroup = false;
break;
}
}
if (matchGroup)
{
contenido = true;
break;
}
}
return(contenido);
}
/// <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);
}
