source: trunk/src/groovy/dbnp/query/Criterion.groovy @ 1456

Last change on this file since 1456 was 1456, checked in by business@…, 9 years ago

moved gdt package to org.dbnp, moved tests for RelTime?, TemplateEntity?, Template etc. to gdt plugin

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