예제 #1
0
        /// <summary>
        /// Verifica si las autorizaciones requeridas del detalle de autorización están negadas para un registro de una tabla específica.
        /// </summary>
        /// <param name="id_tabla">Id de Tabla</param>
        /// <param name="id_registro">Id de Registro</param>
        /// <returns></returns>
        public RetornoOperacion ValidaAutorizacionNegada(int id_tabla, int id_registro)
        {
            //Definiendo objeto de retorno sin error
            RetornoOperacion resultado = new RetornoOperacion(id_registro);

            //Obteniendo los bloques de nivel inicial del detalle de autorización
            DataTable bloques = AutorizacionDetalleBloque.CargaBloquesAutorizacionDetalle(this._id_autorizacion_detalle, 0);

            //Si existen bloques
            if (Validacion.ValidaOrigenDatos(bloques))
            {
                //Recuperando el bloque raíz
                AutorizacionDetalleBloque bRaiz = new AutorizacionDetalleBloque((from DataRow r in bloques.Rows
                                                                                 select r.Field <int>("IdAutorizacionDetalleBloque")).FirstOrDefault());

                //Si la raíz fue encontrada
                if (bRaiz.id_autorizacion_detalle_bloque > 0)
                {
                    //Realizando validación
                    resultado = bRaiz.ValidaAutorizacionNegadasResponsables(id_tabla, id_registro);
                }
                else
                {
                    //Indicando error
                    resultado = new RetornoOperacion("No pudo ser encontrado el bloque inicial de autorizaciones.");
                }
            }

            //Devolviendo resultado
            return(resultado);
        }
예제 #2
0
        /// <summary>
        /// Realiza la deshabilitación de los registros autorización realizada requeridos en el detalle de autorización de un registro y tabla específicos.
        /// </summary>
        /// <param name="id_tabla">Id de Tabla</param>
        /// <param name="id_registro">Id de Registro</param>
        /// <param name="id_usuario">Id de usuario que solicita</param>
        /// <returns></returns>
        public RetornoOperacion DeshabilitaAutorizacionesSinConfirmar(int id_tabla, int id_registro, int id_usuario)
        {
            //Definiendo objeto de retorno, sin errores
            RetornoOperacion resultado = new RetornoOperacion(this._id_autorizacion_detalle);


            //Realizando la carga de los bloques del detalle de autorización
            DataTable bloques = AutorizacionDetalleBloque.CargaBloquesAutorizacionDetalle(this._id_autorizacion_detalle);

            //Si existen registros
            if (Validacion.ValidaOrigenDatos(bloques))
            {
                //Para cada uno de los bloques
                foreach (DataRow b in bloques.Rows)
                {
                    //Cargando los responsables del bloque
                    DataTable responsables = AutorizacionDetalleBloqueResponsable.CargaAutorizacionResponsablesBloque(b.Field <int>("IdAutorizacionDetalleBloque"), id_tabla, id_registro);

                    //Si existen responsables
                    if (Validacion.ValidaOrigenDatos(responsables))
                    {
                        //Para cada uno de los responsables
                        foreach (DataRow r in responsables.Rows)
                        {
                            //Instanciando la autorización realizada
                            using (AutorizacionRealizada ar = new AutorizacionRealizada(r.Field <int>("IdAutorizacionRealizada")))
                            {
                                //Validando que exista
                                if (ar.id_autorizacion_realizada > 0)
                                {
                                    if (ar.bit_confirmacion == null)
                                    {
                                        //Deshabilitando petición de autorización
                                        resultado = ar.DeshabilitaAutorizacionRealizada(id_usuario);
                                    }

                                    //En caso de errores
                                    if (!resultado.OperacionExitosa)
                                    {
                                        //Saliendo de ciclo de inserción
                                        break;
                                    }
                                }
                            }
                        }
                    }

                    //En caso de error
                    if (!resultado.OperacionExitosa)
                    {
                        //Saliendo de ciclo
                        break;
                    }
                }
            }

            //Devolviendo resultado
            return(resultado);
        }
