Changeset 1864 for trunk/grails-app/controllers/dbnp/studycapturing/SimpleWizardController.groovy

Timestamp:

May 23, 2011, 4:36:00 PM (10 years ago)

Author:

s.h.sikkema@…

Message:

in exporter: module error display improvements (ie. display on screen but still able to export); removed changes to simplewizard; removed unnecessary imports; should handle 'null' parent subject from samples correctly; should handle non number values from modules correctly; deselects module measurements in case of module error/no measurements; removed obsolete entry in topnav

File:

• trunk/grails-app/controllers/dbnp/studycapturing/SimpleWizardController.groovy (modified) (3 diffs)

trunk/grails-app/controllers/dbnp/studycapturing/SimpleWizardController.groovy

@@ -37 +37 @@
          */
         def index = {
-//              if( params.id )
-//                      redirect( action: "simpleWizard", id: params.id );
-//              else
-//                      redirect( action: "simpleWizard" );
         redirect action: 'simpleWizard', params: params
         }
@@ -50 +46 @@
                                 if (!flow.study) retrievalError()
 
-                flow.inferDesign = params.inferDesign
                                 // Search for studies
                                 flow.studies = Study.giveWritableStudies( authenticationService.getLoggedInUser(), 100 )
@@ -824 +819 @@
         def errors = [];
 
