source: trunk/src/groovy/dbnp/query/Search.groovy @ 1415

Last change on this file since 1415 was 1415, checked in by robert@…, 10 years ago

First version of advanced querying

File size: 6.1 KB
Line 
1/**
2 * Search Domain Class
3 *
4 * Abstract class containing search criteria and search results when querying.
5 * Should be subclassed in order to enable searching for different entities.
6 *
7 * @author  Robert Horlings (robert@isdat.nl)
8 * @since       20110118
9 * @package     dbnp.query
10 *
11 * Revision information:
12 * $Rev$
13 * $Author$
14 * $Date$
15 */
16package dbnp.query
17
18import java.util.List;
19
20class Search {
21        public String entity;
22
23        protected List criteria;
24        protected List results;
25        protected String view = "results";
26
27        public List getCriteria() { return criteria; }
28        public void setCriteria( List c ) { criteria = c; }
29
30        public List getResults() { return results; }
31        public void setResults( List r ) { results = r; }
32
33        public String getView() { return view; }
34        public void setView( String v) { view = v; }
35
36        /**
37         * Returns the number of results found by this search
38         * @return
39         */
40        public int getNumResults() {
41                if( results )
42                        return results.size();
43
44                return 0;
45        }
46
47        /**
48         * Executes a search based on the given criteria. Should be filled in by
49         * subclasses searching for a specific entity
50         *
51         * @param       c       List with criteria to search on
52         */
53        public void execute( List c ) {
54                setCriteria( c );
55                execute();
56        }
57
58        /**
59         * Executes a search based on the given criteria. Should be filled in by
60         * subclasses searching for a specific entity
61         */
62        public void execute() {}
63
64        /**
65         * Returns a list of criteria targeted on the given entity
66         * @param entity        Entity to search criteria for
67         * @return                      List of criteria
68         */
69        protected List getEntityCriteria( String entity ) {
70                return criteria?.findAll { it.entity == entity }
71        }
72
73        /**
74         * Filters a list with entities, based on the given criteria and a closure to check whether a criterium is matched
75         *
76         * @param entities      Original list with entities to check for these criteria
77         * @param criteria      List with criteria to match on
78         * @param check         Closure to see whether a specific entity matches a criterium. Gets two arguments:
79         *                                              element         The element to check
80         *                                              criterium       The criterium to check on.
81         *                                      Returns true if the criterium holds, false otherwise
82         * @return                      The filtered list of entities
83         */
84        protected List filterEntityList( List entities, List criteria, Closure check ) {
85                if( !entities || !criteria || criteria.size() == 0 ) {
86                        return entities;
87                }
88
89                return entities.findAll { entity ->
90                        for( def criterium in criteria ) {
91                                println "Check " + entity + " for " + criterium
92                                if( !check( entity, criterium ) ) {
93                                        return false;
94                                }
95                        }
96                        return true;
97                }
98        }
99
100        /**
101         * Tries to match a value against a criterium and returns true if it matches
102         *
103         * @param value         Value of the field to match
104         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
105         * @return                      True iff the value matches this criterium, false otherwise
106         */
107        protected boolean compare( def value, def criterium ) {
108                switch( value.class.getName() ) {
109                        // TODO: Make the search capable of handle RelTime fields
110                        case "java.lang.Long":                  return longCompare( value, criterium );
111                        case "java.lang.Double":                return doubleCompare( value, criterium );
112                        case "java.lang.Boolean":               return booleanCompare( value, criterium );
113                        case "java.lang.Date":                  return dateCompare( value, criterium );
114                        case "AssayModule":
115                        case "Template":
116                        case "RelTime":
117                        case "Term":
118                        case "TemplateFieldListItem":
119                        default:                                                return stringCompare( value.toString(), criterium );
120                }
121        }
122
123        /**
124         * Tries to match a string value against a criterium and returns true if it matches
125         *
126         * @param value         String value of the field to match
127         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
128         * @return                      True iff the value matches this criterium, false otherwise
129         */
130        protected boolean stringCompare( String value, def criterium ) {
131                try {
132                        String stringCriterium = criterium.value.toString().trim()
133                        return value.trim().equals( stringCriterium );
134                } catch( Exception e ) {
135                        return false;
136                }
137        }
138
139        /**
140         * Tries to match a date value against a criterium and returns true if it matches
141         *
142         * @param value         Date value of the field to match
143         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
144         * @return                      True iff the value matches this criterium, false otherwise
145         */
146        protected boolean dateCompare( Date value, def criterium ) {
147                try {
148                        Date dateCriterium = DateFormat.parse( criterium.value );
149                        return value.equals( dateCriterium );
150                } catch( Exception e ) {
151                        return false;
152                }
153        }
154
155        /**
156         * Tries to match a long value against a criterium and returns true if it matches
157         *
158         * @param value         Long value of the field to match
159         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
160         * @return                      True iff the value matches this criterium, false otherwise
161         */
162        protected boolean longCompare( Long value, def criterium ) {
163                try {
164                        Long longCriterium = Long.parseLong( criterium.value );
165                        return value.equals( longCriterium );
166                } catch( Exception e ) {
167                        return false;
168                }
169        }
170
171        /**
172         * Tries to match a double value against a criterium and returns true if it matches
173         *
174         * @param value         Double value of the field to match
175         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
176         * @return                      True iff the value matches this criterium, false otherwise
177         */
178        protected boolean doubleCompare( Double value, def criterium ) {
179                try {
180                        Double doubleCriterium = Double.parseDouble( criterium.value );
181                        return value.equals( doubleCriterium );
182                } catch( Exception e ) {
183                        return false;
184                }
185        }
186
187
188        /**
189         * Tries to match a boolean value against a criterium and returns true if it matches
190         *
191         * @param value         Boolean value of the field to match
192         * @param criterium     Criterium to match on. Should be a map with entries 'operator' and 'value'
193         * @return                      True iff the value matches this criterium, false otherwise
194         */
195        protected boolean booleanCompare( Double value, def criterium ) {
196                try {
197                        Boolean booleanCriterium = Boolean.parseBoolean( criterium.value );
198                        return value.equals( booleanCriterium );
199                } catch( Exception e ) {
200                        return false;
201                }
202        }
203}
Note: See TracBrowser for help on using the repository browser.