root/trunk/grails-app/domain/dbnp/studycapturing/TemplateEntity.groovy @ 228

Revision 228, 4.7 KB (checked in by keesvb, 4 years ago)

study template convenience methods

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 templateStringListFields
12        Map templateIntegerFields
13        Map templateFloatFields
14        Map templateDoubleFields
15        Map templateDateFields
16        Map templateTermFields
17
18        static hasMany = [
19                templateStringFields: String,
20                templateStringListFields: TemplateFieldListItem,
21                templateIntegerFields: int,
22                templateFloatFields: float,
23                templateDoubleFields: double,
24                templateDateFields: Date,
25                templateTermFields: Term
26        ]
27
28        static constraints = {
29                template(nullable: true)
30        }
31
32        /**
33         * Find a template field by its name and return its value for this subject
34         * @param fieldName The name of the template subject field
35         * @return the value of the field (class depends on the field type)
36         * @throws NoSuchFieldException If the field is not found or the field type is not supported
37         */
38        def getFieldValue(String fieldName) {
39                TemplateFieldType fieldType = template.getFieldType(fieldName)
40                if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
41                switch(fieldType) {
42                        case [TemplateFieldType.STRING, TemplateFieldType.STRINGLIST]:
43                                return templateStringFields[fieldName]
44                        case [TemplateFieldType.STRINGLIST]:
45                                return templateStringListFields[fieldName]
46                        case TemplateFieldType.INTEGER:
47                                return templateIntegerFields[fieldName]
48                        case TemplateFieldType.DATE:
49                                return templateDateFields[fieldName]
50                        case TemplateFieldType.FLOAT:
51                                return templateFloatFields[fieldName]
52                        case TemplateFieldType.DOUBLE:
53                                return templateDoubleFields[fieldName]
54                        case TemplateFieldType.ONTOLOGYTERM:
55                                return templateTermFields[fieldName]
56                        default:
57                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
58                }
59        }
60
61        def setFieldValue(String fieldName, value) {
62                if (this.properties.containsKey(fieldName)) {
63                        this[fieldName] = value
64                }
65                else
66                if (template == null) {
67                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties")
68                }
69                else {
70                        if (templateStringFields.containsKey(fieldName) && value.class == String) {
71                                this.templateStringFields[fieldName] = value
72                        }
73                        if (templateStringListFields.containsKey(fieldName) && value.class == TemplateFieldListItem) {
74                                // TODO: check if item really belongs to the list under fieldName
75                                this.templateStringFields[fieldName] = value
76                        }
77                        else if (templateIntegerFields.containsKey(fieldName) && value.class == Integer) {
78                                this.templateIntegerFields[fieldName] = value
79                        }
80                        else if (templateFloatFields.containsKey(fieldName) && value.class == Float) {
81                                this.templateFloatFields[fieldName] = value
82                        }
83                        else if (templateDoubleFields.containsKey(fieldName) && value.class == Double) {
84                                this.templateDoubleFields[fieldName] = value
85                        }
86                        else if (templateDateFields.containsKey(fieldName) && value.class == Date) {
87                                this.templateDateFields[fieldName] = value
88                        }
89                        else if (templateTermFields.containsKey(fieldName) && value.class == Term) {
90                                this.templateTermFields[fieldName] = value
91                        }
92                        else {
93                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
94                        }
95                }
96        }
97
98        def Set<TemplateField> giveFields() {
99                return this.template.fields;
100        }
101
102        @Override
103        void setTemplate(Template newTemplate) {
104
105                // Contrary to expectation, this method does not cause an infinite loop but calls the super method
106                // whereas super.setTemplate(newTemplate) leads to errors concerning NullObject values
107                this.template = newTemplate
108
109                // TODO: initialize all template fields with the necessary keys and null values
110
111                println "Setting template " + newTemplate
112                /*if (template == null || template instanceof NullObject) {} else{ // negation doesn't seem to work well
113                        def stringFields = template.getFieldsByType(TemplateFieldType.STRINGLIST)
114                        println stringFields*.name
115                        if (stringFields.size() > 0) {
116                                templateStringFields = new HashMap<String,String>()
117                                templateStringFields.keyset.add stringFields*.name;
118                                println templateStringFields
119                        }
120                }*/
121        }
122
123        /**
124         * Convenience method. Returns all unique templates within a collection of TemplateEntities.
125         */
126        static List<Template> giveTemplates(Set<TemplateEntity> entityCollection) {
127                return entityCollection*.template.unique();
128        }
129
130        static Template giveTemplate(Set<TemplateEntity> entityCollection) {
131                def templates = giveTemplates(entityCollection);
132                if (templates.size() == 0) {
133                        throw new NoSuchFieldException("No templates found in collection!")
134                }
135                else if (templates.size() == 1) {
136                        return templates[0];
137                }
138                else {
139                        throw new NoSuchFieldException("Multiple templates found in collection!")
140                }
141        }
142
143}
Note: See TracBrowser for help on using the browser.