Changeset 1603


Ignore:
Timestamp:
Mar 8, 2011, 5:10:09 PM (6 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 edited

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
Note: See TracChangeset for help on using the changeset viewer.