Changeset 1998


Ignore:
Timestamp:
Sep 6, 2011, 1:43:05 PM (8 years ago)
Author:
taco@…
Message:

Update for the visualization controller

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/grails-app/controllers/dbnp/visualization/VisualizeController.groovy

    r1997 r1998  
    1717import dbnp.studycapturing.*;
    1818import grails.converters.JSON
    19 import groovy.lang.Closure;
    2019
    2120import org.dbnp.gdt.*
     
    2524        def moduleCommunicationService
    2625    def infoMessage = ""
     26    final int categoricalData = 0
     27    final int numericalData = 1
    2728
    2829        /**
     
    3536        def getStudies = {
    3637                def studies = Study.giveReadableStudies( authenticationService.getLoggedInUser() );
    37         returnResults(studies)
     38        return sendResults(studies)
    3839        }
    3940
     
    4344
    4445                try{
    45             // TODO: fix this
    46                         input_object = JSON.parse(params.get('data'))
    47                         studies = input_object.get('studies').id
     46                        input_object = parseGetDataParams();
    4847                } catch(Exception e) {
    49                         returnError(400, "An error occured while retrieving the user input.")
    50             log.error("VisualizationController: getFields: "+e)
    51                 }
     48                        log.error("VisualizationController: getFields: "+e)
     49            return returnError(400, "An error occured while retrieving the user input.")
     50                }
     51
     52        // Check to see if we have enough information
     53        if(input_object==null || input_object?.studyIds==null){
     54            infoMessage = "Please select a study."
     55            return sendInfoMessage()
     56        } else {
     57            studies = input_object.studyIds[0]
     58        }
    5259
    5360                def fields = [];
    54                 studies.each {
    55                         /*
    56                          Gather fields related to this study from GSCF.
    57                          This requires:
    58                          - a study.
    59                          - a category variable, e.g. "events".
    60                          - a type variable, either "domainfields" or "templatefields".
    61                          */
    62                         def study = Study.get(it)
    63                         fields += getFields(study, "subjects", "domainfields")
    64                         fields += getFields(study, "subjects", "templatefields")
    65                         fields += getFields(study, "events", "domainfields")
    66                         fields += getFields(study, "events", "templatefields")
    67                         fields += getFields(study, "samplingEvents", "domainfields")
    68                         fields += getFields(study, "samplingEvents", "templatefields")
    69                         fields += getFields(study, "assays", "domainfields")
    70                         fields += getFields(study, "assays", "templatefields")
    71                         fields += getFields(study, "samples", "domainfields")
    72                         fields += getFields(study, "samples", "domainfields")
     61
     62        /*
     63         Gather fields related to this study from GSCF.
     64         This requires:
     65         - a study.
     66         - a category variable, e.g. "events".
     67         - a type variable, either "domainfields" or "templatefields".
     68         */
     69        // TODO: Handle multiple studies
     70        def study = Study.get(studies)
     71
     72        if(study!=null){
     73            fields += getFields(study, "subjects", "domainfields")
     74            fields += getFields(study, "subjects", "templatefields")
     75            fields += getFields(study, "events", "domainfields")
     76            fields += getFields(study, "events", "templatefields")
     77            fields += getFields(study, "samplingEvents", "domainfields")
     78            fields += getFields(study, "samplingEvents", "templatefields")
     79            fields += getFields(study, "assays", "domainfields")
     80            fields += getFields(study, "assays", "templatefields")
     81            fields += getFields(study, "samples", "domainfields")
     82            fields += getFields(study, "samples", "domainfields")
    7383
    7484            /*
     
    94104            }
    95105
    96                         // TODO: Maybe we should add study's own fields
    97                 }
    98 
    99                 returnResults(fields)
     106            // TODO: Maybe we should add study's own fields
     107        } else {
     108            log.error("VisualizationController: getFields: The requested study could not be found. Id: "+studies)
     109            return returnError(404, "The requested study could not be found.")
     110        }
     111
     112                return sendResults(fields)
    100113        }
    101114
    102115        def getVisualizationTypes = {
    103116        def inputData = parseGetDataParams();
    104         println "inputData: "+inputData
     117        println "inputData: "
     118        inputData.each{
     119            println "\t"+it
     120        }
     121
     122        if(inputData.columnIds == null || inputData.columnIds == [] || inputData.columnIds[0] == null || inputData.columnIds[0] == ""){
     123            infoMessage = "Please select columndata."
     124            return sendInfoMessage()
     125        }
     126        if(inputData.rowIds == null || inputData.rowIds == [] ||  inputData.rowIds[0] == null ||   inputData.rowIds[0] == ""){
     127            infoMessage = "Please select rowdata."
     128            return sendInfoMessage()
     129        }
    105130
    106131
    107132        // TODO: handle the case of multiple fields on an axis
    108         println "Checking type of row data"
     133        // Determine data types
     134        println "Checking type of row data ("+inputData.rowIds[0]+")"
    109135        def rowType = determineFieldType(inputData.studyIds[0], inputData.rowIds[0])
    110         println "Checking type of column data"
     136        println "Checking type of column data ("+inputData.columnIds[0]+")"
    111137        def columnType = determineFieldType(inputData.studyIds[0], inputData.columnIds[0])
    112138
    113139        println "getVisualizationTypes: row contains data of type "+rowType+" and column contains data of type "+columnType
    114140
     141
     142        // Determine possible visualization types
     143        // TODO: Determine possible visualization types
     144
    115145                def types = [ [ "id": "barchart", "name": "Barchart"] ];
    116                 returnResults(types)
     146                return sendResults(types)
    117147        }
    118148
     
    154184            }
    155185        } catch(Exception e){
    156             returnError(404, "An error occured while trying to collect field data from a module. Most likely, this module is offline.")
     186            //returnError(404, "An error occured while trying to collect field data from a module. Most likely, this module is offline.")
     187            infoMessage = "An error occured while trying to collect field data from a module. Most likely, this module is offline."
    157188            log.error("VisualizationController: getFields: "+e)
    158189        }
     
    173204
    174205        // Collecting the data from it's source
    175         def collection
     206        def collection = []
    176207        def fields = []
    177208        def source = "GSCF"
     
    267298                // TODO: handle erroneous input data
    268299                def inputData = parseGetDataParams();
     300
     301        println "getData's inputData: "+inputData
     302        if(inputData.columnIds == null || inputData.rowIds == null){
     303            infoMessage = "Please select row and columndata."
     304            return sendInfoMessage()
     305        }
    269306               
    270307                // TODO: handle the case that we have multiple studies
     
    287324                def returnData = formatData( groupedData, fields );
    288325
    289                 returnResults(returnData)
     326                return sendResults(returnData)
    290327        }
    291328
     
    312349                        visualizationType = "barchart"
    313350                } catch(Exception e) {
     351            /* TODO: Find a way to handle exceptions without breaking the user interface.
     352                Doing things in this way results in the user interface getting a 400.
    314353                        returnError(400, "An error occured while retrieving the user input")
     354            infoMessage = "An error occured while retrieving the user input."
    315355                        log.error("VisualizationController: parseGetDataParams: "+e)
     356            return sendInfoMessage()
     357            */
    316358                }
    317359
     
    435477                               
    436478                        } catch(Exception e){
    437                 returnError(404, "An error occured while trying to collect data from a module. Most likely, this module is offline.")
    438479                log.error("VisualizationController: getFields: "+e)
     480                send returnError(404, "An error occured while trying to collect data from a module. Most likely, this module is offline.")
    439481                        }
    440482                } else {
     
    737779    }
    738780
    739     protected String determineFieldType(studyId, fieldId){
     781    protected def determineFieldType(studyId, fieldId){
    740782        // Parse the fieldId as given by the user
    741783                def parsedField = parseFieldId( fieldId );
     
    750792                // Templatefield
    751793                // ask for tf by id, ask for .type
    752                 println "GSCF, dunno yet"
     794                println "GSCF TF, dunno yet. input: "+studyId+", "+parsedField
     795                try{
     796                    TemplateField tf = TemplateField.get(parsedField.id)
     797                    println "tf.type: "+tf.type
     798                    if(tf.type=="DOUBLE" || tf.type=="LONG" || tf.type=="DATE" || tf.type=="RELTIME"){
     799                        return numericalData
     800                    } else {
     801                        return categoricalData
     802                    }
     803                } catch(Exception e){
     804                    log.error("VisualizationController: determineFieldType: "+e)
     805                }
    753806            } else {
    754807                // Domainfield or memberclass
    755                 switch( parsedField.type ) {
    756                     case "Study":
    757                     case "studies":
    758                         def cat = determineCategoryFromClass(Study[parsedField.name].class)
    759                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    760                         return cat
    761                         break
    762                     case "Subject":
    763                     case "subjects":
    764                         def cat = determineCategoryFromClass(Subject[parsedField.name].class)
    765                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    766                         return cat
    767                         break
    768                     case "Sample":
    769                     case "samples":
    770                         def cat = determineCategoryFromClass(Sample[parsedField.name].class)
    771                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    772                         return cat
    773                         break
    774                     case "Event":
    775                     case "events":
    776                         def cat = determineCategoryFromClass(Event[parsedField.name].class)
    777                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    778                         return cat
    779                         break
    780                     case "SamplingEvent":
    781                     case "samplingEvents":
    782                         def cat = determineCategoryFromClass(SamplingEvent[parsedField.name].class)
    783                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    784                         return cat
    785                         break
    786                     case "Assay":
    787                     case "assays":
    788                         def cat = determineCategoryFromClass(Assay[parsedField.name].class)
    789                         println "parsedField.type: "+parsedField.type+", outcome: "+cat
    790                         return cat
    791                         break
     808                try{
     809                    switch( parsedField.type ) {
     810                        case "Study":
     811                        case "studies":
     812                            return determineCategoryFromClass(Study[parsedField.name].class)
     813                            break
     814                        case "Subject":
     815                        case "subjects":
     816                            return determineCategoryFromClass(Subject[parsedField.name].class)
     817                            break
     818                        case "Sample":
     819                        case "samples":
     820                            return determineCategoryFromClass(Sample[parsedField.name].class)
     821                            break
     822                        case "Event":
     823                        case "events":
     824                            return determineCategoryFromClass(Event.getField(parsedField.name).class)
     825                            break
     826                        case "SamplingEvent":
     827                        case "samplingEvents":
     828                            return determineCategoryFromClass(SamplingEvent[parsedField.name].class)
     829                            break
     830                        case "Assay":
     831                        case "assays":
     832                            return determineCategoryFromClass(Assay[parsedField.name].class)
     833                            break
     834                    }
     835                } catch(Exception e){
     836                    return categoricalData
    792837                }
    793838            }
     
    804849        println "determineCategoryFromClass: "+inputObject+", class: "+inputObject.class
    805850        if(inputObject==java.lang.String){
    806             return "cat"
    807             // TODO: make this a final
     851            return categoricalData
    808852        } else {
    809             return "num"
    810             // TODO: make this a final
     853            return numericalData
    811854        }
    812855    }
     
    821864        } else {
    822865            if(inputObject.toString().isDouble()){
    823                 results << "num"
    824                 // TODO: make this a final
     866                results << numericalData
    825867            } else {
    826                 results << "cat"
    827                 // TODO: make this a final
     868                results << categoricalData
    828869            }
    829870        }
     
    833874        if(results.size()>1){
    834875            //log.error("VisualizeController: determineCategoryFromData: Category list contains more than one category! List: "+results+", inputObject: "+inputObject)
    835             results[0] = "cat"
    836             // TODO: make this a final
     876            results[0] = categoricalData
    837877        }
    838878
     
    840880    }
    841881
    842     protected void returnResults(returnData){
     882    protected void sendResults(returnData){
    843883        def results = [:]
    844884        if(infoMessage!=""){
    845             results.put("infoMessage", returnData)
     885            results.put("infoMessage", infoMessage)
     886            infoMessage = ""
    846887        }
    847888        results.put("returnData", returnData)
     889        println "Returning "+results
     890        render results as JSON
     891    }
     892
     893    protected void sendInfoMessage(){
     894        def results = [:]
     895        results.put("infoMessage", infoMessage)
     896        infoMessage = ""
     897        println "Returning "+results
    848898        render results as JSON
    849899    }
Note: See TracChangeset for help on using the changeset viewer.