/// <summary>
/// Carga las notas al pie de base de datos al modelo de DTO del documento de instancia
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="instanciaXbrlDto"></param>
private static void CargarNotasAlPie(DocumentoInstancia instanciaDb, DocumentoInstanciaXbrlDto instanciaXbrlDto)
{
var hechosPorIdRef = instanciaXbrlDto.HechosPorId;
var notasPorIdRef = new Dictionary <string, List <NotaAlPieDto> >();
foreach (var notaDb in instanciaDb.NotaAlPie)
{
var notaDto = new NotaAlPieDto {
Idioma = notaDb.Idioma, Rol = notaDb.Rol, Valor = notaDb.Valor
};
if (!notasPorIdRef.ContainsKey(notaDb.IdRef))
{
notasPorIdRef.Add(notaDb.IdRef, new List <NotaAlPieDto>());
}
notasPorIdRef[notaDb.IdRef].Add(notaDto);
}
//Agregar notas a hechos por idioma
foreach (var notaPorId in notasPorIdRef)
{
if (hechosPorIdRef.ContainsKey(notaPorId.Key))
{
var hecho = hechosPorIdRef[notaPorId.Key];
hecho.NotasAlPie = new Dictionary <string, IList <NotaAlPieDto> >();
foreach (var notaDto in notaPorId.Value)
{
if (!hecho.NotasAlPie.ContainsKey(notaDto.Idioma))
{
hecho.NotasAlPie.Add(notaDto.Idioma, new List <NotaAlPieDto>());
}
hecho.NotasAlPie[notaDto.Idioma].Add(notaDto);
}
}
}
}
/// <summary>
/// Convierte los registros de DTS Documento instancia de la base de datos a su representación en DTO
/// </summary>
/// <param name="instanciaDb"></param>
/// <param name="instanciaXbrlDto"></param>
private static void CargarDts(DocumentoInstancia instanciaDb, DocumentoInstanciaXbrlDto instanciaXbrlDto)
{
foreach (var dtsDb in instanciaDb.DtsDocumentoInstancia)
{
var dtsDto = new DtsDocumentoInstanciaDto();
dtsDto.Tipo = dtsDb.TipoReferencia;
dtsDto.HRef = dtsDb.Href;
dtsDto.Role = dtsDb.Rol;
dtsDto.RoleUri = dtsDb.RolUri;
instanciaXbrlDto.DtsDocumentoInstancia.Add(dtsDto);
}
}
private String GeneraQueryEnviosMongo(DocumentoInstancia documento)
{
var query = new StringBuilder();
query.Append("{");
query.Append(" \"Taxonomia\" : ");
query.Append(ParseJson(documento.EspacioNombresPrincipal));
query.Append(", \"Entidad.Nombre\" : ");
query.Append(ParseJson(documento.ClaveEmisora));
query.Append(", \"Periodo.Fecha\" : ");
query.Append(ParseJson(documento.FechaReporte));
query.Append(" }");
return(query.ToString());
}
/// <summary>
/// Llena los datos básicos de un documento de instancia para base de datos a partir del modelo de DTO del documento de instancia
/// </summary>
/// <param name="destino"></param>
/// <param name="origen"></param>
/// <param name="idUsuarioExec"></param>
/// <param name="version"></param>
public static void ConvertirModeloDto(DocumentoInstancia destino, DocumentoInstanciaXbrlDto origen, long idUsuarioExec, int version)
{
destino.Titulo = origen.Titulo;
destino.RutaArchivo = origen.NombreArchivo;
destino.FechaCreacion = DateTime.Now;
destino.IdEmpresa = origen.IdEmpresa == 0 ? (long?)null : origen.IdEmpresa;
destino.EsCorrecto = origen.EsCorrecto;
destino.IdUsuarioUltMod = idUsuarioExec == 0 ? (long?)null : idUsuarioExec;
destino.UltimaVersion = version;
destino.FechaUltMod = DateTime.Now;
if (origen.ParametrosConfiguracion != null)
{
destino.ParametrosConfiguracion = JsonConvert.SerializeObject(origen.ParametrosConfiguracion);
}
if (origen.GruposContextosEquivalentes != null)
{
destino.GruposContextosEquivalentes = JsonConvert.SerializeObject(origen.GruposContextosEquivalentes);
}
destino.EspacioNombresPrincipal = origen.EspacioNombresPrincipal;
}
/// <summary>
/// Valida el punto 5.2.6.2.4 de la especificación de XBRL 2.1 donde se describe que la relación
/// del tipo requires-elemento implica que si en un documento de instancia existe un hecho
/// del elemento desde, entonces al menos un hecho del tipo hacia debe existir también en el documento de instancia
/// </summary>
/// <param name="arco"></param>
private void ValidarHechosRequiresElement(ArcoDefinicion arco)
{
foreach (ElementoLocalizable desde in arco.ElementoDesde)
{
foreach (ElementoLocalizable hacia in arco.ElementoHacia)
{
//Si existe elemento desde
IList <Fact> hechoElemento = DocumentoInstancia.ObtenerHechosPorConcepto((Concept)desde.Destino);
IList <Fact> hechoRequerido = DocumentoInstancia.ObtenerHechosPorConcepto((Concept)hacia.Destino);
if (hechoElemento != null && hechoElemento.Count > 0)
{
//existe elemento , verificar si existe el requerido
if (hechoRequerido == null || hechoRequerido.Count == 0)
{
ManejadorErrores.ManejarError(null, "5.2.6.2.4 Se encontró un hecho del tipo (" + desde.Destino.Id + ") en el documento de instancia pero no se encontró " +
" el hecho requerido (" + hacia.Destino.Id + ") definido en el arco: " + arco.ElementoXML.OuterXml, System.Xml.Schema.XmlSeverityType.Error);
}
}
}
}
}
/// <summary>
/// Copia el elemento evitando las referencias a objetos que proboquen redundancia ciclica cuando se serializan a JSON.
/// </summary>
/// <param name="o">Elemento a copiar.</param>
/// <returns>Copia del elemento.</returns>
public DocumentoInstanciaDto Copia(DocumentoInstancia o)
{
if (o == null)
{
return(null);
}
return(new DocumentoInstanciaDto()
{
IdDocumentoInstancia = o.IdDocumentoInstancia,
IdEmpresa = o.IdEmpresa != null?o.IdEmpresa.Value:0,
IdUsuarioBloqueo = o.IdUsuarioBloqueo,
Titulo = o.Titulo,
UltimaVersion = o.UltimaVersion,
RutaArchivo = o.RutaArchivo,
EsCorrecto = o.EsCorrecto,
Bloqueado = o.Bloqueado,
Empresa = Copia(o.Empresa),
FechaCreacion = o.FechaCreacion,
FechaUltMod = o.FechaUltMod,
IdUsuarioUltMod = o.IdUsuarioUltMod
});
}
/// <summary>
/// Carga los contextos y los convierte en su representación en DTO
/// </summary>
/// <param name="documentoDb">Documento de instancia de Base de datos</param>
/// <param name="documentoInstanciaXbrl">Documento de instancia destino dto</param>
private static void CargarContextos(DocumentoInstancia documentoDb, DocumentoInstanciaXbrlDto documentoInstanciaXbrl)
{
documentoInstanciaXbrl.ContextosPorId = new Dictionary <string, Viewer.Application.Dto.ContextoDto>();
foreach (var contextoDb in documentoDb.Contexto)
{
var ctxDto = new Viewer.Application.Dto.ContextoDto
{
Id = contextoDb.Nombre,
Escenario = contextoDb.Escenario,
Periodo = new PeriodoDto
{
Tipo = contextoDb.TipoContexto
}
};
//Recuperar valores de dimensión
ctxDto.ValoresDimension = RecuperarValoresDimension(ctxDto.Escenario);
ctxDto.ContieneInformacionDimensional = ctxDto.ValoresDimension != null &&
ctxDto.ValoresDimension.Count > 0;
if (contextoDb.TipoContexto == Period.Instante)
{
ctxDto.Periodo.FechaInstante = contextoDb.Fecha != null?contextoDb.Fecha.Value.ToLocalTime().ToUniversalTime() : DateTime.MinValue;
}
else if (contextoDb.TipoContexto == Period.Duracion)
{
ctxDto.Periodo.FechaInicio = contextoDb.FechaInicio != null?contextoDb.FechaInicio.Value.ToLocalTime().ToUniversalTime() : DateTime.MinValue;
ctxDto.Periodo.FechaFin = contextoDb.FechaFin != null?contextoDb.FechaFin.Value.ToLocalTime().ToUniversalTime() : DateTime.MinValue;
}
ctxDto.Entidad = CrearEntidad(documentoInstanciaXbrl, contextoDb);
if (!documentoInstanciaXbrl.ContextosPorId.ContainsKey(ctxDto.Id))
{
documentoInstanciaXbrl.ContextosPorId.Add(ctxDto.Id, ctxDto);
}
}
}
/// <summary>
/// Convierte los registros que representan a las uniades en un documento de instancia de base de datos
/// a su representación en DTO
/// </summary>
/// <param name="instanciaDb">Documento de instancia de Base de datos</param>
/// <param name="instanciaXbrlDto">Documento de instancia destino dto</param>
private static void CargarUnidades(DocumentoInstancia instanciaDb, DocumentoInstanciaXbrlDto instanciaXbrlDto)
{
foreach (var unidadDb in instanciaDb.Unidad)
{
var unidadDto = new UnidadDto
{
Id = unidadDb.IdRef,
Tipo = unidadDb.EsFraccion ? Unit.Divisoria : Unit.Medida
};
if (unidadDto.Tipo == Unit.Medida)
{
unidadDto.Medidas = CrearMedidasDto(unidadDb.Medida);
}
else
{
unidadDto.MedidasNumerador = CrearMedidasDto(unidadDb.Numerador);
unidadDto.MedidasDenominador = CrearMedidasDto(unidadDb.Denominador);
}
if (!instanciaXbrlDto.UnidadesPorId.ContainsKey(unidadDto.Id))
{
instanciaXbrlDto.UnidadesPorId.Add(unidadDto.Id, unidadDto);
}
}
}
/// <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>
/// Convierte los datos de base de datos del documento de instancia en su representación del modelo de DTO de presentación
/// </summary>
/// <param name="instanciaXbrlDto">Modelo DTO destino</param>
/// <param name="instanciaDb">Datos de origen</param>
public static void ConvertirModeloBaseDeDatos(DocumentoInstanciaXbrlDto instanciaXbrlDto, DocumentoInstancia instanciaDb)
{
if (!String.IsNullOrEmpty(instanciaDb.GruposContextosEquivalentes))
{
instanciaXbrlDto.GruposContextosEquivalentes =
JsonConvert.DeserializeObject <IDictionary <string, IList <string> > >(instanciaDb.GruposContextosEquivalentes);
}
if (!String.IsNullOrEmpty(instanciaDb.ParametrosConfiguracion))
{
instanciaXbrlDto.ParametrosConfiguracion =
JsonConvert.DeserializeObject <IDictionary <string, string> >(instanciaDb.ParametrosConfiguracion);
}
//Cargar DTS
CargarDts(instanciaDb, instanciaXbrlDto);
//Cargar contextos
CargarContextos(instanciaDb, instanciaXbrlDto);
//Cargar Unidades
CargarUnidades(instanciaDb, instanciaXbrlDto);
//Cargar Hechos
CargarHechos(instanciaDb, instanciaXbrlDto);
//Cargar Notas al Pie
CargarNotasAlPie(instanciaDb, instanciaXbrlDto);
DocumentoInstanciaXbrlDtoConverter.AgruparInformacionDocumento(instanciaXbrlDto);
}
/// <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>
/// Valida la consistencia de un conjunto de arcos summation-item
/// que aportan a la suma de un concepto
/// </summary>
/// <param name="arco">Arco a validar</param>
private void ValidarSumatoriasDeConcepto(ConceptItem conceptoSumatoria, IList <ArcoCalculo> arcosSumandos)
{
//Buscar en la lista de hechos todos los conceptos de la sumatoria
IList <Fact> hechosAValidar = DocumentoInstancia.ObtenerHechosPorConcepto(conceptoSumatoria);
if (hechosAValidar != null)
{
foreach (FactNumericItem hechoSumatoria in hechosAValidar)
{
Decimal valorDeSumandos = 0;
Boolean tieneSumandosDuplicados = false;
Boolean tieneElementosQueContribuyen = false;
List <FactNumericItem> sumandos = new List <FactNumericItem>();
//Para validar la sumatoria el elemento de sumatoria no debe ser nil y la precision debe ser diferente que cero y no debe tener hechos duplicados
if (!hechoSumatoria.IsNilValue)
{
if (hechoSumatoria.EsPrecisionEstablecida() && !hechoSumatoria.EsPrecisionInfinita && hechoSumatoria.PrecisionInferida != null && hechoSumatoria.PrecisionInferida == 0)
{
ManejadorErrores.ManejarError(null, "5.2.5.2 Se encontró un hecho que participa en una verificación de cálculo en arco summation-item " +
" cuya precision es '0' por lo tanto el cálculo es inconsistente", System.Xml.Schema.XmlSeverityType.Warning);
return;
}
if (hechoSumatoria.DuplicadoCon != null && hechoSumatoria.DuplicadoCon.Count > 0)
{
ManejadorErrores.ManejarError(null, "5.2.5.2 Se encontró un hecho que participa en una verificación de cálculo en arco summation-item " +
" que tiene duplicidad con otro hechos . No se validará la consistencia de este cálculo", System.Xml.Schema.XmlSeverityType.Warning);
continue;
}
foreach (ArcoCalculo arco in arcosSumandos)
{
//Procesar elementos de arco
foreach (ElementoLocalizable elementoHacia in arco.ElementoHacia)
{
IList <Fact> elementosSumatoria = DocumentoInstancia.ObtenerHechosPorConcepto((ConceptItem)elementoHacia.Destino);
foreach (FactNumericItem hechoSumando in elementosSumatoria)
{
//Verificar que sean del mismo contexto o equivalente
if (!DocumentoInstancia.GruposContextosEquivalentes[hechoSumando.Contexto.Id].Contains(hechoSumatoria.Contexto.Id))
{
//Este hecho no contribuye a la sumatoria
continue;
}
//Verificar que sean Unit - equal
if (!hechoSumatoria.UnitEquals(hechoSumando))
{
//Este hecho no contribuye a la sumatoria
continue;
}
//Verificar que el hecho sumando no tenga duplicados
if (hechoSumando.DuplicadoCon != null && hechoSumando.DuplicadoCon.Count > 0)
{
ManejadorErrores.ManejarError(null, "5.2.5.2 Se encontró un hecho que participa en una verificación de cálculo en arco summation-item " +
" que tiene duplicidad con otro hechos. No se validará la consistencia de este cálculo", System.Xml.Schema.XmlSeverityType.Warning);
tieneSumandosDuplicados = true;
break;
}
//Que el sumando no tenga valor nil
if (hechoSumando.IsNilValue)
{
continue;
}
//Si el hecho es un descendiente del padre
if (hechoSumatoria.Nodo != null)
{
/*if (!XmlUtil.EsNodoDescendiente(hechoSumatoria.Nodo.ParentNode ,hechoSumando.Nodo))
* {
* //no contribuye
* continue;
* }*/
//Verficar la precision del sumando
if (hechoSumatoria.EsPrecisionEstablecida() && !hechoSumando.EsPrecisionInfinita && hechoSumando.PrecisionInferida != null && hechoSumando.PrecisionInferida == 0)
{
ManejadorErrores.ManejarError(null, "5.2.5.2 Se encontró un hecho que participa en una verificación de cálculo en arco summation-item " +
" cuya precision es '0' por lo tanto el cálculo es inconsistente", System.Xml.Schema.XmlSeverityType.Warning);
return;
}
}
//Este hecho participa en la sumatoria como sumando
tieneElementosQueContribuyen = true;
valorDeSumandos += hechoSumando.ValorRedondeado * arco.Peso;
sumandos.Add(hechoSumando);
}
}
}
if (tieneElementosQueContribuyen && !tieneSumandosDuplicados)
{
//comparar el valor con la sumatoria
//Aplicar el redondeo de decimales
if (hechoSumatoria.ValorRedondeado != hechoSumatoria.Redondear(valorDeSumandos))
{
var err = ManejadorErrores.ManejarError(null, "5.2.5.2 Error en Verificación de cálculo: Contexto: " + hechoSumatoria.Contexto.Id + " : " +
" Valor de Sumatoria (" + hechoSumatoria.Concepto.Id + ") : " + hechoSumatoria.ValorRedondeado.ToString() + " : Valor Resultado de Sumandos: " +
hechoSumatoria.Redondear(valorDeSumandos).ToString(), System.Xml.Schema.XmlSeverityType.Warning);
err.IdHechoPrincipal = hechoSumatoria.Id;
err.IdHechosRelacionados = new List <String>();
foreach (var sum in sumandos)
{
err.IdHechosRelacionados.Add(sum.Id);
}
}
}
}
}
}
}