Changeset 415

Show
Ignore:
Timestamp:
12-05-10 13:23:35 (4 years ago)
Author:
tabma
Message:

- refactored code and templates of the Importer Wizard, now makes use of indexed formparameters

Location:
trunk/grails-app
Files:
4 modified

Legend:

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

    r359 r415  
    7373    */ 
    7474    def savepreview = { 
    75         def tft = null 
    76         def entities  = request.getParameterValues("entity") 
    77         def templatefieldtypes = request.getParameterValues("templatefieldtype") 
     75        def tft = null   
    7876        def identifiercolumnindex = (params.identifier!=null) ? params.identifier.toInteger() : -1 
    7977 
    80         templatefieldtypes.each { t ->       
    81             def columnindex = t.split(":")[0].toInteger() 
    82             def templatefieldtype = t.split(":")[1] 
    83              
    84             switch (templatefieldtype) { 
     78        params.templatefieldtype.index.each { columnindex, _templatefieldtype -> 
     79            switch (_templatefieldtype) { 
    8580                case "STRING"       : tft = TemplateFieldType.STRING 
    8681                                      break 
     
    10196                default: break 
    10297            } 
    103             session.importer_header[columnindex].templatefieldtype = tft 
     98             
     99            session.importer_header[columnindex.toInteger()].templatefieldtype = tft 
    104100        } 
    105101 
    106         entities.each { e ->                 
    107             def columnindex = e.split(":")[0].toInteger() 
    108             def entitytype = e.split(":")[1].toInteger() 
    109             Class clazz      
     102        params.entity.index.each { columnindex, entitytype -> 
     103            Class clazz 
    110104 
    111             switch (entitytype) { 
     105            switch (entitytype.toInteger()) { 
    112106                case 0: clazz = Study 
    113107                        break 
     
    124118            } 
    125119 
    126             session.importer_header[columnindex].identifier = (columnindex == identifiercolumnindex) ? true : false 
    127             session.importer_header[columnindex].index = columnindex 
    128             session.importer_header[columnindex].entity = clazz 
     120            session.importer_header[columnindex.toInteger()].identifier = (columnindex.toInteger() == identifiercolumnindex) ? true : false 
     121            session.importer_header[columnindex.toInteger()].index = columnindex.toInteger() 
     122            session.importer_header[columnindex.toInteger()].entity = clazz 
    129123        } 
    130124 
     
    134128        def templates = Template.get(session.importer_template_id) 
    135129 
    136         render(view:"step2", model:[entities:entities, header:session.importer_header, templates:templates]) 
     130        render(view:"step2", model:[entities:params.entity, header:session.importer_header, templates:templates]) 
    137131    } 
    138132 
    139133    /** 
    140     * @param columnproperty array of columns and the assigned property in `column:property_id` format 
     134    * @param columnproperty array of columns containing index and property_id 
    141135    * 
    142136    */ 
    143     def saveproperties = { 
    144         def columnproperties  = request.getParameterValues("columnproperty")     
     137    def saveproperties = {       
    145138        session.importer_study = Study.get(params.study.id.toInteger()) 
    146139 
    147         columnproperties.each { cp ->            
    148                 def columnindex = cp.split(":")[0].toInteger() 
    149                 def property_id = cp.split(":")[1].toInteger() 
    150                 session.importer_header[columnindex].property = TemplateField.get(property_id) 
     140        params.columnproperty.index.each { columnindex, property_id -> 
     141                session.importer_header[columnindex.toInteger()].property = TemplateField.get(property_id.toInteger()) 
    151142        } 
    152143 
     
    158149 
    159150    def savepostview = { 
    160         ImporterService.savedata(session.importer_study, session.importer_importeddata) 
     151        ImporterService.saveDatamatrix(session.importer_study, session.importer_importeddata) 
    161152        render(view:"step4") 
    162153    } 
  • trunk/grails-app/domain/dbnp/importer/ImportMapping.groovy

    r359 r415  
    44 
    55        static hasMany = [columns: MappingColumn] 
     6        static String t 
    67 
    78        static constraints = { 
  • trunk/grails-app/services/dbnp/importer/ImporterService.groovy

    r359 r415  
    206206     * @param datamatrix two dimensional array containing entities with values read from Excel file     * 
    207207     */     
    208     def savedata(Study study, datamatrix) { 
     208    def saveDatamatrix(Study study, datamatrix) { 
    209209        study.refresh() 
    210210         
     
    215215                                    persistEntity(entity) 
    216216                                    break 
    217                     case Subject :  print "Persisting Subject `" + entity.name + "`: "                               
    218                                     persistEntity(entity)                                    
     217                    case Subject :  print "Persisting Subject `" + entity.name + "`: " 
     218                                    persistEntity(entity) 
    219219                                    study.addToSubjects(entity) 
    220220                                    break 
     
    234234    /** 
    235235     * Method to persist entities into the database 
     236     * Checks whether entity already exists (based on identifier column 'name') 
    236237     *  
    237238     * @param entity entity object like Study, Subject, Protocol et cetera 
     
    279280                                    event.setFieldValue(mc.property.name, value) 
    280281                                    break 
    281                 case Sample     :   (record.any {it.getClass()==mc.entity}) ? record.add(sample) : 0 
     282                case Sample     :   (record.any {it.getClass()==mc.entity}) ? 0 : record.add(sample) 
    282283                                    if (mc.identifier) { sample.name = value; break } 
    283284                                    sample.setFieldValue(mc.property.name, value) 
  • trunk/grails-app/taglib/dbnp/importer/ImporterTagLib.groovy

    r359 r415  
    5353 
    5454    /** 
    55      * @param entities array in the format of columnindex:entitytype format 
     55     * @param entities array 
    5656     */ 
    5757    def properties = { attrs -> 
     
    5959        def header = attrs['header'] 
    6060 
    61         attrs['entities'].each { se -> 
    62             def temp = se.split(":") 
    63             def entity = [type:temp[1],columnindex:temp[0]] 
     61        attrs['entities'].index.each { columnindex, entitytype -> 
     62            def entity = [type:entitytype,columnindex:columnindex.toInteger()] 
    6463            selectedentities.add(entity) 
    6564        } 
     
    7069    /** 
    7170     * Possibly this will later on return an AJAX-like autocompletion chooser for the fields? 
    72      *  
     71     * 
     72     * @param name name for the property chooser element 
    7373     * @param importtemplate_id template identifier where fields are retrieved from 
    7474     * @param MappingColumn object containing all required information 
     
    8787 
    8888    /** 
     89     * Create the property chooser select element 
     90     * 
    8991     * @param name name of the HTML select object 
    9092     * @param options list of options (fields) to be used 
     
    9496    def createPropertySelect(String name, options, Integer columnIndex) 
    9597    {    
    96         def res = "<select style=\"font-size:10px\" name=\"${name}\">" 
     98        def res = "<select style=\"font-size:10px\" name=\"${name}.index.${columnIndex}\">" 
    9799 
    98100        options.each { f ->          
    99             res += "<option value=\"${columnIndex}:${f.id}\"" 
     101            res += "<option value=\"${f.id}\"" 
    100102            //res += (e.type.toInteger() == selected) ? " selected" : "" 
    101103            res += ">${f}</option>" 
     
    120122        def name = (attrs['name']==null) ? -1 : attrs['name'] 
    121123 
    122         def res = "<select style=\"font-size:10px\" name=\"${name}\">" 
     124        def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">" 
    123125 
    124126        standardentities.each { e -> 
    125             res += "<option value=\"${custval}:${e.type}\"" 
     127            res += "<option value=\"${e.type}\"" 
    126128            res += (e.type == sel) ? " selected" : "" 
    127129            res += ">${e.name}</option>" 
     
    133135 
    134136    /** 
     137     * Create a templatefieldtype selector 
     138     * 
    135139    * @param selected selected TemplateFieldType 
    136140    * @param customvalue custom value to be combined in the option(s) of the selector 
     
    142146    def templatefieldtypeSelect = { attrs -> 
    143147        def selected = (attrs['selected']==null) ? -1 : attrs['selected'] 
    144         def customvalue = (attrs['customvalue']==null) ? "" : attrs['customvalue'] 
     148        def custval = (attrs['customvalue']==null) ? "" : attrs['customvalue'] 
    145149        def name = (attrs['name']==null) ? "" : attrs['name']    
    146150 
    147         def res = "<select style=\"font-size:10px\" name=\"${name}\">" 
     151        def res = "<select style=\"font-size:10px\" name=\"${name}.index.${custval}\">" 
    148152 
    149153        TemplateFieldType.list().each { e -> 
    150             res += "<option value=\"${customvalue}:${e}\"" 
     154            res += "<option value=\"${e}\"" 
    151155            res += (e == selected) ? " selected" : "" 
    152156            res += ">${e}</option>"