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

Last change on this file since 299 was 299, checked in by duh, 9 years ago
  • set keyword expansion
  • Property svn:keywords set to Date Rev Author
File size: 5.6 KB
Line 
1package dbnp.studycapturing
2
3import dbnp.data.Term
4
5/**
6 * TemplateEntity Domain Class
7 *
8 * Revision information:
9 * $Rev: 299 $
10 * $Author: duh $
11 * $Date: 2010-03-22 13:40:35 +0000 (ma, 22 mrt 2010) $
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 entity
73         * @param fieldName The name of the template 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        /**
84         * Set a template/entity field value
85         * @param fieldName The name of the template or entity field
86         * @param value The value to be set, this should align with the (template) field type, but there are some convenience setters
87         *
88         */
89        def setFieldValue(String fieldName, value) {
90
91                // First, search if there is an entity property with the given name, and if so, set that
92                if (this.properties.containsKey(fieldName)) {
93                        this[fieldName] = value
94                }
95                // If not the found, then it is a template field, so check if there is a template
96                else if (template == null) {
97                        throw new NoSuchFieldException("Field ${fieldName} not found in class properties: template not set")
98                }
99                // If there is a template, check the template fields
100                else {
101                        // Find the target template field, if not found, throw an error
102                        TemplateField field = this.template.fields.find { it.name == fieldName}
103                        if (field == null) {
104                                throw new NoSuchFieldException("Field ${fieldName} not found in class properties or template fields")
105                        }
106                        // Set the value of the found template field
107                        else {
108                                // Convenience setter for template string list fields: find TemplateFieldListItem by name
109                                if (field.type == TemplateFieldType.STRINGLIST && value.class == String) {
110                                        value = field.listEntries.find { it.name == value }
111                                }
112
113                                // Convenience setter for dates: handle string values for date fields
114                                if (field.type == TemplateFieldType.DATE && value.class == String) {
115                                        // a string was given, attempt to transform it into a date instance
116                                        // and -for now- assume the dd/mm/yyyy format
117                                        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,})/
118                                        if (dateMatch.matches()) {
119                                                // create limited 'autosensing' datetime parser
120                                                // assume dd mm yyyy  or dd mm yy
121                                                def parser = 'd' + dateMatch[0][2] + 'M' + dateMatch[0][4] + (((dateMatch[0][5] as int) > 999) ? 'yyyy' : 'yy')
122
123                                                // add time as well?
124                                                if (dateMatch[0][7] != null) {
125                                                        parser += dateMatch[0][6] + 'HH:mm'
126                                                }
127
128                                                value = new Date().parse(parser, value)
129                                        }
130                                }
131
132                                // Set the field value
133                                // Caution: this assumes that all template...Field Maps are already initialized (as is done now above as [:])
134                                // If that is ever changed, the results are pretty much unpredictable (random Java object pointers?)!
135                                getStore(field.type)[fieldName] = value
136                                return this
137                        }
138                }
139        }
140
141        def Set<TemplateField> giveFields() {
142                return this.template.fields;
143        }
144
145
146        // See revision 237 for ideas about initializing the different templateField Maps
147        // with tailored Maps that already contain the neccessary keys
148        /**
149         * Convenience method. Returns all unique templates used within a collection of TemplateEntities.
150         */
151        static List<Template> giveTemplates(Set<TemplateEntity> entityCollection) {
152                return entityCollection*.template.unique();
153        }
154
155        /**
156         * Convenience method. Returns the template used within a collection of TemplateEntities.
157         * @throws NoSuchFieldException when 0 or multiple templates are used in the collection
158         * @return The template used by all members of a collection
159         */
160        static Template giveSingleTemplate(Set<TemplateEntity> entityCollection) {
161                def templates = giveTemplates(entityCollection);
162                if (templates.size() == 0) {
163                        throw new NoSuchFieldException("No templates found in collection!")
164                }
165                else if (templates.size() == 1) {
166                        return templates[0];
167                }
168                else {
169                        throw new NoSuchFieldException("Multiple templates found in collection!")
170                }
171        }
172
173        def validate() {
174                return super.validate()
175        }
176}
Note: See TracBrowser for help on using the repository browser.