Changeset 2002 for trunk


Ignore:
Timestamp:
Sep 8, 2011, 10:20:26 AM (8 years ago)
Author:
robert@…
Message:

Updates in visualization with type detection and removal of (for now) unnecessary code for multiple values on one axis

File:
1 edited

Legend:

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

    r2001 r2002  
    9292              - an assay, which can be obtained with study.getAssays()
    9393             */
    94 
    95             def moduleFields = []
    9694            study.getAssays().each { assay ->
    9795                def list = []
     
    10098                    if(list.size()!=0){
    10199                        fields += list
    102                         moduleFields += list
    103100                    }
    104                 }
    105             }
    106 
    107             // Creating the option to select composite fields (fields that all occur on one module)
    108             AssayModule.list().each { am ->
    109                 def list = []
    110                 moduleFields.each { mf ->
    111                     if(mf.source==am.id){
    112                         list << mf
    113                     }
    114                 }
    115                 if(list!=[]){
    116                     def compositeId = ""
    117                     def compositeIdId = ""
    118                     def compositeIdName = ""
    119                     def compositeIdSource = ""
    120                     def compositeIdType = ""
    121                     def source = am.id
    122                     def compositeCategory = ""
    123                     def compositeName = ""
    124 
    125                     for(int i = 0; i < list.size(); i++){
    126                         def singleAssayId = list[i].id.split(',')[2]
    127                         if(i==0){
    128                             compositeIdType += list[i].category
    129                             compositeCategory += list[i].category
    130                             compositeIdSource += "compositeId"+singleAssayId
    131                             compositeIdName += list[i].name
    132                             compositeName += list[i].name
    133                         } else {
    134                             compositeIdType += "@SEP@"+list[i].category
    135                             compositeCategory += "@SEP@"+list[i].category
    136                             compositeIdSource += "@SEP@"+singleAssayId
    137                             compositeIdName += "@SEP@"+list[i].name
    138                             if(list.size()>1 && i==(list.size()-1)){
    139                                 compositeName += " and "+list[i].name
    140                             } else {
    141                                 compositeName += ", "+list[i].name
    142                             }
    143                         }
    144                     }
    145                     compositeId = createFieldId(id: compositeIdId, name: compositeIdName, source: compositeIdSource, type: compositeIdType)
    146                     def compositeField = ["id": compositeId, "source": source, "category": compositeCategory, "name": compositeName]
    147                     fields << compositeField
    148                     //println "compositeField: "+compositeField
    149101                }
    150102            }
     
    171123            return sendInfoMessage()
    172124        }
    173 
    174125
    175126        // TODO: handle the case of multiple fields on an axis
     
    222173
    223174        // Making a different call for each assay
    224         // TODO: Change this to one call that requests fields for all assays, when you get that to work (in all cases)
    225 
    226175        def urlVars = "assayToken="+assay.assayUUID
    227176        try {
     
    262211        def source = "GSCF"
    263212
    264         // Gathering the data
    265         if(category=="subjects"){
    266             if(type=="domainfields"){
    267                 collection = Subject.giveDomainFields()
    268             }
    269             if(type=="templatefields"){
    270                 collection = study?.samples?.parentSubject?.template?.fields
    271             }
    272         }
    273         if(category=="events"){
    274             if(type=="domainfields"){
    275                 collection = Event.giveDomainFields()
    276             }
    277             if(type=="templatefields"){
    278                 collection = study?.samples?.parentEventGroup?.events?.template?.fields
    279             }
    280         }
    281         if(category=="samplingEvents"){
    282             if(type=="domainfields"){
    283                 collection = SamplingEvent.giveDomainFields()
    284             }
    285             if(type=="templatefields"){
    286                 collection = study?.samples?.parentEventGroup?.samplingEvents?.template?.fields
    287             }
    288         }
    289         if(category=="samples"){
    290             if(type=="domainfields"){
    291                 collection = Sample.giveDomainFields()
    292             }
    293             if(type=="templatefields"){
    294                 collection = study?.samples?.template?.fields
    295             }
    296         }
    297         if(category=="assays"){
    298             if(type=="domainfields"){
    299                 collection = Assay.giveDomainFields()
    300             }
    301             if(type=="templatefields"){
    302                 collection = study?.assays?.template?.fields
    303             }
    304         }
    305 
    306         collection.unique()
     213                def domainObjects = [
     214                        "subjects": Subject,
     215                        "events": Event,
     216                        "samples": Sample,
     217                        "samplingEvents": SamplingEvent,
     218                        "assays": Assay,
     219                        "studies": Study ]
     220               
     221                def templateObjects = [
     222                        "subjects": study?.samples?.parentSubject,
     223                        "events": study?.samples?.parentEventGroup?.events,
     224                        "samples": study?.samples,
     225                        "samplingEvents": study?.samples?.parentEventGroup?.samplingEvents,
     226                        "assays": study?.assays,
     227                        "studies": study ]
     228               
     229                if( type == "domainfields" )
     230                        collection = domainObjects[ category ]?.giveDomainFields();
     231                else
     232                        collection = templateObjects[ category ]?.template?.fields
     233
     234        collection?.unique()
    307235
    308236        // Formatting the data
     
    371299
    372300                // Group data based on the y-axis if categorical axis is selected
    373 
    374         // Detecting if, on the y-axis, we have categories (multiple fields on an axis)
    375         // For some reason, the class of the elements will be considered null incase of categories
    376         // I'd rather have filtered on being an instance of Collection, or something along those lines
    377         if(data['y'][0].class==null && data['y'][0]['category']!=null){
    378             // We are dealing with multiple categories
    379             def groupedData = []
    380             def returnData = []
    381 
    382             data['y'].each{
    383                 def tmp_GFdat = groupFieldData(['x': data['x'], 'y': it['category']['data']] );
    384                 groupedData << tmp_GFdat
    385 
    386                 // Format data so it can be rendered as JSON
    387                 def tmp_Fdat = formatData( tmp_GFdat, ['x': fields['x'], 'y': "a,"+it['category']['name']+",a,a"] );
    388                 //println "\tmp_Fdat: "+tmp_Fdat
    389                 returnData << tmp_Fdat
    390             }
    391 
    392             // Format data so it can be rendered as JSON
    393             def returnDataWithMultipleCategories = formatCategoryData(returnData)
    394             return sendResults(returnDataWithMultipleCategories)
    395         } else {
    396             // We are dealing with a single category
    397             def groupedData = groupFieldData( data );
     301        def groupedData = groupFieldData( data );
    398302   
    399             // Format data so it can be rendered as JSON
    400             def returnData = formatData( groupedData, fields );
    401             return sendResults(returnData)
    402         }
     303        // Format data so it can be rendered as JSON
     304        def returnData = formatData( groupedData, fields );
     305        return sendResults(returnData)
    403306        }
    404307
     
    515418                //println "assay_id: "+assay_id+", fieldName: "+fieldName
    516419                // TODO: Handle values that should be retrieved from multiple assays
    517         // Check if this id starts with "compositeId", which indicates that the request concerns multiple assays from the same source module
    518         if(assay_id.toString().startsWith("compositeId")){
    519             //println "composite data request."
    520             // This assay_id is a composite, meaning that the user is requesting data from multiple assays
    521             //data = [:]
    522             def ids = assay_id.toString().substring("compositeId".length()).split("@SEP@")
    523             def names = fieldName.split("@SEP@")
    524             ids.eachWithIndex { it, i ->
    525                 //println "data request decomposition:"
    526                 data << ['category': ['name': names[i], 'data': getModuleData(study, samples, it, names[i])]]
     420        def assay = Assay.get(assay_id);
     421
     422        if( assay ) {
     423            // Request for a particular assay and a particular feature
     424            def urlVars = "assayToken=" + assay.assayUUID + "&measurementToken="+fieldName
     425            urlVars += "&" + samples.collect { "sampleToken=" + it.sampleUUID }.join( "&" );
     426
     427            def callUrl
     428            try {
     429                callUrl = assay.module.url + "/rest/getMeasurementData"
     430                def json = moduleCommunicationService.callModuleMethod( assay.module.url, callUrl, urlVars, "POST" );
     431
     432                if( json ) {
     433                    // First element contains sampletokens
     434                    // Second element contains the featurename
     435                    // Third element contains the measurement value
     436                    def sampleTokens = json[ 0 ]
     437                    def measurements = json[ 2 ]
     438
     439                    // Loop through the samples
     440                    samples.each { sample ->
     441                        // Search for this sampletoken
     442                        def sampleToken = sample.sampleUUID;
     443                        def index = sampleTokens.findIndexOf { it == sampleToken }
     444
     445                        if( index > -1 ) {
     446                            data << measurements[ index ];
     447                        } else {
     448                            data << null
     449                        }
     450                    }
     451                } else {
     452                    // TODO: handle error
     453                    // Returns an empty list with as many elements as there are samples
     454                    data = samples.collect { return null }
     455                }
     456
     457            } catch(Exception e){
     458                log.error("VisualizationController: getFields: "+e)
     459                return returnError(404, "An error occured while trying to collect data from a module. Most likely, this module is offline.")
    527460            }
    528461        } else {
    529             def assay = Assay.get(assay_id);
    530 
    531             if( assay ) {
    532                 // Request for a particular assay and a particular feature
    533                 def urlVars = "assayToken=" + assay.assayUUID + "&measurementToken="+fieldName
    534                 urlVars += "&" + samples.collect { "sampleToken=" + it.sampleUUID }.join( "&" );
    535 
    536                 def callUrl
    537                 try {
    538                     callUrl = assay.module.url + "/rest/getMeasurementData"
    539                     def json = moduleCommunicationService.callModuleMethod( assay.module.url, callUrl, urlVars, "POST" );
    540 
    541                     if( json ) {
    542                         // First element contains sampletokens
    543                         // Second element contains the featurename
    544                         // Third element contains the measurement value
    545                         def sampleTokens = json[ 0 ]
    546                         def measurements = json[ 2 ]
    547 
    548                         // Loop through the samples
    549                         samples.each { sample ->
    550                             // Search for this sampletoken
    551                             def sampleToken = sample.sampleUUID;
    552                             def index = sampleTokens.findIndexOf { it == sampleToken }
    553 
    554                             if( index > -1 ) {
    555                                 data << measurements[ index ];
    556                             } else {
    557                                 data << null
    558                             }
    559                         }
    560                     } else {
    561                         // TODO: handle error
    562                         // Returns an empty list with as many elements as there are samples
    563                         data = samples.collect { return null }
    564                     }
    565 
    566                 } catch(Exception e){
    567                     log.error("VisualizationController: getFields: "+e)
    568                     return returnError(404, "An error occured while trying to collect data from a module. Most likely, this module is offline.")
    569                 }
    570             } else {
    571                 // TODO: Handle error correctly
    572                 // Returns an empty list with as many elements as there are samples
    573                 data = samples.collect { return null }
    574             }
    575         }
    576 
     462            // TODO: Handle error correctly
     463            // Returns an empty list with as many elements as there are samples
     464            data = samples.collect { return null }
     465        }
    577466
    578467        //println "\t data request: "+data
     
    792681           }
    793682   }
    794                
     683   Exception e
    795684        /**
    796685         * Return the numeric value of the given object, or null if no numeric value could be returned
     
    895784                        case "Study":
    896785                        case "studies":
    897                             return determineCategoryFromClass(Study[parsedField.name].class)
     786                            return determineCategoryFromClass(Study.fields[parsedField.name].type)
    898787                            break
    899788                        case "Subject":
    900789                        case "subjects":
    901                             return determineCategoryFromClass(Subject[parsedField.name].class)
     790                            return determineCategoryFromClass(Subject.fields[parsedField.name].type)
    902791                            break
    903792                        case "Sample":
    904793                        case "samples":
    905                             return determineCategoryFromClass(Sample[parsedField.name].class)
     794                            return determineCategoryFromClass(Sample.fields[parsedField.name].type)
    906795                            break
    907796                        case "Event":
    908797                        case "events":
    909                             return determineCategoryFromClass(Event[parsedField.name].class)
     798                            return determineCategoryFromClass(Event.fields[parsedField.name].type)
    910799                            break
    911800                        case "SamplingEvent":
    912801                        case "samplingEvents":
    913                             return determineCategoryFromClass(SamplingEvent[parsedField.name].class)
     802                            return determineCategoryFromClass(SamplingEvent.fields[parsedField.name].type)
    914803                            break
    915804                        case "Assay":
    916805                        case "assays":
    917                             return determineCategoryFromClass(Assay[parsedField.name].class)
     806                            return determineCategoryFromClass(Assay.fields[parsedField.name].type)
    918807                            break
    919808                    }
     
    928817                } else {
    929818            data = getModuleData( study, study.getSamples(), parsedField.source, parsedField.name );
    930             def cat = determineCategoryFromData(data)
     819            println "Data: " + data
     820                        def cat = determineCategoryFromData(data)
    931821            return cat
    932822                }
     
    946836            // This data is more complex than a single value, so we will call ourselves again so we c
    947837            inputObject.each {
    948                 results << determineCategoryFromData(it)
     838                                if( it != null )
     839                        results << determineCategoryFromData(it)
    949840            }
    950841        } else {
Note: See TracChangeset for help on using the changeset viewer.