Changeset 1603

Show
Ignore:
Timestamp:
08-03-11 17:10:09 (3 years ago)
Author:
work@…
Message:

- importer wizard for studies is instantiating a study from the hidden field (studies) and tried to save it at a later stage (in saveDataMatrix) when it shouldn't. Added a check to only save the study when importing other entities (subject, sample, etc) and not when importing studies.

Location:
trunk/grails-app
Files:
2 modified

Legend:

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

    r1599 r1603  
    106106                                flow.page = 1 
    107107                                flow.studies = Study.findAllWhere(owner: authenticationService.getLoggedInUser()) 
    108                 flow.importer_fuzzymatching="false" 
    109  
    110                                 success() 
    111                         } 
    112  
    113             on("refresh") {                 
    114  
    115                 if (params.entity) { 
    116                     flash.importer_datatemplates = Template.findAllByEntity(gdtService.getInstanceByEntity(params.entity.decodeURL())) 
    117                 } 
    118                  
    119                 flash.importer_params = params                 
    120  
    121                 // If the file already exists an "existing*" string is added, but we don't 
    122                 // want that after a refresh of the first step in the import wizard, so remove 
    123                 // that string 
    124                 flash.importer_params.importfile = params.importfile.replace('existing*', '') 
     108                                flow.importer_fuzzymatching = "false" 
     109 
     110                                success() 
     111                        } 
     112 
     113                        on("refresh") { 
     114 
     115                                if (params.entity) { 
     116                                        flash.importer_datatemplates = Template.findAllByEntity(gdtService.getInstanceByEntity(params.entity.decodeURL())) 
     117                                } 
     118 
     119                                flash.importer_params = params 
     120 
     121                                // If the file already exists an "existing*" string is added, but we don't 
     122                                // want that after a refresh of the first step in the import wizard, so remove 
     123                                // that string 
     124                                flash.importer_params.importfile = params.importfile.replace('existing*', '') 
    125125 
    126126                                success() 
     
    129129                        on("next") { 
    130130                                flash.wizardErrors = [:] 
    131                 flash.importer_params = params 
    132                 flash.importer_params.importfile = params.importfile.replace('existing*', '') 
    133  
    134                 if (params.entity) { 
    135                     flash.importer_datatemplates = Template.findAllByEntity(gdtService.getInstanceByEntity(params.entity.decodeURL())) 
    136                 } 
     131                                flash.importer_params = params 
     132                                flash.importer_params.importfile = params.importfile.replace('existing*', '') 
     133 
     134                                if (params.entity) { 
     135                                        flash.importer_datatemplates = Template.findAllByEntity(gdtService.getInstanceByEntity(params.entity.decodeURL())) 
     136                                        def importer_entity_type = gdtService.decryptEntity(params.entity.decodeURL()).toString().split(/\./) 
     137                                        flow.importer_entity_type = importer_entity_type[importer_entity_type.size()-1] 
     138                                } 
    137139 
    138140                                // Study selected? 
     
    141143                                // Trying to import data into an existing study? 
    142144                                if (flow.importer_study) 
    143                                         if (flow.importer_study.canWrite(authenticationService.getLoggedInUser()))  
    144                                                 fileImportPage(flow, flash, params) ? success() : error()                                        
     145                                        if (flow.importer_study.canWrite(authenticationService.getLoggedInUser())) 
     146                                                fileImportPage(flow, flash, params) ? success() : error() 
    145147                                        else { 
    146148                                                log.error ".importer wizard wrong permissions" 
     
    161163                        onRender { 
    162164                                log.info ".import wizard properties page" 
    163                  
    164                 def template = Template.get(flow.importer_template_id) 
     165 
     166                                def template = Template.get(flow.importer_template_id) 
    165167 
    166168                                // Grom a development message 
    167169                                if (pluginManager.getGrailsPlugin('grom')) ".rendering the partial: pages/_page_two.gsp".grom() 
    168170 
    169                 flow.importer_importmappings = ImportMapping.findAllByTemplate(template) 
     171                                flow.importer_importmappings = ImportMapping.findAllByTemplate(template) 
    170172 
    171173                                flow.page = 2 
    172174                                success() 
    173175                        } 
    174             on("refresh") { 
    175                 def template = Template.get(flow.importer_template_id) 
    176                 flow.importer_importmappings = ImportMapping.findAllByTemplate(template) 
    177  
    178                 // a name was given to the current property mapping, try to store it 
    179                 if (params.mappingname) { 
    180                     flash.importer_columnproperty = params.columnproperty 
    181                     propertiesSaveImportMappingPage(flow, flash, params)                     
    182                 } else // trying to load an existing import mapping 
    183                 if (params.importmapping_id) { 
    184                     propertiesLoadImportMappingPage(flow, flash, params) 
    185                 } 
    186                  
    187                 if (params.fuzzymatching == "true") 
    188                     flow.importer_fuzzymatching="true" else 
    189                     flow.importer_fuzzymatching="false" 
    190  
    191                 success() 
     176                        on("refresh") { 
     177                                def template = Template.get(flow.importer_template_id) 
     178                                flow.importer_importmappings = ImportMapping.findAllByTemplate(template) 
     179 
     180                                // a name was given to the current property mapping, try to store it 
     181                                if (params.mappingname) { 
     182                                        flash.importer_columnproperty = params.columnproperty 
     183                                        propertiesSaveImportMappingPage(flow, flash, params) 
     184                                } else // trying to load an existing import mapping 
     185                                if (params.importmapping_id) { 
     186                                        propertiesLoadImportMappingPage(flow, flash, params) 
     187                                } 
     188 
     189                                if (params.fuzzymatching == "true") 
     190                                        flow.importer_fuzzymatching = "true" else 
     191                                        flow.importer_fuzzymatching = "false" 
     192 
     193                                success() 
    192194                        }.to "pageTwo" 
    193195 
    194196                        on("next") { 
    195                 flow.importer_fuzzymatching="false" 
    196                                 if (propertiesPage(flow, flash, params)) {                     
     197                                flow.importer_fuzzymatching = "false" 
     198                                if (propertiesPage(flow, flash, params)) { 
    197199                                        success() 
    198200                                } else { 
     
    260262                                // Grom a development message 
    261263                                if (pluginManager.getGrailsPlugin('grom')) ".persisting instances to the database...".grom() 
    262                  
    263                 // Always delete the uploaded file in the save step to be sure it doesn't reside there anymore 
    264                 fileService.delete(flow.importer_importedfile) 
     264 
     265                                // Always delete the uploaded file in the save step to be sure it doesn't reside there anymore 
     266                                fileService.delete(flow.importer_importedfile) 
    265267 
    266268                                // Save all entities 
    267                 if (saveEntities(flow, params)) {                                                                              
     269                                if (saveEntities(flow, params)) { 
    268270                                        success() 
    269271                                } else { 
     
    308310        } 
    309311 
    310     def propertiesManager = { 
    311         render (view:"common/_propertiesManager") 
    312     } 
     312        def propertiesManager = { 
     313                render(view: "common/_propertiesManager") 
     314        } 
    313315 
    314316        /** 
     
    321323                // fetch all templates for a specific entity 
    322324                def templates = Template.findAllByEntity(gdtService.getInstanceByEntity(params.entity.decodeURL())) 
    323  
    324325 
    325326                // render as JSON 
     
    334335         * @returns boolean true if correctly validated, otherwise false 
    335336         */ 
    336         boolean fileImportPage(flow, flash, params) {         
     337        boolean fileImportPage(flow, flash, params) { 
    337338                def importedfile = fileService.get(params['importfile']) 
    338         flow.importer_importedfile = params['importfile']                
    339  
    340         if (importedfile.exists()) { 
    341             try { 
    342                 session.importer_workbook = importerService.getWorkbook(new FileInputStream(importedfile)) 
    343             } catch (Exception e) { 
    344                 log.error ".importer wizard could not load file: " + e 
    345                 this.appendErrorMap(['error': "Wrong file (format), the importer requires an Excel file as input"], flash.wizardErrors) 
    346                 return false 
    347             } 
    348         } 
    349  
    350                 if (params.entity && params.template_id) {             
    351                          
    352             try { 
    353                 session.importer_workbook = importerService.getWorkbook(new FileInputStream(importedfile)) 
    354             } catch (Exception e) { 
    355                 log.error ".importer wizard could not load file: " + e 
    356                 this.appendErrorMap(['error': "Excel file required as input"], flash.wizardErrors) 
    357                 return false 
    358             } 
     339                flow.importer_importedfile = params['importfile'] 
     340 
     341                if (importedfile.exists()) { 
     342                        try { 
     343                                session.importer_workbook = importerService.getWorkbook(new FileInputStream(importedfile)) 
     344                        } catch (Exception e) { 
     345                                log.error ".importer wizard could not load file: " + e 
     346                                this.appendErrorMap(['error': "Wrong file (format), the importer requires an Excel file as input"], flash.wizardErrors) 
     347                                return false 
     348                        } 
     349                } 
     350 
     351                if (params.entity && params.template_id) { 
     352 
     353                        try { 
     354                                session.importer_workbook = importerService.getWorkbook(new FileInputStream(importedfile)) 
     355                        } catch (Exception e) { 
     356                                log.error ".importer wizard could not load file: " + e 
     357                                this.appendErrorMap(['error': "Excel file required as input"], flash.wizardErrors) 
     358                                return false 
     359                        } 
    359360 
    360361                        def selectedentities = [] 
     
    370371                        flow.importer_datamatrix_start = params.datamatrix_start.toInteger() - 1 // 0 == first row 
    371372                        flow.importer_headerrow = params.headerrow.toInteger() 
    372             flow.importer_entityclass = entityClass 
    373             flow.importer_entity = gdtService.cachedEntities.find{ it.entity==entityName } 
    374           
     373                        flow.importer_entityclass = entityClass 
     374                        flow.importer_entity = gdtService.cachedEntities.find { it.entity == entityName } 
     375 
    375376                        // Get the header from the Excel file using the arguments given in the first step of the wizard 
    376377                        flow.importer_header = importerService.getHeader(session.importer_workbook, 
     
    393394 
    394395 
    395         log.error ".importer wizard not all fields are filled in" 
    396         this.appendErrorMap(['error': "Not all fields are filled in, please fill in or select all fields"], flash.wizardErrors) 
    397         return false 
    398         } 
    399  
    400     /** 
    401     * Load an existing import mapping 
    402     * 
    403     * @param Map LocalAttributeMap (the flow scope) 
     396                log.error ".importer wizard not all fields are filled in" 
     397                this.appendErrorMap(['error': "Not all fields are filled in, please fill in or select all fields"], flash.wizardErrors) 
     398                return false 
     399        } 
     400 
     401        /** 
     402        * Load an existing import mapping 
     403        * 
     404        * @param Map LocalAttributeMap (the flow scope) 
    404405         * @param Map GrailsParameterMap (the flow parameters = form data) 
    405406         * @returns boolean true if correctly validated, otherwise false 
    406407         */ 
    407     boolean propertiesLoadImportMappingPage(flow, flash, params) { 
    408         def im = ImportMapping.get(params.importmapping_id.toInteger()) 
    409         im.refresh() 
    410  
    411         im.mappingcolumns.each { mappingcolumn -> 
    412             //def mc = new MappingColumn() 
    413             //mc.properties = mappingcolumn.properties 
    414  
    415             flow.importer_header[mappingcolumn.index.toInteger()] = mappingcolumn             
    416         } 
    417     } 
    418  
    419     /** 
    420     * Save the properties as an import mapping. 
    421     * 
    422     * @param Map LocalAttributeMap (the flow scope) 
     408        boolean propertiesLoadImportMappingPage(flow, flash, params) { 
     409                def im = ImportMapping.get(params.importmapping_id.toInteger()) 
     410                im.refresh() 
     411 
     412                im.mappingcolumns.each { mappingcolumn -> 
     413                        //def mc = new MappingColumn() 
     414                        //mc.properties = mappingcolumn.properties 
     415 
     416                        flow.importer_header[mappingcolumn.index.toInteger()] = mappingcolumn 
     417                } 
     418        } 
     419 
     420        /** 
     421        * Save the properties as an import mapping. 
     422        * 
     423        * @param Map LocalAttributeMap (the flow scope) 
    423424         * @param Map GrailsParameterMap (the flow parameters = form data) 
    424425         * @returns boolean true if correctly validated, otherwise false 
    425426         */ 
    426     boolean propertiesSaveImportMappingPage(flow, flash, params) { 
    427         flash.wizardErrors = [:] 
    428         def isPreferredIdentifier = false 
     427        boolean propertiesSaveImportMappingPage(flow, flash, params) { 
     428                flash.wizardErrors = [:] 
     429                def isPreferredIdentifier = false 
    429430 
    430431                // Find actual Template object from the chosen template name 
    431432                def template = Template.get(flow.importer_template_id) 
    432          
    433         // Create new ImportMapping instance and persist it 
    434         def im = new ImportMapping(name:params.mappingname, entity: flow.importer_entityclass, template:template).save()         
     433 
     434                // Create new ImportMapping instance and persist it 
     435                def im = new ImportMapping(name: params.mappingname, entity: flow.importer_entityclass, template: template).save() 
    435436 
    436437                params.columnproperty.index.each { columnindex, property -> 
     
    438439                        // This should be inside the closure because in some cases in the advanced importer, the fields can have different target entities                       
    439440                        //def entityClass = gdtService.getInstanceByEntityName(flow.importer_header[columnindex.toInteger()].entity.getName()) 
    440             def entityObj = flow.importer_entityclass.newInstance(template:template) 
    441  
    442             def dontimport = (property == "dontimport") ? true : false 
    443  
    444             // Loop through all fields and find the preferred identifier 
    445             entityObj.giveFields().each {                 
     441                        def entityObj = flow.importer_entityclass.newInstance(template: template) 
     442 
     443                        def dontimport = (property == "dontimport") ? true : false 
     444 
     445                        // Loop through all fields and find the preferred identifier 
     446                        entityObj.giveFields().each { 
    446447                                isPreferredIdentifier = (it.preferredIdentifier && (it.name == property)) ? true : false 
    447448                        } 
    448449 
    449             // Create new MappingColumn instance 
    450             def mc = new MappingColumn (importmapping:im, 
    451                                         name: flow.importer_header[columnindex.toInteger()].name, 
    452                                         property:property, 
    453                                         index:columnindex, 
    454                                         entityclass:flow.importer_entityclass, 
    455                                         templatefieldtype:entityObj.giveFieldType(property), 
    456                                         dontimport: dontimport, 
    457                                         identifier:isPreferredIdentifier) 
    458  
    459             // Save mappingcolumn 
    460             if (mc.validate()) { 
    461                 im.addToMappingcolumns(mc)                 
    462             } 
    463             else { 
    464                 mc.errors.allErrors.each { 
    465                     println it 
    466                 } 
    467             } 
    468  
    469             // Save importmapping 
    470             if (im.validate()) { 
    471                 try { 
    472                     im.save(flush:true) 
    473                 } catch (Exception e) { 
    474                     //getNextException 
    475                     log.error "importer wizard save importmapping error: " + e 
    476                 } 
    477             } 
    478             else { 
    479                 im.errors.allErrors.each { 
    480                     println it 
    481                 } 
    482             } 
    483              
    484                 } 
    485     } 
    486  
    487         /** 
     450                        // Create new MappingColumn instance 
     451                        def mc = new MappingColumn(importmapping: im, 
     452                                name: flow.importer_header[columnindex.toInteger()].name, 
     453                                property: property, 
     454                                index: columnindex, 
     455                                entityclass: flow.importer_entityclass, 
     456                                templatefieldtype: entityObj.giveFieldType(property), 
     457                                dontimport: dontimport, 
     458                                identifier: isPreferredIdentifier) 
     459 
     460                        // Save mappingcolumn 
     461                        if (mc.validate()) { 
     462                                im.addToMappingcolumns(mc) 
     463                        } 
     464                        else { 
     465                                mc.errors.allErrors.each { 
     466                                        println it 
     467                                } 
     468                        } 
     469 
     470                        // Save importmapping 
     471                        if (im.validate()) { 
     472                                try { 
     473                                        im.save(flush: true) 
     474                                } catch (Exception e) { 
     475                                        //getNextException 
     476                                        log.error "importer wizard save importmapping error: " + e 
     477                                } 
     478                        } 
     479                        else { 
     480                                im.errors.allErrors.each { 
     481                                        println it 
     482                                } 
     483                        } 
     484 
     485                } 
     486        } 
     487 
     488        /** 
    488489         * Handle the property mapping page. 
    489490         * 
     
    493494         */ 
    494495        boolean propertiesPage(flow, flash, params) { 
    495         flash.wizardErrors = [:] 
    496          
     496                flash.wizardErrors = [:] 
     497 
    497498                // Find actual Template object from the chosen template name 
    498499                def template = Template.get(flow.importer_template_id) 
     
    528529                flow.importer_importeddata = table 
    529530 
    530         // loop through all entities to validate them and add them to wizardErrors flash when invalid 
    531         /*table.each { record -> 
    532             record.each { entity -> 
    533                 if (!entity.validate()) { 
    534                                 this.appendErrors(entity, flash.wizardErrors, 'entity_' + entity.getIdentifier() + '_') 
    535                 } 
    536             } 
    537         }*/ 
    538  
    539         flow.importer_failedcells = failedcells 
     531                // loop through all entities to validate them and add them to wizardErrors flash when invalid 
     532                /*table.each { record -> 
     533                                        record.each { entity -> 
     534                                                if (!entity.validate()) { 
     535                                                this.appendErrors(entity, flash.wizardErrors, 'entity_' + entity.getIdentifier() + '_') 
     536                                                } 
     537                                        } 
     538                                }*/ 
     539 
     540                flow.importer_failedcells = failedcells 
    540541 
    541542                return true 
     
    560561                                entity.giveFields().each { field -> 
    561562 
    562                     // field is a date field, try to set it with the value, if someone enters a non-date value it throws 
    563                     // an error, this should be caught to prevent a complete breakdown 
    564                     if (field.type == org.dbnp.gdt.TemplateFieldType.DATE) { 
    565                         try { 
    566                             entity.setFieldValue(field.toString(), params["entity_" + entity.getIdentifier() + "_" + field.escapedName()]) 
    567                         } catch (Exception e)   { log.error ".importer wizard could not set date field with value: " + 
    568                                                     params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] 
    569                                                 } 
    570                     } else 
     563                                        // field is a date field, try to set it with the value, if someone enters a non-date value it throws 
     564                                        // an error, this should be caught to prevent a complete breakdown 
     565                                        if (field.type == org.dbnp.gdt.TemplateFieldType.DATE) { 
     566                                                try { 
     567                                                        entity.setFieldValue(field.toString(), params["entity_" + entity.getIdentifier() + "_" + field.escapedName()]) 
     568                                                } catch (Exception e) { 
     569                                                        log.error ".importer wizard could not set date field with value: " + 
     570                                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] 
     571                                                } 
     572                                        } else 
    571573 
    572574                                        // field of type ontology and value "#invalidterm"? 
     
    578580                                        if (field.type == org.dbnp.gdt.TemplateFieldType.ONTOLOGYTERM && 
    579581                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] != "#invalidterm") { 
    580                                                 if (entity) removeFailedCell(flow.importer_failedcells, entity, field)                        
     582                                                if (entity) removeFailedCell(flow.importer_failedcells, entity, field) 
    581583                                                entity.setFieldValue(field.toString(), params["entity_" + entity.getIdentifier() + "_" + field.escapedName()]) 
    582584                                        } 
    583585                                        else 
    584586 
    585                     if (field.type == org.dbnp.gdt.TemplateFieldType.STRINGLIST && 
     587                                        if (field.type == org.dbnp.gdt.TemplateFieldType.STRINGLIST && 
    586588                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] != "#invalidterm") { 
    587                                                 if (entity) removeFailedCell(flow.importer_failedcells, entity, field)                         
     589                                                if (entity) removeFailedCell(flow.importer_failedcells, entity, field) 
    588590                                                entity.setFieldValue(field.toString(), params["entity_" + entity.getIdentifier() + "_" + field.escapedName()]) 
    589                     } else 
    590                     if (field.type == org.dbnp.gdt.TemplateFieldType.STRINGLIST && 
     591                                        } else 
     592                                        if (field.type == org.dbnp.gdt.TemplateFieldType.STRINGLIST && 
    591593                                                params["entity_" + entity.getIdentifier() + "_" + field.escapedName()] == "#invalidterm" 
    592594                                        ) { 
     
    628630        def removeFailedCell(failedcells, entity, field) { 
    629631                // Valid entity, remove it from failedcells 
    630         def entityidfield = "entity_" + entity.getIdentifier() + "_" + field.name.toLowerCase() 
     632                def entityidfield = "entity_" + entity.getIdentifier() + "_" + field.name.toLowerCase() 
    631633 
    632634                failedcells.each { record -> 
     
    634636 
    635637 
    636                         record.importcells.each { cell ->                
     638                        record.importcells.each { cell -> 
    637639                                // remove the cell from the failed cells session 
    638640                                if (cell.entityidentifier != entityidfield) { 
     
    661663                //def (validatedSuccesfully, updatedEntities, failedToPersist) = 
    662664                try { 
    663                         importerService.saveDatamatrix(flow.importer_study, flow.importer_importeddata, authenticationService, log) 
     665                        importerService.saveDatamatrix(flow.importer_study, flow.importer_entity_type, flow.importer_importeddata, authenticationService, log) 
    664666                } catch (Exception e) { 
    665667                        log.error ".import wizard saveEntities error\n" + e.dump() 
  • trunk/grails-app/services/dbnp/importer/ImporterService.groovy

    r1600 r1603  
    727727         * @param datamatrix two dimensional array containing entities with values read from Excel file 
    728728         */ 
    729         static saveDatamatrix(Study study, datamatrix, authenticationService, log) { 
     729        static saveDatamatrix(Study study, importerEntityType, datamatrix, authenticationService, log) { 
    730730                def validatedSuccesfully = 0 
    731731                def entitystored = null 
    732732 
    733733                // Study passed? Sync data 
    734                 if (study != null) study.refresh() 
     734                if (study != null && importerEntityType != 'Study') study.refresh() 
    735735 
    736736                // go through the data matrix, read every record and validate the entity and try to persist it 
     
    741741                                                entity.owner = authenticationService.getLoggedInUser() 
    742742 
    743                                                 if (study.validate()) { 
     743                                                if (entity.validate()) { 
    744744                                                        if (!entity.save(flush:true)) { 
    745745                                                                log.error ".importer wizard, study could not be saved: " + entity 
     
    747747                                                        } 
    748748                                                } else { 
    749 println "---" 
    750 study.errors.getAllErrors().each { 
    751         println it.dump() 
    752 } 
    753 println "---//" 
    754749                                                        log.error ".importer wizard, study could not be validated: " + entity 
    755750                                                        throw new Exception('.importer wizard, study could not be validated: ' + entity) 
     
    787782 
    788783                // validate study 
    789                 if (study.validate()) { 
    790                         if (!study.save(flush: true)) { 
    791                                 //this.appendErrors(flow.study, flash.wizardErrors) 
    792                                 throw new Exception('.importer wizard [saveDatamatrix] error while saving study') 
     784                if (importerEntityType != 'Study') { 
     785                        if (study.validate()) { 
     786                                if (!study.save(flush: true)) { 
     787                                        //this.appendErrors(flow.study, flash.wizardErrors) 
     788                                        throw new Exception('.importer wizard [saveDatamatrix] error while saving study') 
     789                                } 
     790                        } else { 
     791                                throw new Exception('.importer wizard [saveDatamatrix] study does not validate') 
    793792                        } 
    794                 } else { 
    795                         throw new Exception('.importer wizard [saveDatamatrix] study does not validate') 
    796793                } 
    797794