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

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

Externalized configuration; improved assay view (detail views of runs and samples); implemented uploading and parsing of FASTA and QUAL files

File size: 4.2 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                                        return true;
52                                }
53                               
54                                // on all pages of the Metagenomics module a user should be present in the session
55                                if (session.sessionToken) {
56                                        log.info("SessionToken found, ask GSCF for User information")
57
58                                        // try to identify the user with the sessionToken, since the user has logged in before                                                                 
59                                        try {
60                                                def user = [:]
61                                               
62                                                // First check if the user is authenticated. If he isn't, he should provide credentials at GSCF
63                                                def authentication = JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/isUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text)
64                                               
65                                                if( !authentication.authenticated ) {
66                                                        log.info "Not authenticated: " + authentication.authenticated
67                                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
68                                                        return false
69                                                }
70                                               
71                                                // Now find the user data
72                                                JSON.parse("${ConfigurationHolder.config.gscf.baseURL}/rest/getUser?consumer=${ConfigurationHolder.config.metagenomics.consumerID}&token=${session.sessionToken}".toURL().text).each { userProperty ->
73                                                        user["${userProperty.key}"] = "${userProperty.value}"
74                                                }
75                                               
76                                                // Locate user in database or create a new user
77                                                session.user = User.findByIdentifierAndUsername(user.id, user.username)
78                                                if (!session.user){ // when not found, create a new user
79                                                        session.user = new User(identifier: user.id, username: user.username).save(flush: true)
80                                                }                                                       
81                                               
82                                        } catch(Exception e) {
83                                                log.error("Unable to fetch user from GSCF", e)
84                                                throw new Exception( "GSCF instance at " + ConfigurationHolder.config.gscf.baseURL + " could not be reached. Please check configuration.", e )
85                                        }
86                                } else {
87                                        session.sessionToken = "${UUID.randomUUID()}"
88                                        log.info("SessionToken created, redirectiong to GSCF to let the user login! (SessionToken: ${session.sessionToken}")
89
90                                        redirect( url: gscfService.urlAuthRemote(params, session.sessionToken) )
91                                        return false
92                                }
93                        }
94                }
95               
96                fullSynchronization(controller:'*', action:'*') {
97                        before = {
98                                // Never perform full synchronization on rest call when the synchronize controller is used
99                                if( controllerName == "rest" || controllerName == "synchronize" ) {
100                                        return true;
101                                }
102
103                                // Never perform synchronization on a POST request
104                                if( request.method == "POST" )
105                                        return true;
106                                       
107                                if( synchronizationService.timeForFullSynchronization() ) {
108                                        redirect( url: synchronizationService.urlForFullSynchronization( params ) );
109                                        return false
110                                }
111                               
112                                return true
113
114                        }
115                }
116               
117                defineStyle(controller: '*', action: '*') {
118                        // before every execution
119                        before = {
120                                // set the default style in the session
121                                if (!session.style) {
122                                        session.style = 'metagenomics'
123                                }
124
125                                // set session lifetime to 1 week
126                                session.setMaxInactiveInterval(604800)
127                        }
128                }
129        }
130
131}
132
Note: See TracBrowser for help on using the repository browser.