Changeset 1222

Show
Ignore:
Timestamp:
30-11-10 14:10:42 (3 years ago)
Author:
robert@…
Message:

Implemented improved authorisation to give administrators all permissions (ticket #207)

Location:
trunk/grails-app
Files:
7 modified

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/exporter/ExporterController.groovy

    r1220 r1222  
    4545        def c = dbnp.studycapturing.Study.createCriteria() 
    4646 
    47         def studies 
    48         if( user == null ) { 
    49             studies = c.list { 
    50                 maxResults(max) 
    51                 and { 
    52                     eq( "published", true ) 
    53                     eq( "publicstudy", true ) 
    54                 } 
    55             } 
    56         } else { 
    57             studies = c.list { 
    58                 maxResults(max) 
    59                 or { 
    60                     eq( "owner", user ) 
    61                     writers { 
    62                         eq( "id", user.id ) 
    63                     } 
    64                     and { 
    65                         readers { 
    66                             eq( "id", user.id ) 
    67                         } 
    68                         eq( "published", true ) 
    69                     } 
    70                 } 
    71             } 
    72         } 
     47        def studies = Study.giveReadableStudies(user, max); 
    7348        [studyInstanceList: studies, studyInstanceTotal: studies.count()] 
    7449    } 
  • trunk/grails-app/controllers/dbnp/studycapturing/StudyController.groovy

    r1213 r1222  
    33import grails.converters.* 
    44import grails.plugins.springsecurity.Secured 
    5  
    65 
    76/** 
     
    2524        def max = Math.min(params.max ? params.int('max') : 10, 100) 
    2625 
    27         def c = Study.createCriteria() 
    28  
    29         def studies 
    30         if( user == null ) { 
    31             studies = c.list { 
    32                 maxResults(max) 
    33                 and { 
    34                     eq( "published", true ) 
    35                     eq( "publicstudy", true ) 
    36                 } 
    37             } 
    38         } else { 
    39             studies = c.list { 
    40                 maxResults(max) 
    41                 or { 
    42                     eq( "owner", user ) 
    43                     writers { 
    44                         eq( "id", user.id ) 
    45                     } 
    46                     and { 
    47                         readers { 
    48                             eq( "id", user.id ) 
    49                         } 
    50                         eq( "published", true ) 
    51                     } 
    52                 } 
    53             } 
    54         } 
    55          
     26        def studies = Study.giveReadableStudies( user, max ); 
     27 
    5628        [studyInstanceList: studies, studyInstanceTotal: studies.count(), loggedInUser: user] 
    5729    } 
  • trunk/grails-app/controllers/nmc/PilotController.groovy

    r1204 r1222  
    1616 
    1717import dbnp.studycapturing.*; 
     18import grails.plugins.springsecurity.Secured 
     19 
    1820 
    1921class PilotController { 
     
    3739   } 
    3840         
    39     def index = { 
     41    @Secured(['IS_AUTHENTICATED_REMEMBERED']) 
     42        def index = { 
    4043                 
    4144                session.pilot = true 
    42                  
     45 
    4346                def user = authenticationService.getLoggedInUser() 
    4447                def max = Math.min(params.max ? params.int('max') : 10, 100) 
    45  
    46                 def c = Study.createCriteria() 
    47  
    48                 def studies 
    49                 if( user == null ) { 
    50                         //login and return here... 
    51                         redirect(controller:"login", action:"auth") 
    52                         return false 
    53                          
    54                 } else { 
    55                         studies = c.list { 
    56                                 maxResults(max) 
    57                                 or { 
    58                                         eq( "owner", user ) 
    59                                         writers { 
    60                                                 eq( "id", user.id ) 
    61                                         } 
    62                                         and { 
    63                                                 readers { 
    64                                                         eq( "id", user.id ) 
    65                                                 } 
    66                                                 eq( "published", true ) 
    67                                         } 
    68                                 } 
    69                         } 
    70                 } 
     48                def studies = Study.giveReadableStudies(user, max); 
    7149                 
    7250                def studyInstance = new Study() 
  • trunk/grails-app/controllers/RestController.groovy

    r1199 r1222  
    256256                        if(study) { 
    257257                                // Check whether the person is allowed to read the data of this study 
    258                                 /* 
    259258                                if( !study.canRead(AuthenticationService.getRemotelyLoggedInUser( params.consumer, params.token ))) { 
    260259                                        response.sendError(401) 
    261260                                        return false 
    262261                                } 
    263                                 */ 
    264262 
    265263                                def assays = [] 
     
    283281 
    284282                                assays.each{ assay -> 
    285                                         if (assay.module.url.equals(params.consumer )) { 
     283                                        if (assay.module.url.equals(params.consumer)) { 
    286284                                                if(assay) { 
    287285                                                        def map = [:] 
  • trunk/grails-app/domain/dbnp/authentication/SecRole.groovy

    r1159 r1222  
    11package dbnp.authentication 
    22 
    3 class SecRole { 
     3class SecRole implements Serializable { 
    44 
    55        String authority 
  • trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

    r1036 r1222  
    410410        } 
    411411 
     412                // Administrators are allowed to read every study 
     413                if( loggedInUser.hasAdminRights() ) { 
     414                        return true; 
     415                } 
     416 
    412417        // Owners and writers are allowed to read this study 
    413418        if( this.owner == loggedInUser || this.writers.contains(loggedInUser) ) { 
     
    430435            return false; 
    431436        } 
     437 
     438                // Administrators are allowed to write every study 
     439                if( loggedInUser.hasAdminRights() ) { 
     440                        return true; 
     441                } 
     442 
    432443        return this.owner == loggedInUser || this.writers.contains(loggedInUser) 
    433444    } 
     
    443454    } 
    444455 
     456        /** 
     457         * Returns a list of studies that are writable for the given user 
     458         */ 
     459        public static giveWritableStudies(SecUser user, int max) { 
     460                // User that are not logged in, are not allowed to write to a study 
     461                if( user == null ) 
     462                        return []; 
     463                         
     464                def c = Study.createCriteria() 
     465 
     466                // Administrators are allowed to read everything 
     467                if( user.hasAdminRights() ) { 
     468                        return c.list { 
     469                                maxResults(max) 
     470                        } 
     471                } 
     472 
     473                return c.list { 
     474                        maxResults(max) 
     475                        or { 
     476                                eq( "owner", user ) 
     477                                writers { 
     478                                        eq( "id", user.id ) 
     479                                } 
     480                        } 
     481                } 
     482        } 
     483 
     484        /** 
     485         * Returns a list of studies that are readable by the given user 
     486         */ 
     487        public static giveReadableStudies(SecUser user, int max) { 
     488                def c = Study.createCriteria() 
     489 
     490        // Administrators are allowed to read everything 
     491                if( user == null ) { 
     492            return c.list { 
     493                                maxResults(max) 
     494                and { 
     495                    eq( "published", true ) 
     496                    eq( "publicstudy", true ) 
     497                } 
     498            } 
     499        } else if( user.hasAdminRights() ) { 
     500            return c.list { 
     501                                maxResults(max) 
     502                        } 
     503                } else  { 
     504            return c.list { 
     505                                maxResults(max) 
     506                or { 
     507                    eq( "owner", user ) 
     508                    writers { 
     509                        eq( "id", user.id ) 
     510                    } 
     511                    and { 
     512                        readers { 
     513                            eq( "id", user.id ) 
     514                        } 
     515                        eq( "published", true ) 
     516                    } 
     517                } 
     518            } 
     519        } 
     520        } 
    445521} 
  • trunk/grails-app/taglib/dbnp/studycapturing/WizardTagLib.groovy

    r1206 r1222  
    653653         */ 
    654654        def studySelect = { attrs -> 
    655                 // Find all studies the user has access to 
    656                 def user = AuthenticationService.getLoggedInUser() 
    657  
    658                 def c = Study.createCriteria() 
    659                 attrs.from = c.list { 
    660                     or { 
    661                         eq( "owner", user ) 
    662                         writers { 
    663                             eq( "id", user.id ) 
    664                         } 
    665                     } 
    666                 } 
     655                // Find all studies the user has access to (max 100) 
     656                attrs.from = Study.giveWritableStudies(AuthenticationService.getLoggedInUser(), 100); 
    667657 
    668658                // got a name?