/// <summary>
/// Genera un listado de hechos con relacion al concepto sin dimension
/// </summary>
/// <param name="concepto">Entidad concepto a procesar</param>
/// <param name="columnas">Lista de columnas que tiene el reporte</param>
/// <param name="listaDeHechosPorConcepto">Lista de hecho a procesar</param>
/// <param name="idioma">Idioma en que se mostrara el reporte</param>
/// <param name="agruparPorUnidad">Por default es "True", permite agrupar por Moneda, si es "False" agrupa por Entidad</param>
/// <returns></returns>
private EstructuraHechoReporte[] ObtenerPrimerHechoSinDimension(EntConcepto concepto, List <EstructuraColumnaReporte> columnas, IEnumerable <EntHecho> listaDeHechos, string idioma, bool agruparPorUnidad, bool esAbstracto)
{
EstructuraHechoReporte[] estructuraHecho = new EstructuraHechoReporte[columnas.Count()];
int valoresDeHechosEncontrados = 0;
var listaDeHechosPorConcepto = listaDeHechos.Where(x => x.concepto.Id.Equals(concepto.Id));
foreach (var hecho in listaDeHechosPorConcepto)
{
if (valoresDeHechosEncontrados == columnas.Count)
{
break;
}
if (hecho.dimension != null)
{
continue;
}
int posicion = BuscarIndexColumna(columnas, hecho, agruparPorUnidad);
if (posicion != -1)
{
estructuraHecho[posicion] = new EstructuraHechoReporte();
estructuraHecho[posicion].Valor = WebUtility.HtmlDecode(hecho.valor);
estructuraHecho[posicion].ValorFormateado = hecho.valorFormateado;
estructuraHecho[posicion].ValorRedondeado = (!string.IsNullOrEmpty(hecho.valorRedondeado) ? Convert.ToDecimal(hecho.valorRedondeado) : 0);
estructuraHecho[posicion].EsNumerico = hecho.esTipoDatoNumerico;
estructuraHecho[posicion].TipoDato = hecho.tipoDato;
valoresDeHechosEncontrados++;
}
}
return(estructuraHecho);
}
public ConceptoAdapter(Concepto concepto)
{
this.EntConcepto = new EntConcepto
{
Id = concepto.IdConcepto,
Nombre = concepto.Nombre,
EspacioNombres = concepto.EspacioNombres,
etiqueta = AdaptarEtiquetasEntity(concepto.Etiquetas)
};
}
/// <summary>
/// Obtiene la descripcion del concepto en el idioma especificado
/// </summary>
/// <param name="concepto">Entidad concepto que contiene la etiqueta </param>
/// <param name="idioma">Idioma en que se mostrara el reporte</param>
/// <returns></returns>
private string ObtenerNombreConceptoAbstracto(EntConcepto concepto, string idioma)
{
if (concepto.EtiquetaConceptoAbstracto == null || concepto.EtiquetaConceptoAbstracto.Count() == 0)
{
return(concepto.EtiquetaVista);
}
string descripcion = string.Empty;
if (concepto.EtiquetaConceptoAbstracto.Where(x => x.Key.Equals(idioma)).Any())
{
descripcion = concepto.EtiquetaConceptoAbstracto.Where(x => x.Key.Equals(idioma)).Select(x => x.Value).FirstOrDefault();
}
else
{
descripcion = concepto.EtiquetaVista;
}
return(descripcion);
}
/// <summary>
/// Obtiene la descripcion del concepto en el idioma especificado
/// </summary>
/// <param name="concepto">Entidad concepto que contiene la etiqueta </param>
/// <param name="idioma">Idioma en que se mostrara el reporte</param>
/// <returns></returns>
private string ObtenerNombreConcepto(EntConcepto concepto, string idioma)
{
if (concepto.etiqueta == null || concepto.etiqueta.Count() == 0)
{
return(concepto.Id);
}
string descripcion = string.Empty;
if (concepto.etiqueta.Where(x => x.lenguaje.Equals(idioma)).Any())
{
descripcion = concepto.etiqueta.Where(x => x.lenguaje.Equals(idioma)).Select(x => x.valor).FirstOrDefault();
}
else
{
descripcion = concepto.etiqueta[0].valor;
}
return(descripcion);
}
/// <summary>
/// Genera un listado de los conceptos con la relacion de sus dimensiones
/// </summary>
/// <param name="concepto">Entidad concepto</param>
/// <param name="columnas">Lista de columnas que tiene el reporte</param>
/// <param name="listaDeHechos">Lista de hechos devueltos por el filtro</param>
/// <param name="idioma">Idioma en que se mostrara el reporte</param>
/// <param name="agruparPorUnidad">Por default es "True", permite agrupar por Moneda, si es "False" agrupa por Entidad</param>
/// <returns></returns>
private IList <EstructuraConceptoReporte> BuscarConceptosConDimensiones(EntConcepto concepto, List <EstructuraColumnaReporte> columnas, IEnumerable <EntHecho> listaDeHechos, string idioma, bool agruparPorUnidad, int nivelIndentacion, bool esAbstracto)
{
List <EstructuraConceptoReporte> listaDeEstructurasConceptos = new List <EstructuraConceptoReporte>();
var listaDeHechosPorConcepto = listaDeHechos.Where(x => x.concepto.Id.Equals(concepto.Id));
string nombreconcepto = ObtenerNombreConcepto(concepto, idioma);
if (!(esAbstracto))
{
if (listaDeHechosPorConcepto.Count() == 0)
{
var combinacionDimensiones = new Dictionary <string, EstructuraDimensionReporte>();
listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = nivelIndentacion,
EsAbstracto = esAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = combinacionDimensiones
});
return(listaDeEstructurasConceptos);
}
else
{
foreach (var hecho in listaDeHechosPorConcepto)
{
if (hecho.dimension != null)
{
List <EntDimension> listaDimensionesTotales = new List <EntDimension>();
listaDimensionesTotales.AddRange(hecho.dimension);
EstructuraConceptoReporte estructuraEncontrada = null;
var estructuraDimensionesBuscada = CrearEstructuraDimensiones(listaDimensionesTotales, 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 = nivelIndentacion,
EsAbstracto = esAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = estructuraDimensionesBuscada
};
listaDeEstructurasConceptos.Add(estructuraEncontrada);
}
int posicion = BuscarIndexColumna(columnas, hecho, agruparPorUnidad);
if (posicion != -1)
{
estructuraEncontrada.Hechos[posicion] = new EstructuraHechoReporte();
estructuraEncontrada.Hechos[posicion].Valor = hecho.valor;
estructuraEncontrada.Hechos[posicion].ValorFormateado = hecho.valorFormateado;
estructuraEncontrada.Hechos[posicion].ValorRedondeado = (!string.IsNullOrEmpty(hecho.valorRedondeado) ? Convert.ToDecimal(hecho.valorRedondeado) : 0);
estructuraEncontrada.Hechos[posicion].EsNumerico = hecho.esTipoDatoNumerico;
estructuraEncontrada.Hechos[posicion].TipoDato = hecho.tipoDato;
}
}
}
}
}
else
{
listaDeEstructurasConceptos.Add(new EstructuraConceptoReporte()
{
ConceptoId = concepto.Id,
NombreConcepto = nombreconcepto,
NivelIndentacion = nivelIndentacion,
EsAbstracto = esAbstracto,
Hechos = new EstructuraHechoReporte[columnas.Count],
Dimensiones = new Dictionary <string, EstructuraDimensionReporte>()
});
}
return(listaDeEstructurasConceptos);
}
