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

Revision 257, 4.8 KB (checked in by duh, 4 years ago)

- added limited auto parsing for DATE template entity values that are set as String instead of Date instances
- general improvements and bugfixes

  • Property svn:keywords set to Author Rev Date
Line 
1package dbnp.studycapturing
2
3import dbnp.data.Term
4
5/**
6 * TemplateEntity Domain Class
7 *
8 * Revision information:
9 * $Rev$
10 * $Author$
11 * $Date$
12 */
13class TemplateEntity implements Serializable {
14
15        Template template
16
17        Map templateStringFields = [:]
18        Map templateTextFields = [:]
19        Map templateStringListFields = [:]
20        Map templateIntegerFields = [:]
21        Map templateFloatFields = [:]
22        Map templateDoubleFields = [:]
23        Map templateDateFields = [:]
24        Map templateTermFields = [:]
25
26        static hasMany = [
27                templateStringFields: String,
28                templateTextFields: String,
29                templateStringListFields: TemplateFieldListItem,
30                templateIntegerFields: int,
31                templateFloatFields: float,
32                templateDoubleFields: double,
33                templateDateFields: Date,
34                templateTermFields: Term
35        ]
36
37        static constraints = {
38                template(nullable: true, blank: true)
39
40        }
41
42        static mapping = {
43                tablePerHierarchy false
44
45                templateTextFields type: 'text'
46        }
47
48        private Map getStore(TemplateFieldType fieldType) {
49                switch(fieldType) {
50                        case TemplateFieldType.STRING:
51                                return templateStringFields
52                        case TemplateFieldType.TEXT:
53                                return templateTextFields
54                        case TemplateFieldType.STRINGLIST:
55                                return templateStringListFields
56                        case TemplateFieldType.INTEGER:
57                                return templateIntegerFields
58                        case TemplateFieldType.DATE:
59                                return templateDateFields
60                        case TemplateFieldType.FLOAT:
61                                return templateFloatFields
62                        case TemplateFieldType.DOUBLE:
63                                return templateDoubleFields
64                        case TemplateFieldType.ONTOLOGYTERM:
65                                return templateTermFields
66                        default:
67                                throw new NoSuchFieldException("Field type ${fieldType} not recognized")
68                }
69        }
70
71        /**
72         * Find a template field by its name and return its value for this subject
73         * @param fieldName The name of the template subject field
74         * @return the value of the field (class depends on the field type)
75         * @throws NoSuchFieldException If the field is not found or the field type is not supported
76         */
77        def getFieldValue(String fieldName) {
78                TemplateFieldType fieldType = template.getFieldType(fieldName)
79                if (!fieldType) throw new NoSuchFieldException("Field name ${fieldName} not recognized")
80                getStore(fieldType)[fieldName]
81        }
82
83        def setFieldValue(String fieldName, value) {
84                if (this.properties.containsKey(fieldName)) {
85                        this[fieldName] = value
86                }
87                else
88                if (template == null) {
89                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties")
90                }
91                else {
92                        TemplateField field = this.template.fields.find { it.name == fieldName}
93                        if (field == null) {
94                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
95                        }
96                        else {
97                                if (field.type == TemplateFieldType.STRINGLIST && value.class == String) {
98                                        // Convenience setter: find template item by name
99                                        value = field.listEntries.find { it.name == value }
100                                }
101
102                                // handle string values for date fields
103                                if (field.type == TemplateFieldType.DATE && value.class == String) {
104                                        // a string was given, attempt to transform it into a date instance
105                                        // and -for now- assume the dd/mm/yyyy format
106                                        def dateMatch = value =~ /^([0-9]{1,})([^0-9]{1,})([0-9]{1,})([^0-9]{1,})([0-9]{1,})((([^0-9]{1,})([0-9]{1,2}):([0-9]{1,2})){0,})/
107                                        if (dateMatch.matches()) {
108                                                // create limited 'autosensing' datetime parser
109                                                // assume dd mm yyyy  or dd mm yy
110                                                def parser = 'd' + dateMatch[0][2] + 'M' + dateMatch[0][4] + (((dateMatch[0][5] as int) > 999) ? 'yyyy' : 'yy')
111
112                                                // add time as well?
113                                                if (dateMatch[0][7] != null) {
114                                                        parser += dateMatch[0][6] + 'HH:mm'
115                                                }
116
117                                                value = new Date().parse(parser, value)
118                                        }
119                                }
120
121                                // Caution: this assumes that all template...Field Maps are already initialized
122                                // Otherwise, the results are pretty much unpredictable!
123                                getStore(field.type)[fieldName] = value
124                                return this
125                        }
126                }
127        }
128
129
130
131        def Set<TemplateField> giveFields() {
132                return this.template.fields;
133        }
134
135
136        // See revision 237 for ideas about initializing the different templateField Maps
137        // with tailored Maps that already contain the neccessary keys
138        /**
139         * Convenience method. Returns all unique templates used within a collection of TemplateEntities.
140         */
141        static List<Template> giveTemplates(Set<TemplateEntity> entityCollection) {
142                return entityCollection*.template.unique();
143        }
144
145        /**
146         * Convenience method. Returns the template used within a collection of TemplateEntities.
147         * @throws NoSuchFieldException when 0 or multiple templates are used in the collection
148         * @return The template used by all members of a collection
149         */
150        static Template giveSingleTemplate(Set<TemplateEntity> entityCollection) {
151                def templates = giveTemplates(entityCollection);
152                if (templates.size() == 0) {
153                        throw new NoSuchFieldException("No templates found in collection!")
154                }
155                else if (templates.size() == 1) {
156                        return templates[0];
157                }
158                else {
159                        throw new NoSuchFieldException("Multiple templates found in collection!")
160                }
161        }
162
163}
Note: See TracBrowser for help on using the browser.