root/trunk/src/groovy/dbnp/query/Criterion.groovy @ 1458

Revision 1458, 9.2 KB (checked in by robert@…, 3 years ago)

- Implemented a cache for module rest calls, to increase performance (see moduleCommunicationService)
- Implemented searching in module data.

  • Property svn:keywords set to Rev Author Date
Line 
1package dbnp.query
2
3import java.text.SimpleDateFormat
4import org.dbnp.gdt.*
5
6/**
7 * Available operators for criteria
8 * @author robert
9 *
10 */
11enum Operator {
12        equals, contains, gte, gt, lte, lt
13}
14
15/**
16 * Represents a criterion to search on
17 * @author robert
18 *
19 */
20class Criterion {
21        public String entity
22        public String field
23        public Operator operator
24        public def value
25
26        /**
27         * Retrieves the correct value for this criterion in the given object (with template)
28         *
29         * @param entity                Entity to check for value. Should be a child of template entity
30         * @param criterion     Criterion to match on
31         * @return                      Value of the given field or null if the field doesn't exist
32         */
33        public def getFieldValue( TemplateEntity entity ) {
34                if( entity == null )
35                        return null;
36
37                try {
38                        def fieldValue
39                        if( field == "Template" ) {
40                                fieldValue = entity.template?.name
41                        } else {
42                                fieldValue = Search.prepare( entity.getFieldValue( field ), entity.giveFieldType( field ) )
43                        }
44
45                        return fieldValue
46                } catch( Exception e ) {
47                        // An exception occurs if the given field doesn't exist. In that case, this criterion will fail.
48                        // TODO: Maybe give the user a choice whether he want's to include these studies or not
49                        return null;
50                }
51        }
52
53        /**
54         * Checks if the given object (with template) that satisfies the given criterion.
55         *
56         * @param entity                Entity to check for criterion satisfaction. Should be a child of template entity
57         * @param criterion     Criterion to match on
58         * @return                      True iff there the entity satisfies the given criterion.
59         */
60        public boolean matchEntity( TemplateEntity entity ) {
61                def fieldValue = this.getFieldValue( entity );
62
63                // Null is returned, the given field doesn't exist. In that case, this criterion will fail.
64                // TODO: Maybe give the user a choice whether he want's to include these studies or not
65                if( fieldValue == null )
66                        return false;
67
68                return this.match( fieldValue );
69        }
70
71        /**
72         * Checks for all entities in the given entityList, if there is any object that satisfies the given criterion.
73         *
74         * @param entityList    List with entities. The entities should be child classes of TemplateEntity
75         * @param criterion             Criterion to match on
76         * @return                              True iff there is any entity in the list that satisfies the given criterion.
77         */
78        public boolean matchAnyEntity( List<TemplateEntity> entityList ) {
79                for( entity in entityList ) {
80                        if( matchOneEntity( entity ) )
81                                return true;
82                }
83                return false;
84        }
85
86        /**
87         * Checks for all entities in the given entityList, if all objects satisfy the given criterion.
88         *
89         * @param entityList    List with entities. The entities should be child classes of TemplateEntity
90         * @param criterion             Criterion to match on
91         * @return                              True iff all entities satisfy the given criterion.
92         */
93        public boolean matchAllEntities( List<TemplateEntity> entityList ) {
94                for( entity in entityList ) {
95                        if( !matchOneEntity( entity ) )
96                                return false;
97                }
98                return true;
99        }
100
101        /**
102         * Checks for all values in the given List, if there is any value that satisfies the given criterion.
103         *
104         * @param entityList            List with values.
105         * @param criterion             Criterion to match on
106         * @return                              True iff there is any value in the list that satisfies the given criterion.
107         */
108        public boolean matchAny( List valueList ) {
109                for( value in valueList ) {
110                        if( match( value ) )
111                                return true;
112                }
113                return false;
114        }
115
116        /**
117         * Checks for all values in the given List, if all values satisfy the given criterion.
118         *
119         * @param entityList            List with values.
120         * @param criterion             Criterion to match on
121         * @return                              True iff all values satisfy the given criterion.
122         */
123        public boolean matchAll( List entityList ) {
124                for( value in valueList ) {
125                        if( !match( value ) )
126                                return false;
127                }
128                return true;
129        }
130
131        /**
132         * Tries to match a value against a criterion and returns true if it matches
133         *
134         * @param value         Value of the field to match
135         * @return                      True iff the value matches this criterion, false otherwise
136         */
137        public boolean match( def fieldValue ) {
138                if( fieldValue == null )
139                        return false;
140
141                def classname = fieldValue.class.getName();
142                classname = classname[classname.lastIndexOf( '.' ) + 1..-1].toLowerCase();
143
144                println "Match " + fieldValue + " of class " + classname + " with " + this
145
146                try {
147                        switch( classname ) {
148                                case "integer":                                 return longCompare( new Long( fieldValue.longValue() ) );
149                                case "long":                                    return longCompare( fieldValue );
150                                case "float":                                   return doubleCompare( new Long( fieldValue.doubleValue() ) );
151                                case "double":                                  return doubleCompare( fieldValue );
152                                case "boolean":                                 return booleanCompare( fieldValue );
153                                case "date":                                    return dateCompare( fieldValue);
154                                case "reltime":                                 return relTimeCompare( fieldValue );
155                                case "assaymodule":
156                                case "template":
157                                case "term":
158                                case "templatefieldlistitem":
159                                case "string":
160                                default:                                                return compareValues( fieldValue.toString().trim().toLowerCase(), this.operator, value.toString().toLowerCase().trim() );
161                        }
162                } catch( Exception e ) {
163                        log.error e.class.getName() + ": " + e.getMessage();
164                        return false;
165                }
166        }
167
168        /**
169         * Tries to match a value against a criterion and returns true if it matches
170         *
171         * @param fieldValue            Value of the field to match
172         * @param operator                      Operator to apply
173         * @param criterionValue        Value of the criterion
174         * @return                                      True iff the value matches this criterion value, false otherwise
175         */
176        protected boolean compareValues( def fieldValue, Operator operator, def criterionValue ) {
177                switch( operator ) {
178                        case Operator.gte:
179                                return fieldValue >= criterionValue;
180                        case Operator.gt:
181                                return fieldValue > criterionValue;
182                        case Operator.lt:
183                                return fieldValue < criterionValue;
184                        case Operator.lte:
185                                return fieldValue <= criterionValue;
186                        case Operator.contains:
187                                return fieldValue.contains( criterionValue );
188                        case Operator.equals:
189                        default:
190                                return fieldValue.equals( criterionValue );
191                }
192
193        }
194
195        /**
196         * Tries to match a date value against a criterion and returns true if it matches
197         *
198         * @param value         Date value of the field to match
199         * @return                      True iff the value matches this criterion, false otherwise
200         */
201        protected boolean dateCompare( Date fieldValue ) {
202                try {
203                        Date dateCriterion = new SimpleDateFormat( "yyyy-MM-dd" ).parse( value );
204                        Date fieldDate = new Date( fieldValue.getTime() );
205
206                        // Clear time in order to just compare dates
207                        dateCriterion.clearTime();
208                        fieldDate.clearTime();
209
210                        return compareValues( fieldDate, this.operator, dateCriterion )
211                } catch( Exception e ) {
212                        log.error e.class.getName() + ": " + e.getMessage();
213                        return false;
214                }
215        }
216
217        /**
218         * Tries to match a long value against a criterion and returns true if it matches
219         *
220         * @param value         Long value of the field to match
221         * @param criterion     Criterion to match on. Should be a map with entries 'operator' and 'value'
222         * @return                      True iff the value matches this criterion, false otherwise
223         */
224        protected boolean longCompare( Long fieldValue ) {
225                Long longCriterion;
226                try {
227                        longCriterion = Long.parseLong( value );
228                } catch( Exception e ) {
229                        try {
230                                // If converting to long doesn't work, try converting to double and rounding it
231                                Double doubleCriterion = Double.parseDouble(value);
232                                longCriterion = new Long( doubleCriterion.longValue() );
233                        } catch( Exception e2 ) {
234                                log.error e2.class.getName() + ": " + e2.getMessage();
235                                return false;
236                        }
237                }
238                return compareValues( fieldValue, this.operator, longCriterion );
239        }
240
241        /**
242         * Tries to match a double value against a criterion and returns true if it matches
243         *
244         * @param value         Double value of the field to match
245         * @return                      True iff the value matches this criterion, false otherwise
246         */
247        protected boolean doubleCompare( Double fieldValue ) {
248                try {
249                        Double doubleCriterion = Double.parseDouble( value );
250                        return compareValues( fieldValue, this.operator, doubleCriterion );
251                } catch( Exception e ) {
252                        log.error e.class.getName() + ": " + e.getMessage();
253                        return false;
254                }
255        }
256
257
258        /**
259         * Tries to match a boolean value against a criterion and returns true if it matches
260         *
261         * @param value         Boolean value of the field to match
262         * @return                      True iff the value matches this criterion, false otherwise
263         */
264        protected boolean booleanCompare( Boolean fieldValue ) {
265                try {
266                        Boolean booleanCriterion = Boolean.parseBoolean( value );
267                        return compareValues( fieldValue, this.operator, booleanCriterion );
268                } catch( Exception e ) {
269                        log.error e.class.getName() + ": " + e.getMessage();
270                        return false;
271                }
272        }
273
274        /**
275         * Tries to match a relTime value against a criterion and returns true if it matches
276         *
277         * @param value         relTime value of the field to match
278         * @return                      True iff the value matches this criterion, false otherwise
279         */
280        protected boolean relTimeCompare( RelTime fieldValue ) {
281                try {
282                        RelTime rt
283
284                        // Numbers are taken to be seconds, if a non-numeric value is given, try to parse it
285                        if( value.toString().isLong() ) {
286                                rt = new RelTime( Long.parseLong( value.toString() ) );
287                        } else {
288                                rt = new RelTime( value.toString() );
289                        }
290
291                        return compareValues( fieldValue, this.operator, rt );
292                } catch( Exception e ) {
293                        log.error e.class.getName() + ": " + e.getMessage();
294                        return false;
295                }
296        }
297
298        public String toString() {
299                return "[Criterion " + entity + "." + field + " " + operator + " " + value + "]";
300        }
301}
Note: See TracBrowser for help on using the browser.