Ignore:
Timestamp:
Apr 6, 2011, 4:40:13 PM (12 years ago)
Author:
s.h.sikkema@…
Message:

new gdtImporter; new jumpbar; excel export to webflow; fixed spelling errors on home page; added menu entry for new gdtImporter

Location:
trunk
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk

    • Property svn:ignore
      •  

        old new  
         1.classpath
         2.project
         3.idea
        14*.iml
        2 .classpath
        3 *.log
        4 .idea
        5 .project
        65target
        76{}
        87[:]
        9 .settings
        108.skip-studies
        119out
        12 dtd
         10.settings
         11*.log
  • trunk/grails-app/controllers/dbnp/studycapturing/AssayController.groovy

    r1659 r1716  
    119119    }
    120120
    121     /**
    122      * Shows a page where an assay from a study can be selected
    123      *
    124      * @param none
    125      */
    126     def selectAssay = {
    127         def user = authenticationService.getLoggedInUser()
    128         def studies = Study.findAllByOwner(user)
    129         def assays = Assay.findAllByParent(studies[0])
    130 
    131         [userStudies: studies, assays: assays]
    132     }
    133 
    134     /**
    135      * Shows a page where individual fields for the different categories (ie.
    136      * subject data, sampling events... etc.) can be selected for export
    137      *
    138      * @param params.id Assay id
    139      */
    140     def selectFields = {
    141         // receives an assay id
    142         def assayId = params.assayId
    143 
    144         // did the assay id value come across?
    145         if (!assayId) {
    146             flash.errorMessage = "An error occurred: assayId = ${assayId}."
    147             redirect action: 'selectAssay'
    148             return
    149         }
    150 
    151         Assay assay = Assay.get(assayId)
    152 
    153         // check if assay exists
    154         if (!assay) {
    155 
    156             flash.errorMessage = "No assay found with id: ${assayId}"
    157             redirect action: 'selectAssay'
    158             return
    159         }
    160 
    161         // obtain fields for each category
    162                 def fieldMap
    163         try {
    164             fieldMap = assayService.collectAssayTemplateFields(assay)
    165         } catch (Exception e) {
    166                         e.printStackTrace();
    167             flash.errorMessage = e.message
    168             redirect action: 'selectAssay'
    169                         return
    170 
    171         }
    172         def measurementTokens = fieldMap.remove('Module Measurement Data')
    173 
    174         flash.fieldMap = fieldMap
    175         flash.measurementTokens = measurementTokens
    176         flash.assayId = assayId
    177 
    178         // remove me
    179         println '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$'
    180         println flash
    181         println '$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$'
    182 
    183         [fieldMap: fieldMap, measurementTokens: measurementTokens.name]
    184     }
    185 
    186     /**
    187      * Exports all assay information as an Excel file.
    188      *
    189      * @param params.id Assay id
    190      */
    191     def compileExportData = {
    192 
    193         def fieldMap = flash.fieldMap
    194         def assayId = flash.assayId
    195 
    196         // remove me
    197         println '##############################################################'
    198         println flash
    199         println '##############################################################'
    200 
    201         // did the assay id value come across?
    202         if (!assayId) {
    203             flash.errorMessage = "An error occurred: assayId = ${assayId}."
    204             redirect action: 'selectAssay'
    205             return
    206         }
    207 
    208         Assay assay = Assay.get(assayId)
    209 
    210         // check if assay exists
    211         if (!assay) {
    212 
    213             flash.errorMessage = "No assay found with id: ${assayId}"
    214             redirect action: 'selectAssay'
    215             return
    216         }
    217 
    218         def fieldMapSelection = [:]
    219 
    220         fieldMap.eachWithIndex { cat, cat_i ->
    221 
    222             if (params."cat_$cat_i" == 'on') {
    223                 fieldMapSelection[cat.key] = []
    224 
    225                 cat.value.eachWithIndex { field, field_i ->
    226 
    227                     if (params."cat_${cat_i}_${field_i}" == 'on') {
    228 
    229                         fieldMapSelection[cat.key] += field
    230 
     121    def excelExportFlow = {
     122        entry {
     123            action{
     124                def user            = authenticationService.getLoggedInUser()
     125                flow.userStudies    = Study.findAllByOwner(user)
     126            }
     127            on("success").to "selectAssay"
     128        }
     129
     130        selectAssay {
     131            on ("submit"){
     132                flow.assay = Assay.get(params.assayId)
     133
     134                // check if assay exists
     135                if (!flow.assay) throw new Exception("No assay found with id: ${flow.assay.id}")
     136
     137                // obtain fields for each category
     138                flow.fieldMap = assayService.collectAssayTemplateFields(flow.assay)
     139
     140                flow.measurementTokens = flow.fieldMap.remove('Module Measurement Data')*.name
     141            }.to "selectFields"
     142
     143            on(Exception).to "handleError"
     144        }
     145
     146        selectFields {
     147            on ("submit"){
     148                def fieldMapSelection = [:]
     149
     150                flow.fieldMap.eachWithIndex { cat, cat_i ->
     151
     152                    if (params."cat_$cat_i" == 'on') {
     153                        fieldMapSelection[cat.key] = []
     154
     155                        cat.value.eachWithIndex { field, field_i ->
     156
     157                            if (params."cat_${cat_i}_${field_i}" == 'on')
     158                                fieldMapSelection[cat.key] += field
     159                        }
     160
     161                        if (fieldMapSelection[cat.key] == [])
     162                            fieldMapSelection.remove(cat.key)
    231163                    }
    232 
    233164                }
    234165
    235                 if (fieldMapSelection[cat.key] == []) fieldMapSelection.remove(cat.key)
    236 
    237             }
    238 
    239         }
    240 
    241         def measurementTokensSelection = []
    242 
    243         if (params."cat_4" == 'on') {
    244 
    245             def measurementToken = params.measurementToken
    246 
    247             if (measurementToken) {
    248 
    249                 if (measurementToken instanceof String)
    250                     measurementTokensSelection = [[name: measurementToken]]
    251                 else
    252                     measurementTokensSelection = measurementToken.collect{[name: it]}
    253 
    254             }
    255 
    256         }
    257 
    258         try {
    259 
    260             def assayData = assayService.collectAssayData(assay, fieldMapSelection, measurementTokensSelection)
    261 
    262             def rowData = assayService.convertColumnToRowStructure(assayData)
    263 
    264             flash.rowData = rowData
    265 
    266             def assayDataPreview = rowData[0..4].collect{it[0..4]}
    267 
    268             [assayDataPreview: assayDataPreview]
    269 
    270         } catch (Exception e) {
    271 
    272             flash.errorMessage = e.message
    273             redirect action: 'selectAssay'
    274 
     166                def measurementTokensSelection = []
     167
     168                if (params."cat_4" == 'on') {
     169
     170                    def measurementToken = params.measurementToken
     171
     172                    if (measurementToken)
     173                        if (measurementToken instanceof String)
     174                            measurementTokensSelection = [[name: measurementToken]]
     175                        else
     176                            measurementTokensSelection = measurementToken.collect{[name: it]}
     177                }
     178
     179                def assayData           = assayService.collectAssayData(flow.assay, fieldMapSelection, measurementTokensSelection)
     180                flow.rowData            = assayService.convertColumnToRowStructure(assayData)
     181                flow.assayDataPreview   = flow.rowData[0..4].collect{ it[0..4] as ArrayList }
     182
     183            }.to "compileExportData"
     184
     185            on(Exception).to "handleError"
     186        }
     187
     188        compileExportData {
     189            on ("ok"){session.rowData = flow.rowData}.to "export"
     190            on ("cancel").to "selectAssay"
     191        }
     192
     193        export {
     194            redirect(action: 'doExport')
     195        }
     196
     197        handleError() {
     198            render(view: 'errorPage')
    275199        }
    276200    }
     
    282206        response.setContentType("application/octet-stream")
    283207        try {
    284            
    285             assayService.exportRowWiseDataToExcelFile(flash.rowData, response.outputStream)
     208
     209            assayService.exportRowWiseDataToExcelFile(session.rowData, response.outputStream)
     210            response.outputStream.flush()
    286211
    287212        } catch (Exception e) {
    288213
    289214            flash.errorMessage = e.message
    290             redirect action: 'selectAssay'
    291 
    292         }
    293 
    294 
     215            redirect action: 'errorPage'
     216
     217        }
     218    }
     219
     220    def errorPage = {
     221        render(view: 'excelExport/errorPage')
    295222    }
    296223}
Note: See TracChangeset for help on using the changeset viewer.