Changeset 236 for trunk/grails-app/domain

Timestamp:

Mar 5, 2010, 2:20:10 PM (13 years ago)

Author:

keesvb

Message:

updated TemplateEntity? to include empty maps, also added the EventGroups? to EventGroup? collection in BootStrap?

Location:

trunk/grails-app/domain/dbnp/studycapturing

Files:

• Study.groovy (modified) (1 diff)
• Template.groovy (modified) (1 diff)
• TemplateEntity.groovy (modified) (7 diffs)
• TemplateFieldType.groovy (modified) (2 diffs)

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

@@ -13 +13 @@
         nimble.User owner
         String title
+
+        // TODO: The following 4 fields should be moved into templates
         String code
         String researchQuestion
         String description
         String ecCode
+
         Date dateCreated
         Date lastUpdated

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

@@ -47 +47 @@
          * get all field of a particular type
          * @param       Class   fieldType
-         * @return      ArrayList
+         * @return      Set<TemplateField>
          */
         def getFieldsByType(TemplateFieldType fieldType) {

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

@@ -8 +8 @@
         Template template
 
-        Map templateStringFields
-        Map templateStringListFields
-        Map templateIntegerFields
-        Map templateFloatFields
-        Map templateDoubleFields
-        Map templateDateFields
-        Map templateTermFields
+        Map templateStringFields = [:]
+        Map templateTextFields = [:]
+        Map templateStringListFields = [:]
+        Map templateIntegerFields = [:]
+        Map templateFloatFields = [:]
+        Map templateDoubleFields = [:]
+        Map templateDateFields = [:]
+        Map templateTermFields = [:]
 
         static hasMany = [
                 templateStringFields: String,
+                templateTextFields: String,
                 templateStringListFields: TemplateFieldListItem,
                 templateIntegerFields: int,
@@ -28 +30 @@
         static constraints = {
                 template(nullable: true)
+
+        }
+
+        static mapping = {
+                tablePerHierarchy false
+
+                templateTextFields type: 'text'
+        }
+
+        private Map getStore(TemplateFieldType fieldType) {
+                switch(fieldType) {
+                        case TemplateFieldType.STRING:
+                                return templateStringFields
+                        case TemplateFieldType.TEXT:
+                                return templateTextFields
+                        case TemplateFieldType.STRINGLIST:
+                                return templateStringListFields
+                        case TemplateFieldType.INTEGER:
+                                return templateIntegerFields
+                        case TemplateFieldType.DATE:
+                                return templateDateFields
+                        case TemplateFieldType.FLOAT:
+                                return templateFloatFields
+                        case TemplateFieldType.DOUBLE:
+                                return templateDoubleFields
+                        case TemplateFieldType.ONTOLOGYTERM:
+                                return templateTermFields
+                        default:
+                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
+                }
         }
 
@@ -39 +71 @@
                 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]
-                        case TemplateFieldType.DATE:
-                                return templateDateFields[fieldName]
-                        case TemplateFieldType.FLOAT:
-                                return templateFloatFields[fieldName]
-                        case TemplateFieldType.DOUBLE:
-                                return templateDoubleFields[fieldName]
-                        case TemplateFieldType.ONTOLOGYTERM:
-                                return templateTermFields[fieldName]
-                        default:
-                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
-                }
+                getStore(fieldType)[fieldName]
         }
 
@@ -73 +88 @@
                         if (templateStringListFields.containsKey(fieldName) && value.class == TemplateFieldListItem) {
                                 // TODO: check if item really belongs to the list under fieldName
-                                this.templateStringFields[fieldName] = value
+                                this.templateStringListFields[fieldName] = value
+                        }
+                        if (templateTextFields.containsKey(fieldName) && value.class == String) {
+                                this.templateTextFields[fieldName] = value
                         }
                         else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
@@ -95 +113 @@
                 }
         }
