1
2 package org.weda.store.impl;
3
4 import org.apache.commons.beanutils.locale.LocaleConvertUtils;
5 import org.apache.commons.lang.StringUtils;
6 import org.apache.commons.logging.Log;
7 import org.apache.commons.logging.LogFactory;
8 import org.weda.enhance.InjectHivemindObject;
9 import org.weda.enhance.InjectMessages;
10 import org.weda.message.Messages;
11 import org.weda.converter.ValueTypeConverter;
12 import org.weda.converter.ValueTypeConverterException;
13 import org.weda.store.QueryFilterElement;
14 import org.weda.property.PropertyDescriptor;
15 import org.weda.store.QueryFilterElementException;
16
17 /**
18 *
19 * @author Mikhail Titov
20 */
21 public class QueryFilterElementImpl
22 implements Cloneable, QueryFilterElement
23 {
24 private final static String[] BETWEEN_OPERATOR = new String[]{"[", "]"};
25 private final static String[] IN_OPERATOR = new String[]{"{", "}"};
26 private final static String[] LIST_SEPARATORS = new String[]{"<,>", ","};
27
28 private final static Log log =
29 LogFactory.getLog(QueryFilterElementImpl.class);
30 protected static final String [] operators =
31 {">=", "<=", "<>", "=", ">", "<"};
32 private String id;
33 private ExpressionType expressionType = ExpressionType.EMPTY;
34 private OperatorType operatorType;
35 private String property;
36 private boolean enabled = true;
37 private boolean useAliasAsProperty = false;
38 private Class propertyClass;
39 private String pattern;
40 private String objectAlias;
41 private String parameterName;
42 private String staticExpression;
43 private String expression;
44 private String operator;
45 private Object value;
46 private PropertyDescriptor propertyDescriptor;
47
48 @InjectHivemindObject private static ValueTypeConverter converter;
49 @InjectMessages private Messages messages;
50
51 public String getId(){
52 return id;
53 }
54
55 public void setId(String id){
56 this.id = id;
57 }
58
59 public Object getValue() {
60 return value;
61 }
62
63 public void setValue(Object value) {
64 this.value = value;
65 }
66
67 public String getStaticExpression() {
68 return staticExpression;
69 }
70
71 public void setStaticExpression(String staticExpression) {
72 this.staticExpression = staticExpression;
73 }
74
75 public String getProperty() {
76 return property;
77 }
78
79 public void setProperty(String name) {
80 property = name;
81 }
82
83 public void setPattern(String pattern) {
84 this.pattern=pattern;
85 }
86
87 public String getObjectAlias() {
88 return objectAlias;
89 }
90
91 public void setObjectAlias(String objectAlias) {
92 this.objectAlias=objectAlias;
93 }
94
95 public Object getParameterValue() {
96 return value;
97 }
98
99 public ExpressionType getExpressionType() {
100 return expressionType;
101 }
102
103 public void setExpressionType(ExpressionType type) {
104 expressionType = type;
105 }
106
107 public String getOperator(){
108 return operator;
109 }
110
111 public void setOperator(String operator){
112 this.operator = operator;
113 }
114
115 public void setExpression(String expression)
116 throws QueryFilterElementException
117 {
118 expressionType = ExpressionType.OPERATOR;
119 String[] values = null;
120 if( expression == null || expression.trim().length() == 0 ){
121 expressionType = ExpressionType.EMPTY;
122 value = null;
123 operator = null;
124 }else{
125 expression = expression.trim();
126
127 if (expression.charAt(0) == '#'){
128 if (expression.length()==1){
129 expressionType = ExpressionType.EMPTY;
130 value = null;
131 operator = null;
132 }else{
133 expressionType = ExpressionType.COMPLETE;
134 value = expression.substring(1);
135 }
136 }else {
137 boolean isFound = false;
138
139 for( int i = 0; i < operators.length; ++i ){
140 if( expression.indexOf(operators[i]) == 0 ){
141 operator = operators[i];
142 value =
143 expression.substring(operators[i].length()).trim();
144 isFound = true;
145 operatorType = OperatorType.SIMPLE;
146 break;
147 }
148 }
149
150 if( !isFound ){
151
152 if ( expression.startsWith(BETWEEN_OPERATOR[0])
153 && expression.endsWith(BETWEEN_OPERATOR[1]))
154 {
155 values = extractValuesFromList(
156 expression.substring(1, expression.length()-1));
157 if (values==null || values.length!=2)
158 throw new QueryFilterElementException(
159 messages.format(
160 "BetweenOperatorError", expression));
161 operatorType = OperatorType.BETWEEN;
162 }else if ( expression.startsWith(IN_OPERATOR[0])
163 && expression.endsWith(IN_OPERATOR[1]))
164 {
165 values = extractValuesFromList(
166 expression.substring(1, expression.length()-1));
167 if (values==null || values.length==0)
168 throw new QueryFilterElementException(
169 messages.format(
170 "InOperatorError", expression));
171 operatorType = OperatorType.IN;
172 }else if( propertyClass.equals(java.lang.String.class)
173 && ( expression.indexOf("%") != -1
174 || expression.indexOf("_") != -1 ) )
175 {
176 isFound = true;
177 value = expression;
178
179 operatorType = OperatorType.LIKE;
180 }else{
181
182
183 operator = "=";
184 value = expression;
185 operatorType = operatorType.SIMPLE;
186 }
187 }
188 if (values == null)
189 value = convertStringToValueType(value);
190 else {
191 Object[] tempValues = new Object[values.length];
192 for (int i=0; i<values.length; ++i)
193 tempValues[i] = convertStringToValueType(values[i]);
194 value = tempValues;
195 }
196 }
197 }
198 this.expression=expression;
199 if (log.isDebugEnabled())
200 log.debug(
201 "Expression seted. Operator: "+operator+"; Value: "+value);
202 }
203
204 private static String[] extractValuesFromList(String listString)
205 throws QueryFilterElementException
206 {
207 for (String separator: LIST_SEPARATORS)
208 if (listString.contains(separator))
209 return listString.trim().split("\\s*"+separator+"\\s*");
210 return null;
211 }
212
213 private Object convertStringToValueType(Object value)
214 throws QueryFilterElementException
215 {
216 try{
217 return
218 converter.convert(
219 propertyClass
220 , value
221 , pattern == null?
222 propertyDescriptor.getPattern() : pattern);
223 }catch(ValueTypeConverterException e){
224 throw new QueryFilterElementException(
225 messages.format(
226 "ExpressionError"
227 , expression, propertyDescriptor.getDisplayName())
228 , e);
229 }
230 }
231
232 public void setPropertyDescriptor(PropertyDescriptor propertyDescriptor) {
233 this.propertyDescriptor=propertyDescriptor;
234 this.propertyClass=propertyDescriptor.getPropertyClass();
235 }
236
237 public PropertyDescriptor getPropertyDescriptor() {
238 return propertyDescriptor;
239 }
240
241 public String getExpression() {
242 return expression;
243 }
244
245 public boolean isEnabled() {
246 return enabled;
247 }
248
249 public void setEnabled(boolean enabled) {
250 this.enabled = enabled;
251 }
252
253 public boolean isUseAliasAsProperty() {
254 return useAliasAsProperty;
255 }
256
257 public void setUseAliasAsProperty(boolean useAliasAsProperty) {
258 this.useAliasAsProperty = useAliasAsProperty;
259 }
260
261 public Object clone() throws CloneNotSupportedException {
262 return super.clone();
263 }
264
265 public OperatorType getOperatorType() {
266 return operatorType;
267 }
268
269 public void setOperatorType(OperatorType operatorType) {
270 this.operatorType = operatorType;
271 }
272
273 public String getParameterName() {
274 return parameterName;
275 }
276
277 public void setParameterName(String parameterName) {
278 this.parameterName = parameterName;
279 }
280
281 }