source: trunk/grails-app/controllers/dbnp/authentication/LoginController.groovy @ 1773

Last change on this file since 1773 was 1773, checked in by robert@…, 10 years ago

Solved redirect bug in login controller

  • Property svn:keywords set to Rev Author Date
File size: 5.8 KB
Line 
1package dbnp.authentication
2
3import grails.converters.JSON
4
5import org.codehaus.groovy.grails.plugins.springsecurity.SpringSecurityUtils
6
7import org.springframework.security.authentication.AccountExpiredException
8import org.springframework.security.authentication.CredentialsExpiredException
9import org.springframework.security.authentication.DisabledException
10import org.springframework.security.authentication.LockedException
11import org.springframework.security.core.context.SecurityContextHolder as SCH
12import org.springframework.security.web.authentication.AbstractAuthenticationProcessingFilter
13import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter
14import org.codehaus.groovy.grails.commons.ConfigurationHolder
15
16class LoginController {
17        /**
18         * Dependency injection for the authenticationTrustResolver.
19         */
20        def authenticationTrustResolver
21
22        /**
23         * Dependency injection for the springSecurityService.
24         */
25        def springSecurityService
26
27        /**
28         * Dependency injection for the GSCF authentication service
29         */
30        def authenticationService
31
32        /**
33         * Default action; redirects to 'defaultTargetUrl' if logged in, /login/auth otherwise.
34         */
35        def index = {
36                if (springSecurityService.isLoggedIn()) {
37                        redirect uri: SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl
38                }
39                else {
40                        redirect action: auth, params: params
41                }
42        }
43
44        /**
45         * Show the login page.
46         */
47        def auth = {
48                def config = SpringSecurityUtils.securityConfig
49                if (springSecurityService.isLoggedIn()) {
50                        if (params.returnURI) {
51                                // see basefilters
52                                redirect uri: params.returnURI
53                        } else {
54                                redirect uri: config.successHandler.defaultTargetUrl
55                        }
56                        return
57                }
58
59                String view = 'auth'
60                String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
61                render view: view, model: [postUrl: postUrl, rememberMeParameter: config.rememberMe.parameter]
62        }
63
64        /**
65         * Shows the login page for users from a module
66         */
67        def auth_remote = {
68                def consumer = params.consumer
69                def token = params.token
70               
71                if (consumer == null || token == null) {
72                        throw new Exception("Consumer and Token must be given!");
73                }
74
75                def returnUrl;
76               
77                // If no returnUrl is given, find the previous one from the session
78                if( params.returnUrl ) {
79                        returnUrl = params.returnUrl;
80                        session.authRemoteUrl = returnUrl;
81                } else if( session.authRemoteUrl ) {
82                        returnUrl = session.authRemoteUrl;
83                }
84
85                // If the user is already authenticated with this session_id, redirect
86                // him
87                if (authenticationService.isRemotelyLoggedIn(consumer, token)) {
88                        if (returnUrl) {
89                                redirect url: returnUrl
90                        } else {
91                                redirect controller: 'home'
92                        }
93                }
94
95                // If the user is already logged in locally, we log him in and
96                // immediately redirect him
97                if (authenticationService.isLoggedIn()) {
98                        authenticationService.logInRemotely(consumer, token, authenticationService.getLoggedInUser())
99
100                        if (returnUrl) {
101                                redirect url: returnUrl
102                        } else {
103                                redirect controller: 'home'
104                        }
105                        return;
106                }
107
108                // Otherwise we show the login screen
109                def config = SpringSecurityUtils.securityConfig
110                String view = 'auth'
111                String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
112               
113                String redirectUrl = g.createLink(controller: 'login', action: 'auth_remote', params: [consumer: params.consumer, token: params.token], absolute: true)
114                render view: view, model: [postUrl: postUrl,
115                        rememberMeParameter: config.rememberMe.parameter, redirectUrl: redirectUrl]
116        }
117
118        /**
119         * Show denied page.
120         */
121        def denied = {
122                if (springSecurityService.isLoggedIn() &&
123                        authenticationTrustResolver.isRememberMe(SCH.context?.authentication)) {
124                        // have cookie but the page is guarded with IS_AUTHENTICATED_FULLY
125                        redirect action: full, params: params
126                }
127        }
128
129        /**
130         * Login page for users with a remember-me cookie but accessing a IS_AUTHENTICATED_FULLY page.
131         */
132        def full = {
133                def config = SpringSecurityUtils.securityConfig
134                render view: 'auth', params: params,
135                        model: [hasCookie: authenticationTrustResolver.isRememberMe(SCH.context?.authentication),
136                                postUrl: "${request.contextPath}${config.apf.filterProcessesUrl}"]
137        }
138
139        /**
140         * Callback after a failed login. Redirects to the auth page with a warning message.
141         */
142        def authfail = {
143                def username = session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_KEY]
144                String msg = ''
145                def exception = session[AbstractAuthenticationProcessingFilter.SPRING_SECURITY_LAST_EXCEPTION_KEY]
146                if (exception) {
147                        if (exception instanceof AccountExpiredException) {
148                                msg = SpringSecurityUtils.securityConfig.errors.login.expired
149                        }
150                        else if (exception instanceof CredentialsExpiredException) {
151                                msg = SpringSecurityUtils.securityConfig.errors.login.passwordExpired
152                        }
153                        else if (exception instanceof DisabledException) {
154                                msg = SpringSecurityUtils.securityConfig.errors.login.disabled
155                        }
156                        else if (exception instanceof LockedException) {
157                                msg = SpringSecurityUtils.securityConfig.errors.login.locked
158                        }
159                        else {
160                                msg = SpringSecurityUtils.securityConfig.errors.login.fail
161                        }
162                }
163
164                if (springSecurityService.isAjax(request)) {
165                        // set output header to json
166                        response.contentType = 'application/json'
167
168                        render([error: msg] as JSON)
169                }
170                else {
171                        flash.message = msg
172                        redirect action: auth, params: params
173                }
174        }
175
176        /**
177         * The Ajax success redirect url.
178         */
179        def ajaxSuccess = {
180                // set output header to json
181                response.contentType = 'application/json'
182
183                render([success: true, username: springSecurityService.authentication.name] as JSON)
184        }
185
186        /**
187         * The Ajax denied redirect url.
188         */
189        def ajaxDenied = {
190                // set output header to json
191                response.contentType = 'application/json'
192
193                render([error: 'access denied'] as JSON)
194        }
195}
Note: See TracBrowser for help on using the repository browser.