source: trunk/grails-app/conf/BaseFilters.groovy @ 20

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

Solved bug in moving data to trash

File size: 7.4 KB
Line 
1/**
2 * Base Filters
3 * @Author Jeroen Wesbeek
4 * @Since 20091026
5 * @see main.gsp
6 * @see http://grails.org/Filters
7 * @Description
8 *
9 * These filters contain generic logic for -every- page request.
10 *
11 * Revision information:
12 * $Rev: 776 $
13 * $Author: duh $
14 * $Date: 2010-08-05 12:15:26 +0200 (Thu, 05 Aug 2010) $
15 */
16import grails.converters.*
17import javax.servlet.http.HttpServletResponse
18
19import org.apache.catalina.connector.Response;
20import org.codehaus.groovy.grails.commons.ConfigurationHolder
21
22import nl.tno.metagenomics.auth.User;
23import nl.tno.metagenomics.integration.*;
24 
25class BaseFilters {
26        def gscfService
27        def synchronizationService
28       
29        // define filters
30        def filters = {
31               
32                userCheck(controller:'*', action:'*') {
33                        before = {
34                                if( actionName == "notifyStudyChange" ) {
35                                        return true;
36                                }
37                               
38                                if( !ConfigurationHolder.config.gscf.baseURL ) {
39                                        throw new Exception( "No GSCF instance specified. Please check configuration." )
40                                        return false
41                                }
42                               
43                                // We are handling the Rest controller as a special case. The rest calls are made
44                                // outside of the users browser session, so it should always contain a session token.
45                                // Moreover, it should never redirect the user, but instead send a 403 error
46                                if( controllerName == 'rest' ) {
47                                        if (!params.sessionToken && !session.sessionToken ){
48                                                response.setStatus( HttpServletResponse.SC_BAD_REQUEST, "No sessiontoken given" );
49                                                render "No sessiontoken given"
50                                                return false
51                                        }
52                                       
53                                        if( params.sessionToken ) 
54                                                session.sessionToken = params.sessionToken
55                                               
56                                        try {
57                                                def user = gscfService.getUser( session.sessionToken );
58                                               
59                                                if( user ) {
60                                                        session.user = User.findByIdentifierAndUsername( user.id, user.username );
61                                                        if( !session.user) {
62                                                                session.user = new User( identifier: user.id, username: user.username ).save( flush: true );
63                                                        }
64                                                } else {
65                                                        response.setStatus( HttpServletResponse.SC_UNAUTHORIZED, "No user logged in" );
66                                                        render "No user logged in"
67                                                        return false;
68                                                }
69                                        } catch( Exception e ) {
70                                                log.error( "Unable to fetch user from GSCF", e );
71                                                response.setStatus( HttpServletResponse.SC_BAD_REQUEST, "Unable to fetch user from GSCF" );
72                                                render "Unable to fetch user from GSCF"
73                                                return false;
74                                        } 
75                                       
76                                        return true;
77                                }
78                                                               
79                                // enable to inject a session from the outside...
80                                if (params.sessionToken){
81                                        log.info("Setting SessionToken from params.sessionToken to ${params.sessionToken}")
82                                        session.sessionToken = params.sessionToken
83                                       
84                                        log.info("Redirecting to GSCF to login for session from params.sessionToken")
85                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
86                                        return false
87                                }
88                               
89                                // If a user is already logged in, let him continue
90                                if( session.user && session.user != null ) {
91                                        // If we don't refresh the user object, an old hiberante session could still be attached to the object
92                                        // raising errors later on (Lazy loading errors)
93                                        session.user.refresh();
94                                       
95                                        return true;
96                                }
97                               
98                                // on all pages of the Metagenomics module a user should be present in the session
99                                if (session.sessionToken) {
100                                        log.info("SessionToken found, ask GSCF for User information")
101
102                                        // try to identify the user with the sessionToken, since the user has logged in before                                                                 
103                                        try {
104                                                def user = [:]
105                                               
106                                                // First check if the user is authenticated. If he isn't, he should provide credentials at GSCF
107                                                def authentication = JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/isUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text)
108                                               
109                                                if( !authentication.authenticated ) {
110                                                        log.info "Not authenticated: " + authentication.authenticated
111                                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
112                                                        return false
113                                                }
114                                               
115                                                // Now find the user data
116                                                JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/getUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text).each { userProperty ->
117                                                        user["${userProperty.key}"] = "${userProperty.value}"
118                                                }
119                                               
120                                                // Locate user in database or create a new user
121                                                session.user = User.findByIdentifierAndUsername(user.id, user.username)
122                                                if (!session.user){ // when not found, create a new user
123                                                        session.user = new User(identifier: user.id, username: user.username).save(flush: true)
124                                                }
125                                               
126                                                return true;
127                                        } catch(Exception e) {
128                                                log.error("Unable to fetch user from GSCF", e)
129                                                throw new Exception( "GSCF instance at " + ConfigurationHolder.config.gscf.baseURL + " could not be reached. Please check configuration.", e )
130                                        }
131                                } else {
132                                        session.sessionToken = "${UUID.randomUUID()}"
133                                        log.info("SessionToken created, redirecting to GSCF to let the user login! (SessionToken: ${session.sessionToken}")
134
135                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
136                                        return false
137                                }
138                        }
139                }
140                restSynchronization(controller:'rest', action:'*') {
141                        before = {
142                                // Synchronize studies normally, but never issue a redirect
143                                synchronizationService.sessionToken = session.sessionToken
144                                synchronizationService.user = session.user
145               
146                                try {
147                                        synchronizationService.synchronizeStudies()
148                                } catch( NotAuthenticatedException e ) {
149                                        // Something went wrong in authentication. Redirect the user to GSCF to authenticate again
150                                        log.info "User is not authenticated during synchronizatino. Returning 401 status"
151                                        response.setStatus( Response.SC_UNAUTHORIZED, "User is not authorized" )
152                                        return false;
153                                } catch( Exception e ) {
154                                        // Synchronization fails. Log error and continue; don't bother the user with it
155                                        log.error e.getMessage()
156                                }
157                                return true;
158                        }
159                }
160                synchronization(controller:'*', action:'*') {
161                        before = {
162                                // Never perform full synchronization on rest call or when the synchronize controller is used
163                                if( controllerName == "rest" || controllerName == "synchronize" || controllerName == "dbUtil" ) {
164                                        return true;
165                                }
166
167                                // Never perform synchronization on a POST request
168                                if( request.method == "POST" )
169                                        return true;
170                                       
171                                if( synchronizationService.timeForFullSynchronization() ) {
172                                        redirect( url: synchronizationService.urlForFullSynchronization( params ) );
173                                        return false
174                                } else {
175                                        // Synchronize studies normally
176                                        synchronizationService.sessionToken = session.sessionToken
177                                        synchronizationService.user = session.user
178                       
179                                        try {
180                                                synchronizationService.synchronizeStudies()
181                                        } catch( NotAuthenticatedException e ) {
182                                                // Something went wrong in authentication. Redirect the user to GSCF to authenticate again
183                                                log.info "User is not authenticated during synchronizatino. Redirecting to GSCF."
184                                                redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
185                                                return false;
186                                        } catch( Exception e ) {
187                                                // Synchronization fails. Log error and continue; don't bother the user with it
188                                                e.printStackTrace()
189                                                log.error e.getMessage()
190                                        }
191                                }
192                               
193                                return true
194
195                        }
196                }
197               
198                defineStyle(controller: '*', action: '*') {
199                        // before every execution
200                        before = {
201                                // set the default style in the session
202                                if (!session.style) {
203                                        session.style = 'metagenomics'
204                                }
205
206                                // set session lifetime to 1 week
207                                session.setMaxInactiveInterval(604800)
208                        }
209                }
210        }
211
212}
213
Note: See TracBrowser for help on using the repository browser.