1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.krad.dao.impl;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.apache.ojb.broker.query.Criteria;
20 import org.apache.ojb.broker.query.QueryByCriteria;
21 import org.apache.ojb.broker.query.QueryFactory;
22 import org.kuali.rice.core.framework.persistence.ojb.dao.PlatformAwareDaoBaseOjb;
23 import org.kuali.rice.kns.service.KNSServiceLocator;
24 import org.kuali.rice.krad.bo.BusinessObject;
25 import org.kuali.rice.krad.bo.PersistableBusinessObject;
26 import org.kuali.rice.krad.dao.BusinessObjectDao;
27 import org.kuali.rice.krad.service.PersistenceStructureService;
28 import org.kuali.rice.krad.service.util.OjbCollectionAware;
29 import org.kuali.rice.krad.service.util.OjbCollectionHelper;
30 import org.kuali.rice.krad.util.KRADPropertyConstants;
31 import org.kuali.rice.krad.util.ObjectUtils;
32 import org.springframework.dao.DataAccessException;
33
34 import java.lang.reflect.InvocationTargetException;
35 import java.util.Collection;
36 import java.util.HashMap;
37 import java.util.Iterator;
38 import java.util.List;
39 import java.util.Map;
40 import java.util.Set;
41
42
43
44
45
46
47
48 @Deprecated
49 public class BusinessObjectDaoOjb extends PlatformAwareDaoBaseOjb implements BusinessObjectDao, OjbCollectionAware {
50 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(BusinessObjectDaoOjb.class);
51
52 private PersistenceStructureService persistenceStructureService;
53 private OjbCollectionHelper ojbCollectionHelper;
54
55
56
57
58 public BusinessObjectDaoOjb(PersistenceStructureService persistenceStructureService) {
59 this.persistenceStructureService = persistenceStructureService;
60 }
61
62
63
64
65 public <T extends BusinessObject> T findBySinglePrimaryKey(Class<T> clazz, Object primaryKey) {
66 if (primaryKey.getClass().getName().startsWith("java.lang.")
67 || primaryKey.getClass().getName().startsWith("java.sql.")
68 || primaryKey.getClass().getName().startsWith("java.math.")
69 || primaryKey.getClass().getName().startsWith("java.util.")) {
70 try {
71 return (T) getPersistenceBrokerTemplate().getObjectById(clazz, primaryKey);
72 } catch ( DataAccessException ex ) {
73
74 return null;
75 }
76 } else {
77 Criteria criteria = buildCriteria(clazz, primaryKey);
78
79 return (T) getPersistenceBrokerTemplate().getObjectByQuery(QueryFactory.newQuery(clazz, criteria));
80 }
81 }
82
83
84
85
86 public <T extends BusinessObject> T findByPrimaryKey(Class<T> clazz, Map<String, ?> primaryKeys) {
87 Criteria criteria = buildCriteria(primaryKeys);
88
89 return (T) getPersistenceBrokerTemplate().getObjectByQuery(QueryFactory.newQuery(clazz, criteria));
90 }
91
92
93
94
95
96
97
98
99 public <T extends BusinessObject> Collection<T> findAll(Class<T> clazz) {
100 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(QueryFactory.newQuery(clazz, (Criteria) null));
101 }
102
103
104
105
106 public <T extends BusinessObject> Collection<T> findAllOrderBy(Class<T> clazz, String sortField, boolean sortAscending) {
107 QueryByCriteria queryByCriteria = new QueryByCriteria(clazz, (Criteria) null);
108
109 if (sortAscending) {
110 queryByCriteria.addOrderByAscending(sortField);
111 }
112 else {
113 queryByCriteria.addOrderByDescending(sortField);
114 }
115
116 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(queryByCriteria);
117 }
118
119
120
121
122
123
124 public <T extends BusinessObject> Collection<T> findMatching(Class<T> clazz, Map<String, ?> fieldValues) {
125 Criteria criteria = buildCriteria(fieldValues);
126
127 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(QueryFactory.newQuery(clazz, criteria));
128 }
129
130
131
132
133 public <T extends BusinessObject> Collection<T> findAllActive(Class<T> clazz) {
134 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(QueryFactory.newQuery(clazz, buildActiveCriteria()));
135 }
136
137
138
139
140 public <T extends BusinessObject> Collection<T> findAllInactive(Class<T> clazz) {
141 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(QueryFactory.newQuery(clazz, buildInactiveCriteria()));
142 }
143
144
145
146
147 public <T extends BusinessObject> Collection<T> findAllActiveOrderBy(Class<T> clazz, String sortField, boolean sortAscending) {
148 QueryByCriteria queryByCriteria = new QueryByCriteria(clazz, buildActiveCriteria());
149
150 if (sortAscending) {
151 queryByCriteria.addOrderByAscending(sortField);
152 }
153 else {
154 queryByCriteria.addOrderByDescending(sortField);
155 }
156
157 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(queryByCriteria);
158 }
159
160
161
162
163 public <T extends BusinessObject> Collection<T> findMatchingActive(Class<T> clazz, Map<String, ?> fieldValues) {
164 Criteria criteria = buildCriteria(fieldValues);
165 criteria.addAndCriteria(buildActiveCriteria());
166
167 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(QueryFactory.newQuery(clazz, criteria));
168 }
169
170
171
172
173
174
175 public int countMatching(Class clazz, Map<String, ?> fieldValues) {
176 Criteria criteria = buildCriteria(fieldValues);
177
178 return getPersistenceBrokerTemplate().getCount(QueryFactory.newQuery(clazz, criteria));
179 }
180
181
182
183
184
185
186 public int countMatching(Class clazz, Map<String, ?> positiveFieldValues, Map<String, ?> negativeFieldValues) {
187 Criteria criteria = buildCriteria(positiveFieldValues);
188 Criteria negativeCriteria = buildNegativeCriteria(negativeFieldValues);
189 criteria.addAndCriteria(negativeCriteria);
190 return getPersistenceBrokerTemplate().getCount(QueryFactory.newQuery(clazz, criteria));
191 }
192
193
194
195
196
197
198
199 public <T extends BusinessObject> Collection<T> findMatchingOrderBy(Class<T> clazz, Map<String, ?> fieldValues, String sortField, boolean sortAscending) {
200 Criteria criteria = buildCriteria(fieldValues);
201 QueryByCriteria queryByCriteria = new QueryByCriteria(clazz, criteria);
202
203 if (sortAscending) {
204 queryByCriteria.addOrderByAscending(sortField);
205 }
206 else {
207 queryByCriteria.addOrderByDescending(sortField);
208 }
209
210 return (Collection<T>)getPersistenceBrokerTemplate().getCollectionByQuery(queryByCriteria);
211 }
212
213
214
215
216
217
218 public PersistableBusinessObject save(PersistableBusinessObject bo) throws DataAccessException {
219
220
221
222 Set<String> boCollections = getPersistenceStructureService().listCollectionObjectTypes(bo.getClass()).keySet();
223 PersistableBusinessObject savedBo = null;
224 if (!boCollections.isEmpty()) {
225
226 savedBo = (PersistableBusinessObject) ObjectUtils.deepCopy(bo);
227 for (String boCollection : boCollections) {
228 if (getPersistenceStructureService().isCollectionUpdatable(savedBo.getClass(), boCollection)) {
229 savedBo.refreshReferenceObject(boCollection);
230 }
231 }
232 getOjbCollectionHelper().processCollections(this, bo, savedBo);
233 }
234
235 getPersistenceBrokerTemplate().store(bo);
236 return bo;
237 }
238
239
240
241
242
243
244 public List<? extends PersistableBusinessObject> save(List businessObjects) throws DataAccessException {
245 if ( LOG.isDebugEnabled() ) {
246 LOG.debug( "About to persist the following BOs:" );
247 for ( Object bo : businessObjects ) {
248 LOG.debug( " --->" + bo );
249 }
250 }
251 for (Iterator i = businessObjects.iterator(); i.hasNext();) {
252 Object bo = i.next();
253 getPersistenceBrokerTemplate().store(bo);
254 }
255 return businessObjects;
256 }
257
258
259
260
261
262
263
264
265
266 public void delete(Object bo) {
267 getPersistenceBrokerTemplate().delete(bo);
268 }
269
270
271
272
273 public void delete(List<? extends PersistableBusinessObject> boList) {
274 for (PersistableBusinessObject bo : boList) {
275 getPersistenceBrokerTemplate().delete(bo);
276 }
277 }
278
279
280
281
282
283 public void deleteMatching(Class clazz, Map<String, ?> fieldValues) {
284 Criteria criteria = buildCriteria(fieldValues);
285
286 getPersistenceBrokerTemplate().deleteByQuery(QueryFactory.newQuery(clazz, criteria));
287
288
289
290 getPersistenceBrokerTemplate().clearCache();
291 }
292
293
294
295
296 public Object retrieve(Object object) {
297 return getPersistenceBrokerTemplate().getObjectByQuery(QueryFactory.newQueryByIdentity(object));
298 }
299
300
301
302
303
304 public <T extends BusinessObject> T findByPrimaryKeyUsingKeyObject(Class<T> clazz, Object pkObject) {
305 throw new UnsupportedOperationException("OJB does not support this option");
306 }
307
308
309
310
311
312 public PersistableBusinessObject manageReadOnly(PersistableBusinessObject bo) {
313 return bo;
314 }
315
316
317
318
319
320
321
322 private Criteria buildCriteria(Map<String, ?> fieldValues) {
323 Criteria criteria = new Criteria();
324 for (Iterator i = fieldValues.entrySet().iterator(); i.hasNext();) {
325 Map.Entry<String, Object> e = (Map.Entry<String, Object>) i.next();
326
327 String key = e.getKey();
328 Object value = e.getValue();
329 if (value instanceof Collection) {
330 criteria.addIn(key, (Collection) value);
331 } else {
332 criteria.addEqualTo(key, value);
333 }
334 }
335
336 return criteria;
337 }
338
339
340 private <T extends BusinessObject> Criteria buildCriteria(Class<T> clazz, Object primaryKey) {
341 Map<String, Object> fieldValues = new HashMap<String, Object>();
342 List<String> fieldNames = getPersistenceStructureService().getPrimaryKeys(clazz);
343
344
345 for (String fieldName : fieldNames) {
346 Object fieldValue;
347
348 try {
349 fieldValue = primaryKey.getClass().getMethod("get" + StringUtils.capitalize(fieldName)).invoke(primaryKey);
350 fieldValues.put(fieldName, fieldValue);
351 } catch (IllegalArgumentException e) {
352 e.printStackTrace();
353 } catch (IllegalAccessException e) {
354 e.printStackTrace();
355 } catch (SecurityException e) {
356 e.printStackTrace();
357 } catch (InvocationTargetException e) {
358 e.printStackTrace();
359 } catch (NoSuchMethodException e) {
360 e.printStackTrace();
361 }
362 }
363 return this.buildCriteria(fieldValues);
364 }
365
366
367
368
369
370 private Criteria buildActiveCriteria(){
371 Criteria criteria = new Criteria();
372 criteria.addEqualTo(KRADPropertyConstants.ACTIVE, true);
373
374 return criteria;
375 }
376
377
378
379
380
381 private Criteria buildInactiveCriteria(){
382 Criteria criteria = new Criteria();
383 criteria.addEqualTo(KRADPropertyConstants.ACTIVE, false);
384
385 return criteria;
386 }
387
388
389
390
391
392
393
394 private Criteria buildNegativeCriteria(Map<String, ?> negativeFieldValues) {
395 Criteria criteria = new Criteria();
396 for (Iterator i = negativeFieldValues.entrySet().iterator(); i.hasNext();) {
397 Map.Entry<String, Object> e = (Map.Entry<String, Object>) i.next();
398
399 String key = e.getKey();
400 Object value = e.getValue();
401 if (value instanceof Collection) {
402 criteria.addNotIn(key, (Collection) value);
403 }
404 else {
405 criteria.addNotEqualTo(key, value);
406 }
407 }
408
409 return criteria;
410 }
411
412
413
414
415
416 protected PersistenceStructureService getPersistenceStructureService() {
417 return persistenceStructureService;
418 }
419
420
421
422
423
424 public void setPersistenceStructureService(PersistenceStructureService persistenceStructureService) {
425 this.persistenceStructureService = persistenceStructureService;
426 }
427
428
429
430
431
432
433 protected OjbCollectionHelper getOjbCollectionHelper() {
434 if (ojbCollectionHelper == null) {
435 ojbCollectionHelper = KNSServiceLocator.getOjbCollectionHelper();
436 }
437
438 return ojbCollectionHelper;
439 }
440
441
442
443
444
445
446 public void setOjbCollectionHelper(OjbCollectionHelper ojbCollectionHelper) {
447 this.ojbCollectionHelper = ojbCollectionHelper;
448 }
449 }