View Javadoc

1   package org.andromda.cartridges.spring.metafacades;
2   
3   import org.andromda.cartridges.spring.SpringProfile;
4   import org.apache.commons.lang.BooleanUtils;
5   import org.apache.commons.lang.ObjectUtils;
6   import org.apache.commons.lang.StringUtils;
7   
8   
9   /**
10   * MetafacadeLogic implementation for org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute.
11   *
12   * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute
13   */
14  public class SpringCriteriaAttributeLogicImpl
15      extends SpringCriteriaAttributeLogic
16  {
17      public SpringCriteriaAttributeLogicImpl(
18          Object metaObject,
19          String context)
20      {
21          super(metaObject, context);
22      }
23  
24      /**
25       * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute#getAttributeName()
26       */
27      protected java.lang.String handleGetAttributeName()
28      {
29          // use the attribute name by default
30          String attributeName = getName();
31  
32          // if there is a tagged value, use it instead
33          Object value = findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_ATTRIBUTE);
34          if (value != null)
35          {
36              attributeName = String.valueOf(value);
37          }
38  
39          return StringUtils.trimToEmpty(attributeName);
40      }
41  
42      /**
43       * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute#getComparator()
44       */
45      protected java.lang.String handleGetComparator()
46      {
47          String comparator = null;
48          Object value = findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_COMPARATOR);
49          if (value != null)
50          {
51              comparator = String.valueOf(value);
52          }
53          return StringUtils.trimToEmpty(comparator);
54      }
55  
56      /**
57       * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute#isComparatorPresent()
58       */
59      protected boolean handleIsComparatorPresent()
60      {
61          return !StringUtils.isEmpty(getComparator());
62      }
63  
64      /**
65       * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttribute#getComparatorConstant()
66       */
67      protected String handleGetComparatorConstant()
68      {
69          String comparator = getComparator();
70          String comparatorConstant = null;
71  
72          if (comparator != null)
73          {
74              if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_LIKE.equalsIgnoreCase(comparator))
75              {
76                  comparatorConstant = "LIKE_COMPARATOR";
77              }
78              else if (SpringProfile.TAGGEDVALUEVALUE_INSENSITIVE_LIKE_COMPARATOR.equalsIgnoreCase(comparator))
79              {
80                  comparatorConstant = "INSENSITIVE_LIKE_COMPARATOR";
81              }
82              else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_EQUAL.equalsIgnoreCase(comparator))
83              {
84                  comparatorConstant = "EQUAL_COMPARATOR";
85              }
86              else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_GREATER_OR_EQUAL.equalsIgnoreCase(comparator))
87              {
88                  comparatorConstant = "GREATER_THAN_OR_EQUAL_COMPARATOR";
89              }
90              else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_GREATER.equalsIgnoreCase(comparator))
91              {
92                  comparatorConstant = "GREATER_THAN_COMPARATOR";
93              }
94              else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_LESS_OR_EQUAL.equalsIgnoreCase(comparator))
95              {
96                  comparatorConstant = "LESS_THAN_OR_EQUAL_COMPARATOR";
97              }
98              else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_LESS.equalsIgnoreCase(comparator))
99              {
100                 comparatorConstant = "LESS_THAN_COMPARATOR";
101             }
102             else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_IN.equalsIgnoreCase(comparator))
103             {
104                 comparatorConstant = "IN_COMPARATOR";
105             }
106             else if (SpringProfile.TAGGEDVALUEVALUE_COMPARATOR_NOT_EQUAL.equalsIgnoreCase(comparator))
107             {
108                 comparatorConstant = "NOT_EQUAL_COMPARATOR";
109             }
110         }
111         return comparatorConstant;
112     }
113 
114     /**
115      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleIsNullable()
116      */
117     protected boolean handleIsNullable()
118     {
119         boolean result = false;
120         String value =
121             StringUtils.trimToEmpty((String)findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_NULLABLE));
122         if (!StringUtils.isEmpty(value))
123         {
124             result = BooleanUtils.toBoolean(value);
125         }
126         return result;
127     }
128 
129     /**
130      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleGetMatchMode()
131      */
132     protected String handleGetMatchMode()
133     {
134         String matchMode = null;
135         Object value = findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_MATCHMODE);
136         if (value != null)
137         {
138             matchMode = String.valueOf(value);
139         }
140         String result = StringUtils.trimToEmpty(matchMode);
141         return result;
142     }
143 
144     /**
145      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleGetMatchModeConstant()
146      */
147     protected String handleGetMatchModeConstant()
148     {
149         String matchMode = getMatchMode();
150         String matchModeConstant = null;
151 
152         if (matchMode != null)
153         {
154             if (matchMode.equalsIgnoreCase(SpringProfile.TAGGEDVALUEVALUE_MATCHMODE_ANYWHERE))
155             {
156                 matchModeConstant = "ANYWHERE";
157             }
158             else if (matchMode.equalsIgnoreCase(SpringProfile.TAGGEDVALUEVALUE_MATCHMODE_END))
159             {
160                 matchModeConstant = "END";
161             }
162             else if (matchMode.equalsIgnoreCase(SpringProfile.TAGGEDVALUEVALUE_MATCHMODE_EXACT))
163             {
164                 matchModeConstant = "EXACT";
165             }
166             else if (matchMode.equalsIgnoreCase(SpringProfile.TAGGEDVALUEVALUE_MATCHMODE_START))
167             {
168                 matchModeConstant = "START";
169             }
170         }
171         return matchModeConstant;
172     }
173 
174     /**
175      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleIsMatchModePresent()
176      */
177     protected boolean handleIsMatchModePresent()
178     {
179         return !StringUtils.isEmpty(getMatchMode());
180     }
181 
182     private static final String ORDER_UNSET = "ORDER_UNSET";
183 
184     /**
185      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleIsOrderable()
186      */
187     protected boolean handleIsOrderable()
188     {
189         return !ORDER_UNSET.equals(getOrderDirection());
190     }
191 
192     /**
193      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleGetOrderDirection()
194      */
195     protected String handleGetOrderDirection()
196     {
197         String result = ORDER_UNSET;
198         String value =
199             StringUtils.trimToEmpty(
200                 (String)findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_ORDER_DIRECTION));
201         if (!StringUtils.isEmpty(value))
202         {
203             if (value.equals(SpringProfile.TAGGEDVALUEVALUE_ORDER_ASCENDING))
204             {
205                 result = "ORDER_ASC";
206             }
207             else if (value.equals(SpringProfile.TAGGEDVALUEVALUE_ORDER_DESCENDING))
208             {
209                 result = "ORDER_DESC";
210             }
211         }
212         return result;
213     }
214 
215     /**
216      * Used for undefined states of the criteria ordering.
217      */
218     private static final int UNSET = -1;
219 
220     /**
221      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#handleGetOrderRelevance()
222      */
223     protected int handleGetOrderRelevance()
224     {
225         int result = UNSET;
226         String value =
227             StringUtils.trimToEmpty(
228                 (String)findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_ORDER_RELEVANCE));
229         if (!StringUtils.isEmpty(value))
230         {
231             result = Integer.parseInt(value);
232         }
233         return result;
234     }
235 
236     /**
237      * The default value for whether hibernate criteria arguments are case insensitive or not.
238      */
239     private static final String HIBERNATE_CRITERIA_QUERY_IGNORE_CASE = "hibernateCriteriaQueryIgnoreCase";
240 
241     /**
242      * @see org.andromda.cartridges.spring.metafacades.SpringCriteriaAttributeLogic#isIgnoreCase()
243      */
244     protected boolean handleIsIgnoreCase()
245     {
246         Object value = this.findTaggedValue(SpringProfile.TAGGEDVALUE_HIBERNATE_CRITERIA_COMPARATOR_IGNORE_CASE);
247         if (value == null)
248         {
249             value = this.getConfiguredProperty(HIBERNATE_CRITERIA_QUERY_IGNORE_CASE);
250         }
251         return Boolean.valueOf(ObjectUtils.toString(value)).booleanValue();
252     }
253 }