Changeset 224

Timestamp:

Mar 2, 2010, 6:10:52 PM (13 years ago)

Author:

keesvb

Message:

revised templating system: templates are now per entity rather than per study, moved samples to Study

Location:

trunk/grails-app

Files:

• conf/BootStrap.groovy (modified) (8 diffs)
• domain/dbnp/studycapturing/Sample.groovy (modified) (1 diff)
• domain/dbnp/studycapturing/Study.groovy (modified) (3 diffs)
• domain/dbnp/studycapturing/Subject.groovy (modified) (1 diff)
• domain/dbnp/studycapturing/Template.groovy (modified) (2 diffs)
• domain/dbnp/studycapturing/TemplateEntity.groovy (modified) (4 diffs)
• domain/dbnp/studycapturing/TemplateField.groovy (modified) (2 diffs)
• domain/dbnp/studycapturing/TemplateStudyField.groovy (deleted)
• domain/dbnp/studycapturing/TemplateSubjectField.groovy (deleted)

trunk/grails-app/conf/BootStrap.groovy

@@ -123 +123 @@
 
                         // create system user
-                        /*
-                        def systemUser = userService.createUser(InstanceGenerator.user(
+
+                        /*def systemUser = userService.createUser(InstanceGenerator.user(
                                 username: 'system',
                                 pass: 'system',
                                 passConfirm: 'system',
                                 enabled: true
-                        ))
-                        */
-
-                        def genderField = new TemplateSubjectField(
+                        ))*/
+                        
+
+                        def genderField = new TemplateField(
                                 name: 'Gender',type: TemplateFieldType.STRINGLIST,
                                 listEntries: ['Male','Female'])
                         .with { if (!validate()) { errors.each { println it} } else save()}
