source: trunk/grails-app/domain/dbnp/studycapturing/Template.groovy @ 556

Last change on this file since 556 was 556, checked in by roberth, 12 years ago

Improved the TemplateEditor? again: templates can be created and removed and some checks were built in to ensure that the same fields in different templates point to the same TemplateField? object.

  • Property svn:keywords set to Date Rev Author
File size: 3.7 KB
Line 
1package dbnp.studycapturing
2import java.lang.reflect.Method
3
4/**
5 * The Template class describes a study template, which is basically an extension of the study capture entities
6 * in terms of extra fields (described by classes that extend the TemplateField class).
7 * At this moment, only extension of the study and subject entities is implemented.
8 *
9 * Revision information:
10 * $Rev: 556 $
11 * $Author: roberth $
12 * $Date: 2010-06-10 14:45:53 +0000 (do, 10 jun 2010) $
13 */
14class Template implements Serializable {
15        String name
16        String description
17        Class entity
18        //nimble.User owner
19        List fields
20        static hasMany = [fields: TemplateField]
21
22        static constraints = {
23                description(nullable: true, blank: true)
24
25                fields(validator: { fields, obj, errors ->
26                        // 'obj' refers to the actual Template object
27
28                        // define a boolean
29                        def error = false
30
31                        // iterate through fields
32                        fields.each { field ->
33                                // check if the field entity is the same as the template entity
34                                if (!field.entity.equals(obj.entity)) {
35                                        error = true
36                                        errors.rejectValue(
37                                                'fields',
38                                                'templateEntity.entityMismatch',
39                                                [field.name, obj.entity, field.entity] as Object[],
40                                                'Template field {0} must be of entity {1} and is currently of entity {2}'
41                                                )
42                                }
43                        }
44
45                        // got an error, or not?
46                        return (!error)
47                })
48
49                // outcommented for now due to bug in Grails / Hibernate
50                // see http://jira.codehaus.org/browse/GRAILS-6020
51                //      name(unique:['entity'])
52        }
53
54        /**
55         * overloaded toString method
56         * @return String
57         */
58        def String toString() {
59                return this.name;
60        }
61
62        /**
63         * Look up the type of a certain template subject field
64         * @param String fieldName The name of the template field
65         * @return String       The type (static member of TemplateFieldType) of the field, or null of the field does not exist
66         */
67        def TemplateFieldType getFieldType(String fieldName) {
68                def field = fields.find {
69                        it.name == fieldName
70                }
71                field?.type
72        }
73
74        /**
75         * get all field of a particular type
76         * @param Class fieldType
77         * @return Set < TemplateField >
78         */
79        def getFieldsByType(TemplateFieldType fieldType) {
80                def result = fields.findAll {
81                        it.type == fieldType
82                }
83                return result;
84        }
85
86        /**
87         * get all required fields
88         * @param Class fieldType
89         * @return Set < TemplateField >
90         */
91        def getRequiredFields() {
92                def result = fields.findAll {
93                        it.required == true
94                }
95                return result;
96        }
97
98        /**
99         * Checks whether this template is used by any object
100         *
101         * @returns             true iff this template is used by any object, false otherwise
102         */
103        def inUse() {
104                return (numUses() > 0 );
105        }
106
107        /**
108         * The number of objects that use this template
109         *
110         * @returns             the number of objects that use this template.
111         */
112        def numUses() {
113                // This template can only be used in objects of the right entity. Find objects of that
114                // entity and see whether they use this method.
115                //
116                // Unfortunately, due to the grails way of creating classes, we can not use reflection for this
117                def elements;
118                switch( this.entity ) {
119                        case Event:
120                                elements = Event.findAllByTemplate( this ); break;
121                        case Sample:
122                                elements = Sample.findAllByTemplate( this ); break;
123                        case Study:
124                                elements = Study.findAllByTemplate( this ); break;
125                        case Subject:
126                                elements = Subject.findAllByTemplate( this ); break;
127                        default:
128                                return 0;
129                }
130
131                return elements.size();
132        }
133
134        /**
135         * overloading the findAllByEntity method to make it function as expected
136         * @param Class entity (for example: dbnp.studycapturing.Subject)
137         * @return ArrayList
138         */
139        public static findAllByEntity(java.lang.Class entity) {
140                def results = []
141                // 'this' should not work in static context, so taking Template instead of this
142                Template.findAll().each() {
143                        if (entity.equals(it.entity)) {
144                                results[results.size()] = it
145                        }
146                }
147
148                return results
149        }
150}
Note: See TracBrowser for help on using the repository browser.