Esempio n. 1
0
        /// <summary>
        /// Valida que los hechos de los roles y conceptos que requieran reportarse al acumulado actual tengan las fechas deseadas
        /// </summary>
        /// <param name="instancia">Documento de instancia a validar</param>
        /// <param name="parametros">Parametros de validación</param>
        /// <param name="fechaTrimestreParam">Fecha de trimestre que se reporta</param>
        /// <param name="resultadoValidacion">Objeto de resultado de la validación</param>
        /// <returns></returns>
        private bool ValidarHechosReportadosAlAcumulado(DocumentoInstanciaXbrlDto instancia, IDictionary <string, string> parametros, DateTime fechaTrimestreParam, ResultadoValidacionDocumentoXBRLDto resultadoValidacion)
        {
            var listaConceptosAValidar = new List <string>();

            foreach (var rol in ROL_URI_CONCEPTOS_REPORTADOS_AL_ACUMULADO)
            {
                var listaConceptosRol = UtilAbax.ObtenerListaConceptosDeRolPresentacion(instancia.Taxonomia, rol);
                foreach (var concepto in listaConceptosRol)
                {
                    listaConceptosAValidar.Add(concepto.Id);
                }
            }
            listaConceptosAValidar.AddRange(ID_CONCEPTOS_ACUMULADOS);
            DateTime fechaInicioEjercicio = new DateTime(fechaTrimestreParam.Year, 1, 1);

            foreach (var idConcepto in listaConceptosAValidar)
            {
                //Si se encuentran hechos, al menos uno debe estar reportado en el acumulado actual
                if (!ValidarAlMenosunHechoEnPeriodo(idConcepto, instancia, fechaInicioEjercicio, fechaTrimestreParam))
                {
                    AgregarError(resultadoValidacion, null, null, String.Format(M_ERROR_RV012, idConcepto), true);
                    return(false);
                }
            }


            return(true);
        }
Esempio n. 2
0
        /// <summary>
        /// Genera las columnas para el reporte y un listado de los conceptos procesados con o sin dimension
        /// </summary>
        /// <param name="documentoInstanciaXbrlDto">Modelo DTO</param>
        /// <param name="rolActual">rol a procesar</param>
        /// <param name="listaDeConceptosEnHiperCubos">lista de conceptos que el rol a procesar tiene en hipercubos</param>
        /// <param name="idioma">Idioma de presentación</param>
        /// <returns></returns>
        private EstructuraRolReporte listaDeConceptosPorRol(DocumentoInstanciaXbrlDto documentoInstanciaXbrlDto,
                                                            RolDto <EstructuraFormatoDto> rolActual, IEnumerable <string> listaDeConceptosEnHiperCubos, string idioma, bool agruparPorUnidad)
        {
            int indentacion      = 0;
            var listaDeConceptos = new List <EstructuraConceptoReporte>();
            var estructuraReporteGenericoPorRol = new EstructuraRolReporte();

            estructuraReporteGenericoPorRol.RolUri = rolActual.Uri;
            estructuraReporteGenericoPorRol.Rol    = rolActual.Nombre;

            // llenar columnas del reporte
            estructuraReporteGenericoPorRol.ColumnasDelReporte = new List <EstructuraColumnaReporte>();

            var conceptosIdPermitidos = UtilAbax.ObtenerListaConceptosDeRolPresentacion(documentoInstanciaXbrlDto.Taxonomia, rolActual.Uri)
                                        .Where(x => !((x.EsDimension != null?x.EsDimension.Value:false) || x.EsHipercubo || (x.EsMiembroDimension != null?x.EsMiembroDimension.Value:false)))
                                        .Select(x => x.Id);

            foreach (var conceptoId in conceptosIdPermitidos)
            {
                if (documentoInstanciaXbrlDto.HechosPorIdConcepto.ContainsKey(conceptoId))
                {
                    foreach (var idHecho in documentoInstanciaXbrlDto.HechosPorIdConcepto[conceptoId])
                    {
                        var hecho = documentoInstanciaXbrlDto.HechosPorId[idHecho];

                        if (hecho.IdContexto != null)
                        {
                            var contexto = documentoInstanciaXbrlDto.ContextosPorId[hecho.IdContexto];
                            //Verificar si este hecho cabe en alguna de las columnas
                            var columnaYaExiste = false;
                            foreach (var columna in estructuraReporteGenericoPorRol.ColumnasDelReporte)
                            {
                                if (HechoPerteneceAColumna(hecho, documentoInstanciaXbrlDto, columna, agruparPorUnidad))
                                {
                                    columnaYaExiste = true;
                                    break;
                                }
                            }
                            if (!columnaYaExiste)
                            {
                                estructuraReporteGenericoPorRol.ColumnasDelReporte.Add(CrearColumnaEncabezado(hecho, documentoInstanciaXbrlDto, agruparPorUnidad));
                            }
                        }
                    }
                }
            }


            if (estructuraReporteGenericoPorRol.ColumnasDelReporte.Count > 1)
            {
                estructuraReporteGenericoPorRol.ColumnasDelReporte = OrdenarFechaDeColumnas(estructuraReporteGenericoPorRol.ColumnasDelReporte);
            }
            Debug.WriteLine(estructuraReporteGenericoPorRol.Rol);
            foreach (var col in estructuraReporteGenericoPorRol.ColumnasDelReporte)
            {
                Debug.WriteLine(col.Entidad + "," + DateUtil.ToStandarString(col.FechaInicio) + " - " + DateUtil.ToStandarString(col.FechaFin) + " - " + DateUtil.ToStandarString(col.FechaInstante) + "," +
                                col.Moneda
                                );
            }

            if (documentoInstanciaXbrlDto.Taxonomia != null && documentoInstanciaXbrlDto.Taxonomia.RolesPresentacion != null)
            {
                foreach (var estructura in rolActual.Estructuras)
                {
                    AgregarNodoEstructura(documentoInstanciaXbrlDto, rolActual.Uri, listaDeConceptos, estructura, documentoInstanciaXbrlDto.Taxonomia, idioma, indentacion, estructuraReporteGenericoPorRol.ColumnasDelReporte, listaDeConceptosEnHiperCubos, agruparPorUnidad, conceptosIdPermitidos);
                }
            }
            estructuraReporteGenericoPorRol.Conceptos = listaDeConceptos;
            return(estructuraReporteGenericoPorRol);
        }