martes, 30 de julio de 2013

Instalar y configurar Spring Security en Grails parte 2

Esta es la continuación para terminar de configurar Spring Security en Grails, acá la primera parte

Para finalizar la configuración solo nos resta agregar los permisos a la base de datos (en un post anterior muestro como agregar datos a la BD cada vez que se carga nuestra aplicación, para esta parte nos va a ser muy útil) pongamos lo siguiente en el archivo catalogos.sql en el orden en que los pongo aquí mismo:

Primero necesitamos definir que roles tendrá nuestro sistema en este ejemplo solo habrá dos: Administrador y Usuarios

insert into rol (id, version, authority ) values (1, 0, 'ROLE_ADMINISTRADOR');
insert into rol (id, version, authority ) values (2, 0, 'ROLE_USUARIO');


Insertamos los usuarios de ejemplo

insert into usuario (id, version, username, "password", enabled, account_expired, account_locked, password_expired, nombre, apellido_paterno, apellido_materno, email, fecha_alta) values (1, 0, 'administrador', '5f4dcc3b5aa765d61d8327deb882cf99', 1, 0, 0, 0, 'Administrador', 'del', 'Sistema', 'administrador@example.com', current_timestamp);
insert into usuario (id, version, username, "password", enabled, account_expired, account_locked, password_expired, nombre, apellido_paterno, apellido_materno, email, fecha_alta) values (2, 0, 'usuario', '5f4dcc3b5aa765d61d8327deb882cf99', 1, 0, 0, 0, 'usuario', 'del', 'Sistema', 'usuario@example.com', current_timestamp);




Hacemos la relación entre el rol y el usuario

insert into usuario_rol ( rol_id , usuario_id ) values (1,1)
insert into usuario_rol ( rol_id , usuario_id ) values (2,2)


Finalmente agregamos los permisos

insert into requestmap (id, version, url, config_attribute) values (1, 0, '/admin/dbconsole/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (2, 0, '/js/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (3, 0, '/css/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (4, 0, '/images/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (5, 0, '/login/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (6, 0, '/logout/**', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (7, 0, '/', 'IS_AUTHENTICATED_ANONYMOUSLY');
insert into requestmap (id, version, url, config_attribute) values (8, 0, '/*', 'IS_AUTHENTICATED_FULLY');
insert into requestmap (id, version, url, config_attribute) values (9, 0, '/usuario/**', 'ROLE_ADMINISTRADOR');


Los controladores:

Una vez que terminamos con las configuraciones es necesario crear los controladores que son la puerta de entrada y salida a nuestra aplicación:



LoginController

class LoginController {

    /**
     * Dependency injection for the authenticationTrustResolver.
     */
    def authenticationTrustResolver

    /**
     * Dependency injection for the springSecurityService.
     */
    def springSecurityService

    def loginService


    /**
     * Default action; redirects to 'defaultTargetUrl' if logged in, /login/auth otherwise.
     */
    def index = {
        if (springSecurityService.isLoggedIn()) {
            redirect uri: SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl
        }
        else {
            redirect action: 'auth', params: params
        }
    }

    /**
     * Show the login page.
     */
    def auth = {
        println "llega aqui primero"
        def config = SpringSecurityUtils.securityConfig
         println "verificar si esta loggeado " + springSecurityService.isLoggedIn()
        if (springSecurityService.isLoggedIn()) {
            redirect uri: config.successHandler.defaultTargetUrl
            return
        }
        String view = 'login'
        String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
        render view: view, model: [postUrl: postUrl,
                rememberMeParameter: config.rememberMe.parameter]
    }

    /**
     * The redirect action for Ajax requests.
     */
    def authAjax = {
        response.setHeader 'Location', SpringSecurityUtils.securityConfig.auth.ajaxLoginFormUrl
        response.sendError HttpServletResponse.SC_UNAUTHORIZED
    }

    /**
     * Show denied page.
     */
    def denied = {
        if (springSecurityService.isLoggedIn() &&
                authenticationTrustResolver.isRememberMe(SCH.context?.authentication)) {
            // have cookie but the page is guarded with IS_AUTHENTICATED_FULLY
            redirect action: 'full', params: params
        }
    }

    /**
     * Login page for users with a remember-me cookie but accessing a IS_AUTHENTICATED_FULLY page.
     */
    def full = {
        def config = SpringSecurityUtils.securityConfig
        render view: 'index', params: params,
                model: [hasCookie: authenticationTrustResolver.isRememberMe(SCH.context?.authentication),
                        postUrl: "${request.contextPath}${config.apf.filterProcessesUrl}"]
    }

    /**
     * Callback after a failed login. Redirects to the auth page with a warning message.
     */
    def authfail = {

        def username = session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_KEY]
        String msg = ''
        def exception = session[WebAttributes.AUTHENTICATION_EXCEPTION]
        if (exception) {
            if (exception instanceof AccountExpiredException) {
                msg = g.message(code: "springSecurity.errors.login.expired")
            }
            else if (exception instanceof CredentialsExpiredException) {
                msg = g.message(code: "springSecurity.errors.login.passwordExpired")
            }
            else if (exception instanceof DisabledException) {
                msg = g.message(code: "springSecurity.errors.login.disabled")
            }
            else if (exception instanceof LockedException) {
                msg = g.message(code: "springSecurity.errors.login.locked")
            }
            else {
                msg = g.message(code: "springSecurity.errors.login.fail")
            }
        }

        if (springSecurityService.isAjax(request)) {
            render([error: msg] as JSON)
        }
        else {
            flash.message = msg
            redirect action: 'auth', params: params
        }
    }

    /**
     * The Ajax success redirect url.
     */
    def ajaxSuccess = {
        render([success: true, username: springSecurityService.authentication.name] as JSON)
    }

    /**
     * The Ajax denied redirect url.
     */
    def ajaxDenied = {
        render([error: 'access denied'] as JSON)
    }

    def errorAcceso = {
        def model = [:]
        return new ModelAndView("/login/Recuperar", model)
    }
}


LogoutController

class LogoutController {

    /**
     * Index action. Redirects to the Spring security logout uri.
     */
    def index = {

        redirect uri: SpringSecurityUtils.securityConfig.logout.filterProcessesUrl // '/j_spring_security_logout'
    }
}


Con esto únicamente nos resta crear la pantalla de login que servirá como entrada a nuestra aplicación

Pantalla de login

Por cuestiones de mala interpretación del plugin con respecto al html solo pondré lo que va en el body de nuestra gsp

${flash.message}






Listo!!! ahora solo ejecutamos nuestra aplicación y probamos que todo funcione, sí tienen dudas dejen un comentario.

1 comentario:

  1. buen dia he probado el tutorial pero al ingresar me dice q el usuario o la contraseña son incorrectos a q se deberá?????

    ResponderEliminar