Changeset 415


Ignore:
Timestamp:
May 12, 2010, 1:23:35 PM (7 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 edited

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