source: trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy @ 238

Last change on this file since 238 was 238, checked in by duh, 9 years ago

Refectored version of the wizard

  • initial template page has been removed, now is a generic 'start' page where one (in the future) may create a new study, or load and modify an already stored study
  • study page incorporates study template select element, but does not yet incorporate the study template fields
  • subjects page now allows creation of subjects based on a template. This change also implied the study page altogether had to change into a seperate table entity. Now the the page lists as many tables as unique templates have been selected. These tables contain all subjects that were added using that particular template. NOTE: data is not stored yet, due to the fact that templateEntity does not work properly yey (key/value pairs need to be set correctly when calling the setTemplate method)
  • the JavaScript? now handles multiple tables in a page as well, and automatically initializes any underlying slider div if that is required
File size: 6.8 KB
Line 
1package dbnp.studycapturing
2
3import dbnp.data.Term
4import org.codehaus.groovy.runtime.NullObject
5
6/**
7 * TemplateEntity Domain Class
8 *
9 * Revision information:
10 * $Rev$
11 * $Author$
12 * $Date$
13 */
14class TemplateEntity implements Serializable {
15
16        Template template
17
18        Map templateStringFields = [:]
19        Map templateTextFields = [:]
20        Map templateStringListFields = [:]
21        Map templateIntegerFields = [:]
22        Map templateFloatFields = [:]
23        Map templateDoubleFields = [:]
24        Map templateDateFields = [:]
25        Map templateTermFields = [:]
26
27        static hasMany = [
28                templateStringFields: String,
29                templateTextFields: String,
30                templateStringListFields: TemplateFieldListItem,
31                templateIntegerFields: int,
32                templateFloatFields: float,
33                templateDoubleFields: double,
34                templateDateFields: Date,
35                templateTermFields: Term
36        ]
37
38        static constraints = {
39                template(nullable: true, blank: true)
40
41        }
42
43        static mapping = {
44                tablePerHierarchy false
45
46                templateTextFields type: 'text'
47        }
48
49        private Map getStore(TemplateFieldType fieldType) {
50                switch(fieldType) {
51                        case TemplateFieldType.STRING:
52                                return templateStringFields
53                        case TemplateFieldType.TEXT:
54                                return templateTextFields
55                        case TemplateFieldType.STRINGLIST:
56                                return templateStringListFields
57                        case TemplateFieldType.INTEGER:
58                                return templateIntegerFields
59                        case TemplateFieldType.DATE:
60                                return templateDateFields
61                        case TemplateFieldType.FLOAT:
62                                return templateFloatFields
63                        case TemplateFieldType.DOUBLE:
64                                return templateDoubleFields
65                        case TemplateFieldType.ONTOLOGYTERM:
66                                return templateTermFields
67                        default:
68                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
69                }
70        }
71
72        /**
73         * Find a template field by its name and return its value for this subject
74         * @param fieldName The name of the template subject field
75         * @return the value of the field (class depends on the field type)
76         * @throws NoSuchFieldException If the field is not found or the field type is not supported
77         */
78        def getFieldValue(String fieldName) {
79                TemplateFieldType fieldType = template.getFieldType(fieldName)
80                if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
81                getStore(fieldType)[fieldName]
82        }
83
84        def setFieldValue(String fieldName, value) {
85                if (this.properties.containsKey(fieldName)) {
86                        this[fieldName] = value
87                }
88                else
89                if (template == null) {
90                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties")
91                }
92                else {
93                        if (templateStringFields && templateStringFields.containsKey(fieldName) && value.class == String) {
94                                this.templateStringFields[fieldName] = value
95                        }
96                        if (templateStringFields && templateStringListFields.containsKey(fieldName) && value.class == TemplateFieldListItem) {
97                                // TODO: check if item really belongs to the list under fieldName
98                                this.templateStringListFields[fieldName] = value
99                        }
100                        if (templateTextFields.containsKey(fieldName) && value.class == String) {
101                                this.templateTextFields[fieldName] = value
102                        }
103                        else if (templateIntegerFields && templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
104                                this.templateIntegerFields[fieldName] = value
105                        }
106                        else if (templateFloatFields && templateFloatFields.containsKey(fieldName) && value.class == Float) {
107                                this.templateFloatFields[fieldName] = value
108                        }
109                        else if (templateDoubleFields && templateDoubleFields.containsKey(fieldName) && value.class == Double) {
110                                this.templateDoubleFields[fieldName] = value
111                        }
112                        else if (templateDateFields && templateDateFields.containsKey(fieldName) && value.class == Date) {
113                                this.templateDateFields[fieldName] = value
114                        }
115                        else if (templateTermFields && templateTermFields.containsKey(fieldName) && value.class == Term) {
116                                this.templateTermFields[fieldName] = value
117                        }
118                        else {
119                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
120                        }
121                }
122        }
123
124
125
126        def Set<TemplateField> giveFields() {
127                return this.template.fields;
128        }
129
130        @Override
131        void setTemplate(Template newTemplate) {
132
133                // Contrary to expectation, this method does not cause an infinite loop but calls the super method
134                // whereas super.setTemplate(newTemplate) leads to errors concerning NullObject values
135                this.template = newTemplate
136
137                // TODO: initialize all template fields with the necessary keys and null values
138
139                //println "Setting template " + newTemplate
140                if (template != null) {
141
142                        // Loop over all template field types and
143                        // That is inpossible in Java if the Maps are not yet set because the pointer is evaluated here
144
145                        // So this code is quite dangerous stuff:
146
147                        /*TemplateFieldType.list().each() { fieldType ->
148                                Set<TemplateFieldType> fields = template.getFieldsByType(fieldType)
149                                println fieldType
150                                println "before: " + getStore(fieldType)
151                                initFields(getStore(fieldType),fieldType.getDefaultValue(),fields)
152                                println "after: " + getStore(fieldType)
153
154                        }
155                        println "SF:" + templateStringListFields*/
156
157
158                        /*def type = TemplateFieldType.STRING
159                        //<T extends Annotation> T = type.getTypeClass().class
160                        def stringFields = template.getFieldsByType(TemplateFieldType.STRING)
161                        if (stringFields.size() > 0) {
162                                templateStringFields = new HashMap<String,String>(stringFields.size())
163                                stringFields.each {
164                                        templateStringFields.put(it.name,TemplateFieldType.STRING.getDefaultValue())
165                                }
166                                println templateStringFields
167                        }
168                        stringFields = template.getFieldsByType(TemplateFieldType.INTEGER)
169                        println stringFields*.name
170                        if (stringFields.size() > 0) {
171                                templateIntegerFields = new HashMap<String,Integer>(stringFields.size())
172                                stringFields.each {
173                                        templateIntegerFields.put(it.name,TemplateFieldType.INTEGER.getDefaultValue())
174                                }
175                        }*/
176                }
177        }
178
179        // Private function to initialize template field collections
180        private <T> void initFields(Map fieldCollection, T defaultValue, Set<TemplateFieldType> fields) {
181                if (fields.size() > 0) {
182                        fieldCollection = new HashMap<String,T>(fields.size());
183                        fields.each {
184                                fieldCollection.put(it.name,defaultValue);
185                        }
186                        println fieldCollection
187                }
188        }
189
190        /**
191         * Convenience method. Returns all unique templates used within a collection of TemplateEntities.
192         */
193        static List<Template> giveTemplates(Set<TemplateEntity> entityCollection) {
194                return entityCollection*.template.unique();
195        }
196
197        /**
198         * Convenience method. Returns the template used within a collection of TemplateEntities.
199         * @throws NoSuchFieldException when 0 or multiple templates are used in the collection
200         * @return The template used by all members of a collection
201         */
202        static Template giveSingleTemplate(Set<TemplateEntity> entityCollection) {
203                def templates = giveTemplates(entityCollection);
204                if (templates.size() == 0) {
205                        throw new NoSuchFieldException("No templates found in collection!")
206                }
207                else if (templates.size() == 1) {
208                        return templates[0];
209                }
210                else {
211                        throw new NoSuchFieldException("Multiple templates found in collection!")
212                }
213        }
214
215}
Note: See TracBrowser for help on using the repository browser.