View Javadoc
1   /*
2    * Copyright 2008 FatWire Corporation. All Rights Reserved.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *    http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package com.fatwire.gst.foundation.facade.assetapi;
18  
19  import java.util.ArrayList;
20  import java.util.Arrays;
21  import java.util.Date;
22  import java.util.List;
23  
24  import com.fatwire.assetapi.common.AssetAccessException;
25  import com.fatwire.assetapi.query.Condition;
26  import com.fatwire.assetapi.query.ConditionFactory;
27  import com.fatwire.assetapi.query.OpTypeEnum;
28  import com.fatwire.assetapi.query.Query;
29  import com.fatwire.assetapi.query.QueryProperties;
30  import com.fatwire.assetapi.query.SimpleQuery;
31  import com.fatwire.assetapi.query.SortOrder;
32  
33  /**
34   * Builder for a SimpleQuery object.
35   * 
36   * @author Dolf Dijkstra
37   * @see SimpleQuery
38   */
39  
40  public class QueryBuilder {
41  
42      private static final String INITIALIZE_FIRST_MSG = "Condition not initialized.  Please set the condition first with QueryBuilder.condition(...).";
43              
44      private SimpleQuery query;
45  
46      private QueryProperties props() {
47          return query.getProperties();
48      }
49  
50      public QueryBuilder(String assetType, String subType) {
51          query = new SimpleQuery(assetType, subType);
52      }
53  
54      public QueryBuilder(String assetType) {
55          query = new SimpleQuery(assetType, null);
56      }
57  
58      public Query toQuery() {
59          return query;
60      }
61  
62      /**
63       * @param attributeName
64       * @see com.fatwire.assetapi.query.SimpleQuery#setAttributes(java.util.List)
65       */
66      public QueryBuilder attribute(String attributeName) {
67          List<String> old = new ArrayList<String>();
68          old.addAll(query.getAttributeNames());
69          old.add(attributeName);
70          query.setAttributes(old);
71          return this;
72      }
73  
74      /**
75       * @param attributeNames
76       * @see com.fatwire.assetapi.query.SimpleQuery#setAttributes(java.util.List)
77       */
78      public QueryBuilder attributes(String... attributeNames) {
79          List<String> old = new ArrayList<String>();
80          old.addAll(query.getAttributeNames());
81          old.addAll(Arrays.asList(attributeNames));
82          query.setAttributes(old);
83          return this;
84  
85      }
86  
87      /**
88       * @param sort
89       * @see com.fatwire.assetapi.query.SimpleQuery#setSortOrder(java.util.List)
90       */
91      public QueryBuilder setSortOrder(List<SortOrder> sort) {
92          query.setSortOrder(sort);
93          return this;
94      }
95  
96      /**
97       * @param fConfidence
98       * @see com.fatwire.assetapi.query.QueryProperties#setConfidence(float)
99       */
100     public QueryBuilder setConfidence(float fConfidence) {
101         props().setConfidence(fConfidence);
102         return this;
103     }
104 
105     /**
106      * @param fixedList
107      * @see com.fatwire.assetapi.query.QueryProperties#setFixedList(boolean)
108      */
109     public QueryBuilder setFixedList(boolean fixedList) {
110         props().setFixedList(fixedList);
111         return this;
112     }
113 
114     /**
115      * @param basicSearch
116      * @see com.fatwire.assetapi.query.QueryProperties#setIsBasicSearch(boolean)
117      */
118     public QueryBuilder setBasicSearch(boolean basicSearch) {
119         props().setIsBasicSearch(basicSearch);
120         return this;
121     }
122 
123     /**
124      * @param caseSensitive
125      * @see com.fatwire.assetapi.query.QueryProperties#setIsCaseSensitive(boolean)
126      */
127     public QueryBuilder setCaseSensitive(boolean caseSensitive) {
128         props().setIsCaseSensitive(caseSensitive);
129         return this;
130     }
131 
132     /**
133      * @param immediateOnly
134      * @see com.fatwire.assetapi.query.QueryProperties#setIsImmediateOnly(boolean)
135      */
136     public QueryBuilder setImmediateOnly(boolean immediateOnly) {
137         props().setIsImmediateOnly(immediateOnly);
138         return this;
139     }
140 
141     /**
142      * @param lowerEqual
143      * @see com.fatwire.assetapi.query.QueryProperties#setIsLowerEqual(boolean)
144      */
145     public QueryBuilder setLowerEqual(boolean lowerEqual) {
146         props().setIsLowerEqual(lowerEqual);
147         return this;
148     }
149 
150     /**
151      * @param upperEqual
152      * @see com.fatwire.assetapi.query.QueryProperties#setIsUpperEqual(boolean)
153      */
154     public QueryBuilder setUpperEqual(boolean upperEqual) {
155         props().setIsUpperEqual(upperEqual);
156         return this;
157     }
158 
159     /**
160      * @param loadDependency
161      * @see com.fatwire.assetapi.query.QueryProperties#setLoadDependency(int)
162      */
163     public QueryBuilder setLoadDependency(int loadDependency) {
164         props().setLoadDependency(loadDependency);
165         return this;
166     }
167 
168     /**
169      * @param maxAnswers
170      * @see com.fatwire.assetapi.query.QueryProperties#setMaxAnswers(int)
171      */
172     public QueryBuilder setMaxAnswers(int maxAnswers) {
173         props().setMaxAnswers(maxAnswers);
174         return this;
175     }
176 
177     /**
178      * @param maxRows
179      * @see com.fatwire.assetapi.query.QueryProperties#setMaxRows(int)
180      */
181     public QueryBuilder setMaxRows(int maxRows) {
182         props().setMaxRows(maxRows);
183         return this;
184     }
185 
186     /**
187      * @param parser
188      * @see com.fatwire.assetapi.query.QueryProperties#setParser(java.lang.String)
189      */
190     public QueryBuilder setParser(String parser) {
191         props().setParser(parser);
192         return this;
193     }
194 
195     /**
196      * @param readAll
197      * @see com.fatwire.assetapi.query.QueryProperties#setReadAll(boolean)
198      */
199     public QueryBuilder setReadAll(boolean readAll) {
200         props().setReadAll(readAll);
201         return this;
202     }
203 
204     /**
205      * @param site
206      * @see com.fatwire.assetapi.query.QueryProperties#setSite(java.lang.Long)
207      */
208     public QueryBuilder setSite(long site) {
209         props().setSite(site);
210         return this;
211     }
212 
213     /**
214      * @param startIndex
215      * @see com.fatwire.assetapi.query.QueryProperties#setStartIndex(int)
216      */
217     public QueryBuilder setStartIndex(int startIndex) {
218         props().setStartIndex(startIndex);
219         return this;
220     }
221 
222     public QueryBuilder condition(String condition) {
223 
224         Condition cond = new ConditionParser().parse(condition);
225         query.setCondition(cond);
226         return this;
227     }
228 
229     public QueryBuilder condition(String attName, OpTypeEnum opType, String value) {
230         Condition cond = ConditionFactory.createCondition(attName, opType, value);
231         query.setCondition(cond);
232         return this;
233     }
234 
235     public QueryBuilder condition(String attName, OpTypeEnum opType, Date value) {
236         Condition cond = ConditionFactory.createCondition(attName, opType, value);
237         query.setCondition(cond);
238         return this;
239     }
240 
241     public QueryBuilder condition(String attName, OpTypeEnum opType, Integer value) {
242         Condition cond = ConditionFactory.createCondition(attName, opType, value);
243         query.setCondition(cond);
244         return this;
245     }
246 
247     public QueryBuilder condition(String attName, OpTypeEnum opType, Float value) {
248         Condition cond = ConditionFactory.createCondition(attName, opType, value);
249         query.setCondition(cond);
250         return this;
251     }
252 
253     public QueryBuilder condition(String attName, OpTypeEnum opType, Long value) {
254         Condition cond = ConditionFactory.createCondition(attName, opType, value);
255         query.setCondition(cond);
256         return this;
257     }
258 
259     public QueryBuilder condition(String attName, OpTypeEnum opType, List<String> value) {
260         Condition cond = ConditionFactory.createCondition(attName, opType, value);
261         query.setCondition(cond);
262         return this;
263     }
264 
265     public QueryBuilder condition(String attName, OpTypeEnum opType, List<String> value, boolean containsAll) {
266         Condition cond = ConditionFactory.createCondition(attName, opType, value);
267         query.setCondition(cond);
268         return this;
269     }
270 
271     public QueryBuilder condition(String attName, OpTypeEnum opType, Date value, boolean caseSensiive,
272             boolean immediateOnly) {
273         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
274         query.setCondition(cond);
275         return this;
276     }
277 
278     public QueryBuilder condition(String attName, OpTypeEnum opType, Integer value, boolean caseSensiive,
279             boolean immediateOnly) {
280         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
281         query.setCondition(cond);
282         return this;
283     }
284 
285     public QueryBuilder condition(String attName, OpTypeEnum opType, Float value, boolean caseSensiive,
286             boolean immediateOnly) {
287         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
288         query.setCondition(cond);
289         return this;
290     }
291 
292     public QueryBuilder condition(String attName, OpTypeEnum opType, Long value, boolean caseSensiive,
293             boolean immediateOnly) {
294         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
295         query.setCondition(cond);
296         return this;
297     }
298 
299     public QueryBuilder condition(String attName, OpTypeEnum opType, List<String> value, boolean caseSensiive,
300             boolean immediateOnly) {
301         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
302         query.setCondition(cond);
303         return this;
304     }
305 
306     public QueryBuilder between(String attName, Object lower, Object upper) {
307         Condition cond;
308         try {
309             cond = new ConditionFactory().createBetweenCondition(attName, lower, upper);
310         } catch (AssetAccessException e) {
311             throw new RuntimeAssetAccessException(e);
312         }
313         query.setCondition(cond);
314         return this;
315     }
316 
317     public QueryBuilder between(String attName, Object lower, Object upper, boolean lowerEqual, boolean upperEqual) {
318         Condition cond;
319         try {
320             cond = new ConditionFactory().createBetweenCondition(attName, lower, upper, lowerEqual, upperEqual);
321         } catch (AssetAccessException e) {
322             throw new RuntimeAssetAccessException(e);
323         }
324         query.setCondition(cond);
325         return this;
326     }
327 
328     public QueryBuilder or(String attName, OpTypeEnum opType, String value) {
329         Condition cond = ConditionFactory.createCondition(attName, opType, value);
330         Condition qc = query.getCondition();
331         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
332         query.setCondition(qc.or(cond));
333         return this;
334     }
335 
336     public QueryBuilder or(String attName, OpTypeEnum opType, Date value) {
337         Condition cond = ConditionFactory.createCondition(attName, opType, value);
338         Condition qc = query.getCondition();
339         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
340         query.setCondition(qc.or(cond));
341         return this;
342     }
343 
344     public QueryBuilder or(String attName, OpTypeEnum opType, Integer value) {
345         Condition cond = ConditionFactory.createCondition(attName, opType, value);
346         Condition qc = query.getCondition();
347         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
348         query.setCondition(qc.or(cond));
349         return this;
350     }
351 
352     public QueryBuilder or(String attName, OpTypeEnum opType, Float value) {
353         Condition cond = ConditionFactory.createCondition(attName, opType, value);
354         Condition qc = query.getCondition();
355         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
356         query.setCondition(qc.or(cond));
357         return this;
358     }
359 
360     public QueryBuilder or(String attName, OpTypeEnum opType, Long value) {
361         Condition cond = ConditionFactory.createCondition(attName, opType, value);
362         Condition qc = query.getCondition();
363         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
364         query.setCondition(qc.or(cond));
365         return this;
366     }
367 
368     public QueryBuilder or(String attName, OpTypeEnum opType, List<String> value) {
369         Condition cond = ConditionFactory.createCondition(attName, opType, value);
370         Condition qc = query.getCondition();
371         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
372         query.setCondition(qc.or(cond));
373         return this;
374     }
375 
376     public QueryBuilder or(String attName, OpTypeEnum opType, List<String> value, boolean containsAll) {
377         Condition cond = ConditionFactory.createCondition(attName, opType, value);
378         Condition qc = query.getCondition();
379         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
380         query.setCondition(qc.or(cond));
381         return this;
382     }
383 
384     public QueryBuilder or(String attName, OpTypeEnum opType, Date value, boolean caseSensiive, boolean immediateOnly) {
385         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
386         Condition qc = query.getCondition();
387         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
388         query.setCondition(qc.or(cond));
389         return this;
390     }
391 
392     public QueryBuilder or(String attName, OpTypeEnum opType, Integer value, boolean caseSensiive, boolean immediateOnly) {
393         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
394         Condition qc = query.getCondition();
395         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
396         query.setCondition(qc.or(cond));
397         return this;
398     }
399 
400     public QueryBuilder or(String attName, OpTypeEnum opType, Float value, boolean caseSensiive, boolean immediateOnly) {
401         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
402         Condition qc = query.getCondition();
403         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
404         query.setCondition(qc.or(cond));
405         return this;
406     }
407 
408     public QueryBuilder or(String attName, OpTypeEnum opType, Long value, boolean caseSensiive, boolean immediateOnly) {
409         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
410         Condition qc = query.getCondition();
411         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
412         query.setCondition(qc.or(cond));
413         return this;
414     }
415 
416     public QueryBuilder or(String attName, OpTypeEnum opType, List<String> value, boolean caseSensiive,
417             boolean immediateOnly) {
418         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
419         Condition qc = query.getCondition();
420         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
421         query.setCondition(qc.or(cond));
422         return this;
423     }
424 
425     public QueryBuilder and(String attName, OpTypeEnum opType, String value) {
426         Condition cond = ConditionFactory.createCondition(attName, opType, value);
427         Condition qc = query.getCondition();
428         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
429         query.setCondition(qc.and(cond));
430         return this;
431     }
432 
433     public QueryBuilder and(String attName, OpTypeEnum opType, Date value) {
434         Condition cond = ConditionFactory.createCondition(attName, opType, value);
435         Condition qc = query.getCondition();
436         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
437         query.setCondition(qc.and(cond));
438         return this;
439     }
440 
441     public QueryBuilder and(String attName, OpTypeEnum opType, Integer value) {
442         Condition cond = ConditionFactory.createCondition(attName, opType, value);
443         Condition qc = query.getCondition();
444         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
445         query.setCondition(qc.and(cond));
446         return this;
447     }
448 
449     public QueryBuilder and(String attName, OpTypeEnum opType, Float value) {
450         Condition cond = ConditionFactory.createCondition(attName, opType, value);
451         Condition qc = query.getCondition();
452         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
453         query.setCondition(qc.and(cond));
454         return this;
455     }
456 
457     public QueryBuilder and(String attName, OpTypeEnum opType, Long value) {
458         Condition cond = ConditionFactory.createCondition(attName, opType, value);
459         Condition qc = query.getCondition();
460         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
461         query.setCondition(qc.and(cond));
462         return this;
463     }
464 
465     public QueryBuilder and(String attName, OpTypeEnum opType, List<String> value) {
466         Condition cond = ConditionFactory.createCondition(attName, opType, value);
467         Condition qc = query.getCondition();
468         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
469         query.setCondition(qc.and(cond));
470         return this;
471     }
472 
473     public QueryBuilder and(String attName, OpTypeEnum opType, List<String> value, boolean containsAll) {
474         Condition cond = ConditionFactory.createCondition(attName, opType, value);
475         Condition qc = query.getCondition();
476         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
477         query.setCondition(qc.and(cond));
478         return this;
479     }
480 
481     public QueryBuilder and(String attName, OpTypeEnum opType, Date value, boolean caseSensiive, boolean immediateOnly) {
482         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
483         Condition qc = query.getCondition();
484         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
485         query.setCondition(qc.and(cond));
486         return this;
487     }
488 
489     public QueryBuilder and(String attName, OpTypeEnum opType, Integer value, boolean caseSensiive,
490             boolean immediateOnly) {
491         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
492         Condition qc = query.getCondition();
493         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
494         query.setCondition(qc.and(cond));
495         return this;
496     }
497 
498     public QueryBuilder and(String attName, OpTypeEnum opType, Float value, boolean caseSensiive, boolean immediateOnly) {
499         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
500         Condition qc = query.getCondition();
501         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
502         query.setCondition(qc.and(cond));
503         return this;
504     }
505 
506     public QueryBuilder and(String attName, OpTypeEnum opType, Long value, boolean caseSensiive, boolean immediateOnly) {
507         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
508         Condition qc = query.getCondition();
509         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
510         query.setCondition(qc.and(cond));
511         return this;
512     }
513 
514     public QueryBuilder and(String attName, OpTypeEnum opType, List<String> value, boolean caseSensiive,
515             boolean immediateOnly) {
516         Condition cond = ConditionFactory.createCondition(attName, opType, value, caseSensiive, immediateOnly);
517         Condition qc = query.getCondition();
518         if (qc == null) throw new RuntimeAssetAccessException(INITIALIZE_FIRST_MSG);
519         query.setCondition(qc.and(cond));
520         return this;
521     }
522 }