Changeset 2036


Ignore:
Timestamp:
Sep 27, 2011, 10:43:14 AM (5 years ago)
Author:
taco@…
Message:

visualization/VisualizeController.groovy. Changed the server-side code for the horizontal barchart to the way that Robert appears to have intended it's implementation. Some general cleaning up.

File:
1 edited

Legend:

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

    r2035 r2036  
    288288        }
    289289
    290         // Handle the case that we are gathering data for a horizontal barchart
    291         if(inputData.visualizationType=='horizontal_barchart'){
    292             def tmp = inputData.columnIds
    293             inputData.columnIds = inputData.rowIds
    294             inputData.rowIds = tmp
    295         }
    296                
    297290                // TODO: handle the case that we have multiple studies
    298291                def studyId = inputData.studyIds[ 0 ];
     
    308301
    309302                // Group data based on the y-axis if categorical axis is selected
    310         def groupedData = groupFieldData( data );
     303        def groupedData
     304        if(inputData.visualizationType=='horizontal_barchart'){
     305            groupedData = groupFieldData( data, "y", "x" ); // Indicate non-standard axis ordering
     306        } else {
     307            groupedData = groupFieldData( data ); // Don't indicate axis ordering, standard <"x", "y"> will be used
     308        }
    311309   
    312310        // Format data so it can be rendered as JSON
    313         def returnData = formatData( inputData.visualizationType, groupedData, fields );
     311        def returnData
     312        if(inputData.visualizationType=='horizontal_barchart'){
     313            returnData = formatData( inputData.visualizationType, groupedData, fields, "y", "x" ); // Indicate non-standard axis ordering
     314        } else {
     315            returnData = formatData( inputData.visualizationType, groupedData, fields); // Don't indicate axis ordering, standard <"x", "y"> will be used
     316        }
    314317        return sendResults(returnData)
    315318        }
     
    549552        // TODO: Handle name and unit of fields correctly
    550553        if(type=="table"){
     554            // TODO: implement this
    551555            def xAxis = groupedData[ groupAxis ].collect { it.toString() };
    552556            def yName = parseFieldId( fields[ valueAxis ] ).name;
     
    843847     */
    844848    protected int determineFieldType(studyId, fieldId){
    845         // Parse the fieldId as given by the user
    846849                def parsedField = parseFieldId( fieldId );
    847 
    848850        def study = Study.get(studyId)
    849 
    850851                def data = []
    851852
    852                 if( parsedField.source == "GSCF" ) {
    853             if(parsedField.id.isNumber()){
    854                 // Templatefield
    855                 // ask for tf by id, ask for .type
    856                 try{
    857                     TemplateField tf = TemplateField.get(parsedField.id)
    858                     if(tf.type==TemplateFieldType.DOUBLE || tf.type==TemplateFieldType.LONG || tf.type==TemplateFieldType.DATE || tf.type==TemplateFieldType.RELTIME){
    859                         println "GSCF templatefield: NUMERICALDATA ("+NUMERICALDATA+") (based on "+tf.type+")"
    860                         return NUMERICALDATA
     853        try{
     854            if( parsedField.source == "GSCF" ) {
     855                if(parsedField.id.isNumber()){
     856                        return determineCategoryFromTemplateField(parsedField.id)
     857                } else { // Domainfield or memberclass
     858                    def field = domainObjectCallback( parsedField.type )?.declaredFields.find { it.name == parsedField.name };
     859                    if( field ) {
     860                        return determineCategoryFromClass( field.getType() )
    861861                    } else {
    862                         println "GSCF templatefield: CATEGORICALDATA ("+CATEGORICALDATA+") (based on "+tf.type+")"
    863                         return CATEGORICALDATA
     862                        // TODO: how do we communicate this to the user? Do we allow the process to proceed?
     863                        log.error( "The user asked for field " + parsedField.type + " - " + parsedField.name + ", but it doesn't exist." );
    864864                    }
    865                 } catch(Exception e){
    866                     log.error("VisualizationController: determineFieldType: "+e)
    867                     // If we cannot figure out what kind of a datatype a piece of data is, we treat it as categorical data
    868                     return CATEGORICALDATA
    869865                }
    870866            } else {
    871                 // Domainfield or memberclass
    872                 try{
    873                                         def field = domainObjectCallback( parsedField.type )?.declaredFields.find { it.name == parsedField.name };
    874                                         if( field ) {
    875                                                 return determineCategoryFromClass( field.getType() )
    876                                         } else {
    877                                                 log.error( "The user asked for field " + parsedField.type + " - " + parsedField.name + ", but it doesn't exist." );
    878                                         }
    879                 } catch(Exception e){
    880                     log.error("VisualizationController: determineFieldType: "+e)
    881                     e.printStackTrace()
    882                     // If we cannot figure out what kind of a datatype a piece of data is, we treat it as categorical data
    883                     return CATEGORICALDATA
    884                 }
    885             }
    886                 } else {
    887             data = getModuleData( study, study.getSamples(), parsedField.source, parsedField.name );
    888             println "Data: " + data
    889                         def cat = determineCategoryFromData(data)
    890             return cat
    891                 }
     867                data = getModuleData( study, study.getSamples(), parsedField.source, parsedField.name );
     868                println "Data: " + data
     869                def cat = determineCategoryFromData(data)
     870                return cat
     871            }
     872        } catch(Exception e){
     873            log.error("VisualizationController: determineFieldType: "+e)
     874            e.printStackTrace()
     875            // If we cannot figure out what kind of a datatype a piece of data is, we treat it as categorical data
     876            return CATEGORICALDATA
     877        }
    892878    }
    893879
     
    937923    }
    938924
     925    /**
     926     * Determines a field category, based on the TemplateFieldType of a Templatefield
     927     * @param id A database ID for a TemplateField
     928     * @return Either CATEGORICALDATA of NUMERICALDATA
     929     */
     930    protected int determineCategoryFromTemplateField(id){
     931        TemplateField tf = TemplateField.get(id)
     932        if(tf.type==TemplateFieldType.DOUBLE || tf.type==TemplateFieldType.LONG || tf.type==TemplateFieldType.DATE || tf.type==TemplateFieldType.RELTIME){
     933            println "GSCF templatefield: NUMERICALDATA ("+NUMERICALDATA+") (based on "+tf.type+")"
     934            return NUMERICALDATA
     935        } else {
     936            println "GSCF templatefield: CATEGORICALDATA ("+CATEGORICALDATA+") (based on "+tf.type+")"
     937            return CATEGORICALDATA
     938        }
     939    }
    939940    /**
    940941     * Properly formats the object that will be returned to the client. Also adds an informational message, if that message has been set by a function. Resets the informational message to the empty String.
Note: See TracChangeset for help on using the changeset viewer.