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

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

Resolved two bugs in synchronization:

  • full synchronization didn't work when no studies were present in the database (initial synchronization)
  • synchronization didn't work with spaces in the end of a studyToken
File size: 4.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 org.codehaus.groovy.grails.commons.ConfigurationHolder
18
19import nl.tno.metagenomics.auth.User;
20 
21class BaseFilters {
22        def gscfService
23        def synchronizationService
24       
25        // define filters
26        def filters = {
27               
28                userCheck(controller:'*', action:'*') {
29                        before = {
30                                if( actionName == "notifyStudyChange" && controllerName == "rest" ) {
31                                        return true;
32                                }
33                               
34                                if( !ConfigurationHolder.config.gscf.baseURL ) {
35                                        throw new Exception( "No GSCF instance specified. Please check configuration." )
36                                        return false
37                                }
38                               
39                                // enable to inject a session from the outside...
40                                if (params.sessionToken){
41                                        log.info("Setting SessionToken from params.sessionToken to ${params.sessionToken}")
42                                        session.sessionToken = params.sessionToken
43                                       
44                                        log.info("Redirecting to GSCF to login for session from params.sessionToken")
45                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
46                                        return false
47                                }
48                               
49                                // If a user is already logged in, let him continue
50                                if( session.user && session.user != null ) {
51                                        // If we don't refresh the user object, an old hiberante session could still be attached to the object
52                                        // raising errors later on (Lazy loading errors)
53                                        session.user.refresh();
54                                       
55                                        return true;
56                                }
57                               
58                                // on all pages of the Metagenomics module a user should be present in the session
59                                if (session.sessionToken) {
60                                        log.info("SessionToken found, ask GSCF for User information")
61
62                                        // try to identify the user with the sessionToken, since the user has logged in before                                                                 
63                                        try {
64                                                def user = [:]
65                                               
66                                                // First check if the user is authenticated. If he isn't, he should provide credentials at GSCF
67                                                def authentication = JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/isUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text)
68                                               
69                                                if( !authentication.authenticated ) {
70                                                        log.info "Not authenticated: " + authentication.authenticated
71                                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
72                                                        return false
73                                                }
74                                               
75                                                // Now find the user data
76                                                JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/getUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text).each { userProperty ->
77                                                        user["${userProperty.key}"] = "${userProperty.value}"
78                                                }
79                                               
80                                                // Locate user in database or create a new user
81                                                session.user = User.findByIdentifierAndUsername(user.id, user.username)
82                                                if (!session.user){ // when not found, create a new user
83                                                        session.user = new User(identifier: user.id, username: user.username).save(flush: true)
84                                                }
85                                        } catch(Exception e) {
86                                                log.error("Unable to fetch user from GSCF", e)
87                                                throw new Exception( "GSCF instance at " + ConfigurationHolder.config.gscf.baseURL + " could not be reached. Please check configuration.", e )
88                                        }
89                                } else {
90                                        session.sessionToken = "${UUID.randomUUID()}"
91                                        log.info("SessionToken created, redirectiong to GSCF to let the user login! (SessionToken: ${session.sessionToken}")
92
93                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
94                                        return false
95                                }
96                        }
97                }
98               
99                fullSynchronization(controller:'*', action:'*') {
100                        before = {
101                                // Never perform full synchronization on rest call when the synchronize controller is used
102                                if( controllerName == "rest" || controllerName == "synchronize" || controllerName == "dbUtil" ) {
103                                        return true;
104                                }
105
106                                // Never perform synchronization on a POST request
107                                if( request.method == "POST" )
108                                        return true;
109                                       
110                                if( synchronizationService.timeForFullSynchronization() ) {
111                                        redirect( url: synchronizationService.urlForFullSynchronization( params ) );
112                                        return false
113                                }
114                               
115                                return true
116
117                        }
118                }
119               
120                defineStyle(controller: '*', action: '*') {
121                        // before every execution
122                        before = {
123                                // set the default style in the session
124                                if (!session.style) {
125                                        session.style = 'metagenomics'
126                                }
127
128                                // set session lifetime to 1 week
129                                session.setMaxInactiveInterval(604800)
130                        }
131                }
132        }
133
134}
135
Note: See TracBrowser for help on using the repository browser.