+
+
 
         def Set<TemplateField> giveFields() {
@@ -110 +130 @@
 
                 println "Setting template " + newTemplate
-                /*if (template == null || template instanceof NullObject) {} else{ // negation doesn't seem to work well
-                        def stringFields = template.getFieldsByType(TemplateFieldType.STRINGLIST)
+                if (template != null) {
+
+                        // Loop over all template field types and
+                        // That is inpossible in Java if the Maps are not yet set because the pointer is evaluated here
+
+                        // So this code is quite dangerous stuff:
+
+                        /*TemplateFieldType.list().each() { fieldType ->
+                                Set<TemplateFieldType> fields = template.getFieldsByType(fieldType)
+                                println fieldType
+                                println "before: " + getStore(fieldType)
+                                initFields(getStore(fieldType),fieldType.getDefaultValue(),fields)
+                                println "after: " + getStore(fieldType)
+
+                        }
+                        println "SF:" + templateStringListFields*/
+
+
+                        /*def type = TemplateFieldType.STRING
+                        //<T extends Annotation> T = type.getTypeClass().class
+                        def stringFields = template.getFieldsByType(TemplateFieldType.STRING)
+                        if (stringFields.size() > 0) {
+                                templateStringFields = new HashMap<String,String>(stringFields.size())
+                                stringFields.each {
+                                        templateStringFields.put(it.name,TemplateFieldType.STRING.getDefaultValue())
+                                }
+                                println templateStringFields
+                        }
+                        stringFields = template.getFieldsByType(TemplateFieldType.INTEGER)
                         println stringFields*.name
                         if (stringFields.size() > 0) {
-                                templateStringFields = new HashMap<String,String>()
-                                templateStringFields.keyset.add stringFields*.name;
-                                println templateStringFields
-                        }
-                }*/
+                                templateIntegerFields = new HashMap<String,Integer>(stringFields.size())
+                                stringFields.each {
+                                        templateIntegerFields.put(it.name,TemplateFieldType.INTEGER.getDefaultValue())
+                                }
+                        }*/
+                }
+        }
+
+        // Private function to initialize template field collections
+        private <T> void initFields(Map fieldCollection, T defaultValue, Set<TemplateFieldType> fields) {
+                if (fields.size() > 0) {
+                        fieldCollection = new HashMap<String,T>(fields.size());
+                        fields.each {
+                                fieldCollection.put(it.name,defaultValue);
+                        }
+                        println fieldCollection
+                }
         }
 
         /**
-         * Convenience method. Returns all unique templates within a collection of TemplateEntities.
+         * Convenience method. Returns all unique templates used within a collection of TemplateEntities.
          */
         static List<Template> giveTemplates(Set<TemplateEntity> entityCollection) {
@@ -128 +187 @@
         }
 
-        static Template giveTemplate(Set<TemplateEntity> entityCollection) {
+        /**
+         * Convenience method. Returns the template used within a collection of TemplateEntities.
+         * @throws NoSuchFieldException when 0 or multiple templates are used in the collection
+         * @return The template used by all members of a collection
+         */
+        static Template giveSingleTemplate(Set<TemplateEntity> entityCollection) {
                 def templates = giveTemplates(entityCollection);
                 if (templates.size() == 0) {

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

@@ -10 +10 @@
 public enum TemplateFieldType {
         STRING('String'),
+        TEXT('Long string'),
         INTEGER('Integer number'),
         FLOAT('Floating-point number'),
@@ -24 +25 @@
 
         static list() {
-                [STRING, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE]
+                [STRING, TEXT, INTEGER, FLOAT, DOUBLE, STRINGLIST, ONTOLOGYTERM, DATE]
+        }
+
+        def getDefaultValue() {
+                switch(this) {
+                        case [STRING, TEXT]:
+                                return ""
+                        case INTEGER:
+                                return Integer.MIN_VALUE
+                        case FLOAT:
+                                return Float.NaN
+                        case DOUBLE:
+                                return Double.MIN_VALUE
+                        case STRINGLIST:
+                                return null
+                        case ONTOLOGYTERM:
+                                return null
+                        case DATE:
+                                return null
+                        default:
+                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
+                }
         }