Changeset 1358

Show
Ignore:
Timestamp:
11-01-11 12:46:56 (3 years ago)
Author:
t.w.abma@…
Message:

- fixed study.id error when logged in as new user and trying to import a new study

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/importer/ImporterController.groovy

    r1332 r1358  
    1010import grails.converters.JSON 
    1111import cr.co.arquetipos.crypto.Blowfish 
     12 
     13import org.codehaus.groovy.grails.plugins.web.taglib.ValidationTagLib 
    1214 
    1315/** 
     
    3133    def fileService 
    3234    def ImporterService 
     35    def validationTagLib = new ValidationTagLib() 
    3336         
    3437    /** 
     
    121124            } 
    122125            on("next") { 
    123                 if (fileImportPage(flow, params)) {                     
    124                     success() 
    125                 } else { 
    126                     println "field is missing" 
    127                     error() 
    128                 } 
     126                // Study selected? 
     127                flow.importer_study = (params.study) ? Study.get(params.study.id.toInteger()) : null 
     128 
     129                // Trying to import a new study? 
     130                if (flow.importer_study) 
     131                    if (flow.importer_study.canWrite(AuthenticationService.getLoggedInUser())) { 
     132                        if (fileImportPage(flow, params)) { 
     133                            success() 
     134                        } else { 
     135                            error.log ".importer wizard not all fields are filled in" 
     136                            error() 
     137                        } 
     138                    } else 
     139                    { 
     140                        error.log ".importer wizard wrong permissions" 
     141                    } 
     142                else { 
     143                   if (fileImportPage(flow, params)) { 
     144                            success() 
     145                        } else { 
     146                            error.log ".importer wizard not all fields are filled in" 
     147                            error() 
     148                        } 
     149                } 
     150 
     151 
     152                 
    129153                // put your bussiness logic (if applicable) in here 
    130154            }.to "pageTwo" 
     
    156180            } 
    157181            on("next") { 
    158                 if (propertiesPage(flow, params)) { 
    159                     println "HIER" 
     182                if (propertiesPage(flow, params)) {                     
    160183                    success() 
    161184                } else { 
     
    188211            }.to "pageThree" 
    189212            on("next") { 
    190                 if (mappingsPage(flow, params)) { 
     213                if (mappingsPage(flow, flash, params)) { 
    191214                    success() 
    192215                } else { 
    193                     log.error ".import wizard mapping error, could not validate all entities" 
    194                     error()                     
     216                    log.error ".import wizard mapping error, could not validate all entities"                     
     217                    error()                   
    195218                } 
    196219            }.to "pageFour" 
     
    242265                    if (pluginManager.getGrailsPlugin('grom')) ".persisting instances to the database...".grom()                     
    243266 
    244                     if (saveEntities(flow, params)) { 
    245                         println "succes" 
     267                    if (saveEntities(flow, params)) {                         
    246268                        success() 
    247269                    } else { 
     
    263285        // render errors 
    264286        error { 
     287            //println "error?" 
    265288            render(view: "_error") 
    266289            onRender { 
     
    342365             
    343366            // Initialize some session variables 
    344             //flow.importer_workbook = wb // workbook object must be serialized for this to work 
    345             flow.importer_study = Study.get(params.study.id.toInteger())             
    346  
    347              // Is the current logged in user allowed to write to this study? 
    348              if (flow.importer_study.canWrite(AuthenticationService.getLoggedInUser())) { 
     367            //flow.importer_workbook = wb // workbook object must be serialized for this to work             
     368              
    349369                flow.importer_template_id = params.template_id 
    350370                flow.importer_sheetindex = params.sheetindex.toInteger() -1 // 0 == first sheet 
     
    373393               
    374394                flow.importer_templates = Template.get(flow.importer_template_id) 
    375                 flow.importer_allfieldtypes = "true" 
    376             } // end of if 
     395                flow.importer_allfieldtypes = "true"      
    377396            /*else { 
    378397                render (template:"common/error", 
     
    435454     * @returns boolean true if correctly validated, otherwise false 
    436455     */ 
    437     boolean mappingsPage(flow,params) {         
     456    boolean mappingsPage(flow, flash, params) { 
     457        flash.wizardErrors = [:] 
    438458        flow.importer_invalidentities = 0         
    439459 
     
    461481                if (!entity.validate() || invalidontologies) { 
    462482                    flow.importer_invalidentities++ 
     483 
     484                    // add errors to map 
     485                    this.appendErrors(entity, flash.wizardErrors, 'subject_' + entity.getIdentifier() + '_')                     
    463486                     
    464487                                        entity.errors.getAllErrors().each() { 
     
    505528            return true 
    506529    } 
     530 
     531    /** 
     532         * append errors of a particular object to a map 
     533         * @param object 
     534         * @param map linkedHashMap 
     535         * @void 
     536         */ 
     537        def appendErrors(object, map) { 
     538                this.appendErrorMap(getHumanReadableErrors(object), map) 
     539        } 
     540 
     541        def appendErrors(object, map, prepend) { 
     542                this.appendErrorMap(getHumanReadableErrors(object), map, prepend) 
     543        } 
     544 
     545    /** 
     546         * append errors of one map to another map 
     547         * @param map linkedHashMap 
     548         * @param map linkedHashMap 
     549         * @void 
     550         */ 
     551        def appendErrorMap(map, mapToExtend) { 
     552                map.each() {key, value -> 
     553                        mapToExtend[key] = ['key': key, 'value': value, 'dynamic': false] 
     554                } 
     555        } 
     556 
     557        def appendErrorMap(map, mapToExtend, prepend) { 
     558                map.each() {key, value -> 
     559                        mapToExtend[prepend + key] = ['key': key, 'value': value, 'dynamic': true] 
     560                } 
     561        } 
     562 
     563    /** 
     564         * transform domain class validation errors into a human readable 
     565         * linked hash map 
     566         * @param object validated domain class 
     567         * @return object  linkedHashMap 
     568         */ 
     569        def getHumanReadableErrors(object) { 
     570                def errors = [:] 
     571                object.errors.getAllErrors().each() { error -> 
     572                        // error.codes.each() { code -> println code } 
     573 
     574                        // generally speaking g.message(...) should work, 
     575                        // however it fails in some steps of the wizard 
     576                        // (add event, add assay, etc) so g is not always 
     577                        // availably. Using our own instance of the 
     578                        // validationTagLib instead so it is always 
     579                        // available to us 
     580                        errors[ error.getArguments()[0] ] = validationTagLib.message(error: error) 
     581                } 
     582 
     583                return errors 
     584        } 
    507585}