-                        def ageField = new TemplateSubjectField(
+                        def ageField = new TemplateField(
                                 name: 'Age',type: TemplateFieldType.INTEGER)
                         .with { if (!validate()) { errors.each { println it} } else save()}
@@ -142 +142 @@
                         // Mouse template
                         def mouseTemplate = new Template(
-                                name: 'Mouse'
-                        ).addToSubjectFields(new TemplateSubjectField(
+                                name: 'Mouse', entity: dbnp.studycapturing.Subject
+                        ).addToFields(new TemplateField(
                                 name: 'Genotype',type: TemplateFieldType.STRINGLIST,
                                 listEntries: ['C57/Bl6j','wild type']))
-                        .addToSubjectFields(genderField)
-                        .addToSubjectFields(ageField)
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(genderField)
+                        .addToFields(ageField)
+                        .addToFields(new TemplateField(
                                 name: 'Cage',type: TemplateFieldType.INTEGER))
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(new TemplateField(
                                 name: 'Some double', type: TemplateFieldType.DOUBLE))
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(new TemplateField(
                                 name: 'Some ontology', type: TemplateFieldType.ONTOLOGYTERM))
                         .with { if (!validate()) { errors.each { println it} } else save()}
@@ -158 +158 @@
                         // Human template
                         def humanTemplate = new Template(
-                                name: 'Human')
-                        .addToSubjectFields(genderField)
-                        .addToSubjectFields(ageField)
-                        .addToSubjectFields(new TemplateSubjectField(
+                                name: 'Human', entity: dbnp.studycapturing.Subject)
+                        .addToFields(genderField)
+                        .addToFields(ageField)
+                        .addToFields(new TemplateField(
                                 name: 'DOB',type: TemplateFieldType.DATE))
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(new TemplateField(
                                 name: 'Height',type: TemplateFieldType.DOUBLE))
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(new TemplateField(
                                 name: 'Weight',type: TemplateFieldType.DOUBLE))
-                        .addToSubjectFields(new TemplateSubjectField(
+                        .addToFields(new TemplateField(
                                 name: 'BMI',type: TemplateFieldType.DOUBLE))
                         .with { if (!validate()) { errors.each { println it} } else save()}
@@ -245 +245 @@
                         println 'Adding PPSH study'
 
-            def humanStudy = new Study(
+                        def humanStudy = new Study(
                                 title:"NuGO PPS human study",
                                 code:"PPSH",
@@ -291 +291 @@
                                         eventDescription: bloodSamplingEvent,
                                         parameterFloatValues: ['Sample volume':4.5F])
-                                        .addToSamples(new Sample(
-                                                name: currentSubject.name + '_B',
-                                                material: bloodTerm
-                                ))
-                                ).with { if (!validate()) { errors.each { println it} } else save()}
+                                )
+                                .addToSamples(new Sample(
+                                        name: currentSubject.name + '_B',
+                                        material: bloodTerm)
+                                )
+                                .with { if (!validate()) { errors.each { println it} } else save()}
                         }
 
@@ -334 +335 @@
                         ).with { if (!validate()) { errors.each { println it} } else save()}
 
-                        humanStudy.giveSamples()*.each {
+                        humanStudy.samples*.each {
                                 new dbnp.clinicaldata.ClinicalFloatData(
                                         assay: lipidAssayInstance,
@@ -365 +366 @@
                         ).with { if (!validate()) { errors.each { println it} } else save()}
 
-                        humanStudy.giveSamples()*.each {
+                        humanStudy.samples*.each {
                                 lipidAssayRef.addToSamples(it)
                         }
@@ -372 +373 @@
                         humanStudy.addToAssays(lipidAssayRef);
                         humanStudy.save()
+
                 }
         }

trunk/grails-app/domain/dbnp/studycapturing/Sample.groovy

@@ -9 +9 @@
         static searchable = true
 
-    // TODO: should Sample also carry a reference to its parent study,
-    // or should this be inferred via the parent SamplingEvent?
+
 
     String name      // should be unique with respect to the parent study (which can be inferred)
     Term material
-    // don't we need a member that describes the quantity of the sample?
+    // don't we need a member that describes the quantity of the sample? --> should be in the templates
 
     static constraints = {

trunk/grails-app/domain/dbnp/studycapturing/Study.groovy

@@ -20 +20 @@
         Date lastUpdated
         Date startDate
-        Template template
 
         static hasMany = [
@@ -29 +28 @@
                 events: Event,
                 samplingEvents: SamplingEvent,
+                samples: Sample,
                 assays: Assay,
                 persons: StudyPerson,
@@ -50 +50 @@
         }
 
-        def giveAllFields() {
-                return template.studyFields;
-        }
-
-        def giveSamples() {
-                return samplingEvents*.samples;
-        }
 }

trunk/grails-app/domain/dbnp/studycapturing/Subject.groovy

@@ -13 +13 @@
 class Subject extends TemplateEntity implements Serializable {
         static searchable = true
-        Template template
         String name
         Term species

trunk/grails-app/domain/dbnp/studycapturing/Template.groovy

@@ -12 +12 @@
  */
 class Template implements Serializable {
+
         String name
+        Class entity
         //nimble.User owner
 
-        static hasMany = [studyFields: TemplateStudyField, subjectFields: TemplateSubjectField]
+        static hasMany = [fields: TemplateField]
 
         static constraints = {
-                name(unique: true)
+                name(unique:['entity'])
+
         }
 
@@ -30 +33 @@
          * @return The type (static member of TemplateFieldType) of the field, or null of the field does not exist
          */
-        def TemplateFieldType getSubjectFieldType(String fieldName) {
-                def field = subjectFields.find {
+        def TemplateFieldType getFieldType(String fieldName) {
+                def field = fields.find {
                         it.name == fieldName    
                 }
                 field?.type
         }
+
+        def getFieldsByType(TemplateFieldType fieldType) {
+                def result = fields.findAll {
+                        it.type == fieldType
+                }
+                return result;
+        }
 }

trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy

@@ -2 +2 @@
 
 import dbnp.data.Term
+import org.codehaus.groovy.runtime.NullObject
 
 class TemplateEntity {
 
+        Template template
+
         Map templateStringFields
+        Map templateStringListFields
         Map templateIntegerFields
         Map templateFloatFields
@@ -13 +17 @@
 
         static hasMany = [
-                templateStringFields: String, // stores both STRING and STRINGLIST items (latter should be checked against the list)
+                templateStringFields: String,
+                templateStringListFields: TemplateFieldListItem,
                 templateIntegerFields: int,
                 templateFloatFields: float,
@@ -31 +36 @@
          */
         def getFieldValue(String fieldName) {
-                TemplateFieldType fieldType = template.getSubjectFieldType(fieldName)
+                TemplateFieldType fieldType = template.getFieldType(fieldName)
                 if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
                 switch(fieldType) {
                         case [TemplateFieldType.STRING, TemplateFieldType.STRINGLIST]:
                                 return templateStringFields[fieldName]
+                        case [TemplateFieldType.STRINGLIST]:
+                                return templateStringListFields[fieldName]
                         case TemplateFieldType.INTEGER:
                                 return templateIntegerFields[fieldName]
@@ -52 +59 @@
 
         def setFieldValue(String fieldName, value) {
-                this.properties.each { println it}
                 if (this.properties.containsKey(fieldName)) {
                         this[fieldName] = value
                 }
-                else if (templateStringFields.containsKey(fieldName) && value.class == String) {
-                        this.templateStringFields[fieldName] = value
-                }
-                else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
-                        this.templateIntegerFields[fieldName] = value
-                }
-                else if (templateFloatFields.containsKey(fieldName) && value.class == Float) {
-                        this.templateFloatFields[fieldName] = value
-                }
-                else if (templateDoubleFields.containsKey(fieldName) && value.class == Double) {
-                        this.templateDoubleFields[fieldName] = value
-                }
-                else if (templateDateFields.containsKey(fieldName) && value.class == Date) {
-                        this.templateDateFields[fieldName] = value
-                }
-                else if (templateTermFields.containsKey(fieldName) && value.class == Term) {
-                        this.templateTermFields[fieldName] = value
+                else
+                if (template == null) {
+                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties")
                 }
                 else {
-                        println "Field ${fieldName} not found"
+                        if (templateStringFields.containsKey(fieldName) && value.class == String) {
+                                this.templateStringFields[fieldName] = value
+                        }
+                        if (templateStringListFields.containsKey(fieldName) && value.class == TemplateFieldListItem) {
+                                this.templateStringFields[fieldName] = value
+                        }
+                        else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
+                                this.templateIntegerFields[fieldName] = value
+                        }
+                        else if (templateFloatFields.containsKey(fieldName) && value.class == Float) {
+                                this.templateFloatFields[fieldName] = value
+                        }
+                        else if (templateDoubleFields.containsKey(fieldName) && value.class == Double) {
+                                this.templateDoubleFields[fieldName] = value
+                        }
+                        else if (templateDateFields.containsKey(fieldName) && value.class == Date) {
+                                this.templateDateFields[fieldName] = value
+                        }
+                        else if (templateTermFields.containsKey(fieldName) && value.class == Term) {
+                                this.templateTermFields[fieldName] = value
+                        }
+                        else {
+                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
+                        }
                 }
         }
 
+        def Set<TemplateField> giveFields() {
+                return this.template.fields;
+        }
+
+        @Override
+        void setTemplate(Template newTemplate) {
+
+                // Contrary to expectation, this method does not cause an infinite loop but calls the super method
+                // whereas super.setTemplate(newTemplate) leads to errors concerning NullObject values
+                this.template = newTemplate
+
+                // TODO: initialize all template fields with the necessary keys and null values
+
+                println "Setting template " + newTemplate
+                /*if (template == null || template instanceof NullObject) {} else{ // negation doesn't seem to work well
+                        def stringFields = template.getFieldsByType(TemplateFieldType.STRINGLIST)
+                        println stringFields*.name
+                        if (stringFields.size() > 0) {
+                                templateStringFields = new HashMap<String,String>()
+                                templateStringFields.keyset.add stringFields*.name;
+                                println templateStringFields
+                        }
+                }*/
+        }
+
 }

trunk/grails-app/domain/dbnp/studycapturing/TemplateField.groovy

@@ -9 +9 @@
  * $Date$
  */
-abstract class TemplateField implements Serializable {
+class TemplateField implements Serializable {
         String name
         TemplateFieldType type
@@ -15 +15 @@
 
     static hasMany = [listEntries : String] // to store the entries to choose from when the type is 'item from predefined list'
+        //TODO: make TemplateFieldListItem and make a convenience setter for a string array
 
         static constraints = {