-        if (flow.inferDesign) {
-
-            println 'Entered infer design...'
-
-            // find the indices of the classes of interest in the records
-            def sampleIdx           = table[0].findIndexOf{it.class.name == 'dbnp.studycapturing.Sample'}
-            def samplingEventIdx    = table[0].findIndexOf{it.class.name == 'dbnp.studycapturing.SamplingEvent'}
-            def subjectIdx          = table[0].findIndexOf{it.class.name == 'dbnp.studycapturing.Subject'}
-
-            // Check for duplicate samples
-            def samples = table.collect{it[sampleIdx]}
-
-            def uniques     = [] as Set
-            def duplicates  = [] as Set
-
-            // this approach separates the unique from the duplicate entries
-            samples*.name.each {
-                uniques.add(it) || duplicates.add(it)
-            }
-
-            duplicates.each{ duplicateName ->
-                samples.findAll{it.name == duplicateName}.each{ sample ->
-                    numInvalidEntities++
-                    failedcells = addNonValidatingCells(failedcells, sample, flow)
-                    errors += "(Sample) duplicate name: $duplicateName"
-                }
-            }
-
-            // A closure that returns a sub list of entities from a list that have
-            // unique values of a property indicated by propertyName
-            def uniqueEntitiesByProperty = { entities, propertyName ->
-
-               entities*."$propertyName".unique().collect { uniquePropertyValue ->
-
-                    entities.find{ it."$propertyName" == uniquePropertyValue }
-
-                }
-            }
-
-            def addToCollectionIfNonexistent = { parent, collectionName, entity, propertyName ->
-
-                if (!parent[collectionName].find{it[propertyName] == entity[propertyName]})
-                    parent."addTo${collectionName.capitalize()}" entity
-
-            }
-
-            // collect unique subjects and sampling events from table
-            def uniqueSubjects =
-                uniqueEntitiesByProperty(table.collect{it[subjectIdx]}, 'name')
-            uniqueSubjects.each{
-                addToCollectionIfNonexistent study, 'subjects', it, 'name'
-                it.species = Term.findByName('Homo sapiens')
-            }
-
-            def uniqueSamplingEvents =
-                uniqueEntitiesByProperty(table.collect{it[samplingEventIdx]}, 'startTime')
-            uniqueSamplingEvents.each{
-                it.setFieldValue( 'sampleTemplate', flow.sampleForm.template.Sample.name )
-            }
-
-            // create an event group for each unique sampling event (not much of a group, is it ...)
-            def eventGroups = uniqueSamplingEvents.collect{
-
-                def eventGroupName = "Sampling_${it.sampleTemplate.name}_${new RelTime(it.startTime).toString()}"
-
-                def eventGroup = study.eventGroups.find{it.name == eventGroupName} ?: //EventGroup.findByParentAndName(study, eventGroupName) ?:
-                    new EventGroup(name: eventGroupName)
-
-                eventGroup.addToSamplingEvents it
-
-                if (!study.eventGroups.find{it == eventGroup})
-                    study.addToEventGroups eventGroup
-
-                if (!it.parent) study.addToSamplingEvents it
-
-                println eventGroup.name
-
-                eventGroup
-
-            }
-
-            table.each{ record ->
-
-                Sample sample = record[sampleIdx]
-
-                // gather all sample related entities
-                def correspondingSamplingEvent  = uniqueSamplingEvents.find {it.startTime == record[samplingEventIdx].startTime}
-                def correspondingSubject        = uniqueSubjects.find{it.name == record[subjectIdx].name}
-                def correspondingEventGroup     = eventGroups.find{correspondingSamplingEvent in it.samplingEvents}
-
-                addToCollectionIfNonexistent correspondingSamplingEvent, 'samples', sample, 'name'
-
-                sample.parentSubject = correspondingSubject
-
-                correspondingEventGroup.addToSamplingEvents correspondingSamplingEvent
-
-                if (!correspondingEventGroup.subjects.find{it.name == correspondingSubject.name})
-                    correspondingEventGroup.addToSubjects correspondingSubject
-
-                addToCollectionIfNonexistent study, 'samples', sample, 'name'
-
-            }
-
-        } else {
-            // Add all samples
-            table.each { record ->
-                record.each { entity ->
-                    if( entity ) {
-                        // Determine entity class and add a parent. Add the entity to the study
-                        def preferredIdentifier = importerService.givePreferredIdentifier( entity.class );
-                        def equalClosure = { it.getIdentifier() == entity.getIdentifier() }
-                        def entityName = entity.class.name[ entity.class.name.lastIndexOf( "." ) + 1 .. -1 ]
-
-                        entity.parent = study
-
-                        switch( entity.class ) {
-                            case Sample:
-                                if( !study.samples?.find( equalClosure ) ) {
-                                    study.addToSamples( entity );
+        // Add all samples
+        table.each { record ->
+            record.each { entity ->
+                if( entity ) {
+                    // Determine entity class and add a parent. Add the entity to the study
+                    def preferredIdentifier = importerService.givePreferredIdentifier( entity.class );
+                    def equalClosure = { it.getIdentifier() == entity.getIdentifier() }
+                    def entityName = entity.class.name[ entity.class.name.lastIndexOf( "." ) + 1 .. -1 ]
+
+                    entity.parent = study
+
+                    switch( entity.class ) {
+                        case Sample:
+                            if( !study.samples?.find( equalClosure ) ) {
+                                study.addToSamples( entity );
+                            }
+
+                            // If an eventgroup is created, add it to the study
+                            // The eventgroup must have a unique name, but the user shouldn't be bothered with it
+                            // Add 'group ' + samplename and it that is not unique, add a number to it
+                            if( entity.parentEventGroup ) {
+                                study.addToEventGroups( entity.parentEventGroup )
+
+                                entity.parentEventGroup.name = "Group " + entity.name
+                                while( !entity.parentEventGroup.validate() ) {
+                                    //entity.parentEventGroup.getErrors().each { println it }
+                                    entity.parentEventGroup.name += "" + Math.floor( Math.random() * 100 )
                                 }
-
-                                // If an eventgroup is created, add it to the study
-                                // The eventgroup must have a unique name, but the user shouldn't be bothered with it
-                                // Add 'group ' + samplename and it that is not unique, add a number to it
-                                if( entity.parentEventGroup ) {
-                                    study.addToEventGroups( entity.parentEventGroup )
-
-                                    entity.parentEventGroup.name = "Group " + entity.name
-                                    while( !entity.parentEventGroup.validate() ) {
-                                        //entity.parentEventGroup.getErrors().each { println it }
-                                        entity.parentEventGroup.name += "" + Math.floor( Math.random() * 100 )
+                            }
+
+                            break;
+                        case Subject:
+                            if( !study.samples?.find( equalClosure ) ) {
+
+                                if( preferredIdentifier ) {
+                                    // Subjects without a name should just be called 'subject'
+                                    if( !entity.getFieldValue( preferredIdentifier.name ) )
+                                        entity.setFieldValue( preferredIdentifier.name, "Subject" );
+
+                                    // Subjects should have unique names; if the user has entered the same name multiple times,
+                                    // the subject will be renamed
+                                    def baseName = entity.getFieldValue( preferredIdentifier.name )
+                                    def counter = 2;
+
+                                    while( study.subjects?.find { it.getFieldValue( preferredIdentifier.name ) == entity.getFieldValue( preferredIdentifier.name ) } ) {
+                                        entity.setFieldValue( preferredIdentifier.name, baseName + " (" + counter++ + ")" )
                                     }
                                 }
 
-                                break;
-                            case Subject:
-                                if( !study.samples?.find( equalClosure ) ) {
-
-                                    if( preferredIdentifier ) {
-                                        // Subjects without a name should just be called 'subject'
-                                        if( !entity.getFieldValue( preferredIdentifier.name ) )
-                                            entity.setFieldValue( preferredIdentifier.name, "Subject" );
-
-                                        // Subjects should have unique names; if the user has entered the same name multiple times,
-                                        // the subject will be renamed
-                                        def baseName = entity.getFieldValue( preferredIdentifier.name )
-                                        def counter = 2;
-
-                                        while( study.subjects?.find { it.getFieldValue( preferredIdentifier.name ) == entity.getFieldValue( preferredIdentifier.name ) } ) {
-                                            entity.setFieldValue( preferredIdentifier.name, baseName + " (" + counter++ + ")" )
-                                        }
-                                    }
-
-                                    study.addToSubjects( entity );
-
-                                }
-
-                                break;
-                            case Event:
-                                if( !study.events?.find( equalClosure ) ) {
-                                    study.addToEvents( entity );
-                                }
-                                break;
-                            case SamplingEvent:
-                                // Sampling events have a 'sampleTemplate' value, which should be filled by the
-                                // template that is chosen for samples.
-                                if( !entity.getFieldValue( 'sampleTemplate' ) ) {
-                                    entity.setFieldValue( 'sampleTemplate', flow.sampleForm.template.Sample.name )
-                                }
-
-                                if( !study.samplingEvents?.find( equalClosure ) ) {
-                                    study.addToSamplingEvents( entity );
-                                }
-                                break;
-                        }
-
-                        if (!entity.validate()) {
-                            numInvalidEntities++;
-
-                            // Add this field to the list of failed cells, in order to give the user feedback
-                            failedcells = addNonValidatingCells( failedcells, entity, flow )
-
-                            // Also create a full list of errors
-                            def currentErrors = getHumanReadableErrors( entity )
-                            if( currentErrors ) {
-                                currentErrors.each {
-                                    errors += "(" + entityName + ") " + it.value;
-                                }
+                                study.addToSubjects( entity );
+
+                            }
+
+                            break;
+                        case Event:
+                            if( !study.events?.find( equalClosure ) ) {
+                                study.addToEvents( entity );
+                            }
+                            break;
+                        case SamplingEvent:
+                            // Sampling events have a 'sampleTemplate' value, which should be filled by the
+                            // template that is chosen for samples.
+                            if( !entity.getFieldValue( 'sampleTemplate' ) ) {
+                                entity.setFieldValue( 'sampleTemplate', flow.sampleForm.template.Sample.name )
+                            }
+
+                            if( !study.samplingEvents?.find( equalClosure ) ) {
+                                study.addToSamplingEvents( entity );
+                            }
+                            break;
+                    }
+
+                    if (!entity.validate()) {
+                        numInvalidEntities++;
+
+                        // Add this field to the list of failed cells, in order to give the user feedback
+                        failedcells = addNonValidatingCells( failedcells, entity, flow )
+
+                        // Also create a full list of errors
+                        def currentErrors = getHumanReadableErrors( entity )
+                        if( currentErrors ) {
+                            currentErrors.each {
+                                errors += "(" + entityName + ") " + it.value;
                             }
                         }