Changeset 224 for trunk/grails-app/domain

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/domain/dbnp/studycapturing

Files:

• Sample.groovy (modified) (1 diff)
• Study.groovy (modified) (3 diffs)
• Subject.groovy (modified) (1 diff)
• Template.groovy (modified) (2 diffs)
• TemplateEntity.groovy (modified) (4 diffs)
• TemplateField.groovy (modified) (2 diffs)
• TemplateStudyField.groovy (deleted)
• TemplateSubjectField.groovy (deleted)

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 = {