예제 #3
0
        /// <summary>
        /// Realiza la inserción de los registros autorización realizada requeridos en el detalle de autorización de un registro y tabla específicos.
        /// </summary>
        /// <param name="id_tabla">Id de Tabla</param>
        /// <param name="id_registro">Id de Registro</param>
        /// <param name="id_usuario">Id de usuario que solicita</param>
        /// <returns></returns>
        public RetornoOperacion InsertaAutorizacionesRequeridas(int id_tabla, int id_registro, int id_usuario)
        {
            //Definiendo objeto de retorno, sin errores
            RetornoOperacion resultado = new RetornoOperacion(this._id_autorizacion_detalle);


            //Realizando la carga de los bloques del detalle de autorización
            DataTable bloques = AutorizacionDetalleBloque.CargaBloquesAutorizacionDetalle(this._id_autorizacion_detalle);

            //Si existen registros
            if (Validacion.ValidaOrigenDatos(bloques))
            {
                //Para cada uno de los bloques
                foreach (DataRow b in bloques.Rows)
                {
                    //Cargando los responsables del bloque
                    DataTable responsables = AutorizacionDetalleBloqueResponsable.CargaResponsablesAutorizacionDetalleBloque(b.Field <int>("IdAutorizacionDetalleBloque"));

                    //Si existen responsables
                    if (Validacion.ValidaOrigenDatos(responsables))
                    {
                        //Para cada uno de los responsables
                        foreach (DataRow r in responsables.Rows)
                        {
                            //Insertando petición de autorización
                            resultado = AutorizacionRealizada.InsertaAutorizacionRealizada(id_tabla, id_registro, r.Field <int>("IdAutorizacionDetalleBloqueResponsable"), id_usuario);

                            //Si no hay errores
                            if (resultado.OperacionExitosa)
                            {
                                //Instanciando autorización registrada
                                using (AutorizacionRealizada ar = new AutorizacionRealizada(resultado.IdRegistro))
                                {
                                    //Realziando el envío según corresponda
                                    //resultado = ar.EnviaNotificacionAutorizacion();
                                }
                            }

                            //En caso de errores
                            if (!resultado.OperacionExitosa)
                            {
                                //Saliendo de ciclo de inserción
                                break;
                            }
                        }
                    }

                    //En caso de error
                    if (!resultado.OperacionExitosa)
                    {
                        //Saliendo de ciclo
                        break;
                    }
                }
            }

            //Devolviendo resultado
            return(resultado);
        }
예제 #4
0
        /// <summary>
        /// Realiza la validación de las autorizaciones de un bloque, dado un registro de tabla específica. Devuelve error en caso de existir autorizaciones negadas (acorde al operador AND / OR)
        /// </summary>
        /// <param name="id_tabla">Id de Tabla</param>
        /// <param name="id_registro">Id de Registro</param>
        /// <returns></returns>
        public RetornoOperacion ValidaAutorizacionNegadasResponsables(int id_tabla, int id_registro)
        {
            //Definiendo objeto de retorno
            RetornoOperacion resultado = new RetornoOperacion(id_registro);

            //Cargando los bloques pertenecientes a este bloque (sub bloques)
            DataTable subBloques = AutorizacionDetalleBloque.CargaBloquesAutorizacionDetalle(this._id_autorizacion_detalle, this._id_autorizacion_detalle_bloque);

            //Validando la existencia de sub bloques
            if (Validacion.ValidaOrigenDatos(subBloques))
            {
                //Para cada uno de estos sub bloques
                foreach (DataRow sb in subBloques.Rows)
                {
                    //Instanciando bloque
                    using (AutorizacionDetalleBloque sBloque = new AutorizacionDetalleBloque(sb.Field <int>("IdAutorizacionDetalleBloque")))
                    {
                        //Si el bloque se instanció correctamente
                        if (sBloque.id_autorizacion_detalle_bloque > 0)
                        {
                            //Realizando validación del bloque
                            resultado = sBloque.ValidaAutorizacionNegadasResponsables(id_tabla, id_registro);
                        }

                        //Si existe error
                        if (!resultado.OperacionExitosa)
                        {
                            //Saliendo del ciclo
                            break;
                        }
                    }
                }
            }

            //Si no existen errores
            if (resultado.OperacionExitosa)
            {
                //Obteniendo los resultados de autorización de los responsables del bloque actual
                DataTable autorizaciones = AutorizacionDetalleBloqueResponsable.CargaAutorizacionResponsablesBloque(this._id_autorizacion_detalle_bloque, id_tabla, id_registro);

                //Validando que existan autorizaciones
                if (Validacion.ValidaOrigenDatos(autorizaciones))
                {
                    //Determinando el uso de resultados en base al operador lógico que rige al bloque
                    switch (this.operador)
                    {
                    case TipoOperador.AND:
                        //Si alguno de los elementos NO se ha autorizado aún
                        if ((from DataRow a in autorizaciones.Rows
                             select a.Field <bool?>("Autorizado")).Any(au => au.Equals(false)))
                        {
                            //Señalando el error
                            resultado = new RetornoOperacion("Existen autorizaciones rechazadas.");
                        }
                        break;

                    case TipoOperador.OR:
                        //Si todos los elementos NO se han autorizado aún
                        if ((from DataRow a in autorizaciones.Rows
                             select a.Field <bool?>("Autorizado")).All(au => au.Equals(false)))
                        {
                            //Señalando el error
                            resultado = new RetornoOperacion("Existen autorizaciones rechazadas.");
                        }
                        break;
                    }
                }
            }

            //Devolviendo resultado
            return(resultado);
        }