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

Last change on this file since 236 was 236, checked in by keesvb, 9 years ago

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

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