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

Last change on this file since 1977 was 1977, checked in by robert@…, 13 years ago
  • Implemented silent remote login method
  • Added a clean error message if an optimistic locking exception occurs in study wizard
  • Made the study wizard send notifications if only the assay-sample associations has been changed
  • Property svn:keywords set to Rev Author Date
File size: 6.3 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                // Silent means that the user will be sent back, regardless of his login state. He will not
72                // be redirected to the login page.
73                def silent = params.silent ? Boolean.valueOf( params.silent ) : false;
74               
75                if (consumer == null || token == null) {
76                        throw new Exception("Consumer and Token must be given!");
77                }
78
79                log.info( "Remote authentication with " + consumer + " and " + token )
80               
81                def returnUrl;
82               
83                // If no returnUrl is given, find the previous one from the session
84                if( params.returnUrl ) {
85                        returnUrl = params.returnUrl;
86                        session.authRemoteUrl = returnUrl;
87                } else if( session.authRemoteUrl ) {
88                        returnUrl = session.authRemoteUrl;
89                }
90
91                // If the user is already authenticated with this session_id, redirect
92                // him
93                if (authenticationService.isRemotelyLoggedIn(consumer, token)) {
94                        if (returnUrl) {
95                                redirect url: returnUrl
96                        } else {
97                                redirect controller: 'home'
98                        }
99                }
100
101                // If the user is already logged in locally, we log him in and
102                // immediately redirect him
103                if (authenticationService.isLoggedIn()) {
104                        authenticationService.logInRemotely(consumer, token, authenticationService.getLoggedInUser())
105
106                        if (returnUrl) {
107                                redirect url: returnUrl
108                        } else {
109                                redirect controller: 'home'
110                        }
111                        return;
112                }
113               
114                // On silent login, the user should be sent back anyway
115                if( silent ) {
116                        if (returnUrl) {
117                                redirect url: returnUrl
118                        } else {
119                                redirect controller: 'home'
120                        }
121                }
122               
123                // Otherwise we show the login screen
124                def config = SpringSecurityUtils.securityConfig
125                String view = 'auth'
126                String postUrl = "${request.contextPath}${config.apf.filterProcessesUrl}"
127               
128                String redirectUrl = g.createLink(controller: 'login', action: 'auth_remote', params: [consumer: params.consumer, token: params.token], absolute: true)
129                render view: view, model: [postUrl: postUrl,
130                        rememberMeParameter: config.rememberMe.parameter, redirectUrl: redirectUrl]
131        }
132
133        /**
134         * Show denied page.
135         */
136        def denied = {
137                if (springSecurityService.isLoggedIn() &&
138                        authenticationTrustResolver.isRememberMe(SCH.context?.authentication)) {
139                        // have cookie but the page is guarded with IS_AUTHENTICATED_FULLY
140                        redirect action: full, params: params
141                }
142        }
143
144        /**
145         * Login page for users with a remember-me cookie but accessing a IS_AUTHENTICATED_FULLY page.
146         */
147        def full = {
148                def config = SpringSecurityUtils.securityConfig
149                render view: 'auth', params: params,
150                        model: [hasCookie: authenticationTrustResolver.isRememberMe(SCH.context?.authentication),
151                                postUrl: "${request.contextPath}${config.apf.filterProcessesUrl}"]
152        }
153
154        /**
155         * Callback after a failed login. Redirects to the auth page with a warning message.
156         */
157        def authfail = {
158                def username = session[UsernamePasswordAuthenticationFilter.SPRING_SECURITY_LAST_USERNAME_KEY]
159                String msg = ''
160                def exception = session[AbstractAuthenticationProcessingFilter.SPRING_SECURITY_LAST_EXCEPTION_KEY]
161                if (exception) {
162                        if (exception instanceof AccountExpiredException) {
163                                msg = SpringSecurityUtils.securityConfig.errors.login.expired
164                        }
165                        else if (exception instanceof CredentialsExpiredException) {
166                                msg = SpringSecurityUtils.securityConfig.errors.login.passwordExpired
167                        }
168                        else if (exception instanceof DisabledException) {
169                                msg = SpringSecurityUtils.securityConfig.errors.login.disabled
170                        }
171                        else if (exception instanceof LockedException) {
172                                msg = SpringSecurityUtils.securityConfig.errors.login.locked
173                        }
174                        else {
175                                msg = SpringSecurityUtils.securityConfig.errors.login.fail
176                        }
177                }
178
179                if (springSecurityService.isAjax(request)) {
180                        // set output header to json
181                        response.contentType = 'application/json'
182
183                        render([error: msg] as JSON)
184                }
185                else {
186                        flash.message = msg
187                        redirect action: auth, params: params
188                }
189        }
190
191        /**
192         * The Ajax success redirect url.
193         */
194        def ajaxSuccess = {
195                // set output header to json
196                response.contentType = 'application/json'
197
198                render([success: true, username: springSecurityService.authentication.name] as JSON)
199        }
200
201        /**
202         * The Ajax denied redirect url.
203         */
204        def ajaxDenied = {
205                // set output header to json
206                response.contentType = 'application/json'
207
208                render([error: 'access denied'] as JSON)
209        }
210}
Note: See TracBrowser for help on using the repository browser.