1 package org.itracker.persistence.dao;
2
3 import java.util.Collection;
4 import java.util.Collections;
5 import java.util.Date;
6 import java.util.LinkedList;
7 import java.util.List;
8 import java.util.Map;
9 import java.util.Set;
10
11 import org.apache.commons.collections.CollectionUtils;
12 import org.apache.commons.collections.Predicate;
13 import org.hibernate.Criteria;
14 import org.hibernate.HibernateException;
15 import org.hibernate.Query;
16 import org.hibernate.criterion.Order;
17 import org.hibernate.criterion.Restrictions;
18 import org.itracker.model.Issue;
19 import org.itracker.model.IssueSearchQuery;
20 import org.itracker.model.PermissionType;
21 import org.itracker.model.Project;
22 import org.itracker.model.User;
23 import org.itracker.services.util.IssueUtilities;
24
25
26
27
28
29
30 public class IssueDAOImpl extends BaseHibernateDAOImpl<Issue> implements IssueDAO {
31
32 private ProjectDAO projectDAO;
33
34 public Issue findByPrimaryKey(Integer issueId) {
35
36 try {
37 Issue issue = (Issue) getSession().get(Issue.class, issueId);
38
39
40
41
42
43 getSession().refresh(issue);
44 return issue;
45 } catch (HibernateException ex) {
46 throw convertHibernateAccessException(ex);
47 }
48 }
49
50 public Long countAllIssues() {
51
52 final Long count;
53
54 try {
55 final Query query = getSession().getNamedQuery("IssueCountAll");
56 count = (Long) query.uniqueResult();
57 } catch (HibernateException ex) {
58 throw convertHibernateAccessException(ex);
59 }
60
61 return count;
62
63 }
64
65 @SuppressWarnings("unchecked")
66 public List<Issue> findAll() {
67
68 final List<Issue> issues;
69
70 try {
71 issues = getSession().getNamedQuery("IssuesAllQuery").list();
72 } catch (HibernateException ex) {
73 throw convertHibernateAccessException(ex);
74 }
75
76 return issues;
77
78 }
79
80 @SuppressWarnings("unchecked")
81 public List<Issue> findByStatus(int status) {
82
83 try {
84 Query query = getSession().getNamedQuery("IssuesByStatusQuery");
85 query.setInteger("issueStatus", status);
86 return query.list();
87 } catch (HibernateException ex) {
88 throw convertHibernateAccessException(ex);
89 }
90
91 }
92
93 @SuppressWarnings("unchecked")
94 public List<Issue> findByStatusLessThan(int maxExclusiveStatus) {
95
96 final List<Issue> issues;
97
98 try {
99 Query query = getSession().getNamedQuery("IssuesByStatusLessThanQuery");
100 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
101 issues = query.list();
102 } catch (HibernateException ex) {
103 throw convertHibernateAccessException(ex);
104 }
105
106 return issues;
107
108 }
109
110 @SuppressWarnings("unchecked")
111 public List<Issue> findByStatusLessThanEqualTo(int maxStatus) {
112
113 final List<Issue> issues;
114
115 try {
116 Query query = getSession().getNamedQuery("IssuesByStatusLessThanEqualToQuery");
117 query.setInteger("maxStatus", maxStatus);
118 issues = query.list();
119 } catch (HibernateException ex) {
120 throw convertHibernateAccessException(ex);
121 }
122
123 return issues;
124
125 }
126
127 @SuppressWarnings("unchecked")
128 public List<Issue> findByStatusLessThanEqualToInAvailableProjects(int maxStatus) {
129
130 final List<Issue> issues;
131
132 try {
133 Query query = getSession().getNamedQuery(
134 "IssuesByStatusLessThanEqualToInAvailableProjectsQuery");
135 query.setInteger("maxStatus", maxStatus);
136 issues = query.list();
137 } catch (HibernateException ex) {
138 throw convertHibernateAccessException(ex);
139 }
140
141 return issues;
142
143 }
144
145 @SuppressWarnings("unchecked")
146 public List<Issue> findBySeverity(int severity) {
147
148 final List<Issue> issues;
149
150 try {
151 Query query = getSession().getNamedQuery("IssuesBySeverityQuery");
152 query.setInteger("severity", severity);
153 issues = query.list();
154 } catch (HibernateException ex) {
155 throw convertHibernateAccessException(ex);
156 }
157
158 return issues;
159
160 }
161
162 @SuppressWarnings("unchecked")
163 public List<Issue> findByProject(Integer projectId) {
164
165 final List<Issue> issues;
166
167 try {
168 Query query = getSession().getNamedQuery("IssuesByProjectQuery");
169 query.setInteger("projectId", projectId);
170 issues = query.list();
171 } catch (HibernateException ex) {
172 throw convertHibernateAccessException(ex);
173 }
174
175 return issues;
176
177 }
178
179 public Long countByProject(Integer projectId) {
180
181 final Long count;
182
183 try {
184 final Query query = getSession().getNamedQuery(
185 "IssueCountByProjectQuery");
186 query.setInteger("projectId", projectId);
187 count = (Long) query.uniqueResult();
188 } catch (HibernateException ex) {
189 throw convertHibernateAccessException(ex);
190 }
191
192 return count;
193
194 }
195
196 @SuppressWarnings("unchecked")
197 public List<Issue> findByProjectAndLowerStatus(Integer projectId,
198 int maxExclusiveStatus) {
199
200 final List<Issue> issues;
201
202 try {
203 Query query = getSession().getNamedQuery(
204 "IssuesByProjectAndLowerStatusQuery");
205 query.setInteger("projectId", projectId);
206 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
207 issues = query.list();
208 } catch (HibernateException ex) {
209 throw convertHibernateAccessException(ex);
210 }
211
212 return issues;
213
214 }
215
216 public Long countByProjectAndLowerStatus(Integer projectId,
217 int maxExclusiveStatus) {
218
219 final Long count;
220
221 try {
222 final Query query = getSession().getNamedQuery(
223 "IssueCountByProjectAndLowerStatusQuery");
224 query.setInteger("projectId", projectId);
225 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
226 count = (Long) query.uniqueResult();
227 } catch (HibernateException ex) {
228 throw convertHibernateAccessException(ex);
229 }
230
231 return count;
232
233 }
234
235 @SuppressWarnings("unchecked")
236 public List<Issue> findByProjectAndHigherStatus(Integer projectId,
237 int status) {
238
239 final List<Issue> issues;
240
241 try {
242 Query query = getSession().getNamedQuery(
243 "IssuesByProjectAndHigherStatusQuery");
244 query.setInteger("projectId", projectId);
245 query.setInteger("minStatus", status);
246 issues = query.list();
247 } catch (HibernateException ex) {
248 throw convertHibernateAccessException(ex);
249 }
250
251 return issues;
252
253 }
254
255 public Long countByProjectAndHigherStatus(Integer projectId, int minStatus) {
256
257 final Long count;
258
259 try {
260 final Query query = getSession().getNamedQuery(
261 "IssueCountByProjectAndHigherStatusQuery");
262 query.setInteger("projectId", projectId);
263 query.setInteger("minStatus", minStatus);
264 count = (Long) query.uniqueResult();
265 } catch (HibernateException ex) {
266 throw convertHibernateAccessException(ex);
267 }
268
269 return count;
270
271 }
272
273 @SuppressWarnings("unchecked")
274 public List<Issue> findByOwner(Integer ownerId, int maxExclusiveStatus) {
275
276 final List<Issue> issues;
277
278 try {
279 Query query = getSession().getNamedQuery("IssuesByOwnerQuery");
280 query.setInteger("ownerId", ownerId);
281 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
282 issues = query.list();
283 } catch (HibernateException ex) {
284 throw convertHibernateAccessException(ex);
285 }
286
287 return issues;
288
289 }
290
291 @SuppressWarnings("unchecked")
292 public List<Issue> findByOwnerInAvailableProjects(Integer ownerId,
293 int maxExclusiveStatus) {
294
295 final List<Issue> issues;
296
297 try {
298 Query query = getSession().getNamedQuery(
299 "IssuesByOwnerInAvailableProjectsQuery");
300 query.setInteger("ownerId", ownerId);
301 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
302
303 issues = query.list();
304 } catch (HibernateException ex) {
305 throw convertHibernateAccessException(ex);
306 }
307
308 return issues;
309
310 }
311
312 @SuppressWarnings("unchecked")
313 public List<Issue> findUnassignedIssues(int maxStatus) {
314
315 final List<Issue> issues;
316
317 try {
318 Query query = getSession().getNamedQuery("IssuesUnassignedQuery");
319 query.setInteger("maxStatus", maxStatus);
320
321 issues = query.list();
322 } catch (HibernateException ex) {
323 throw convertHibernateAccessException(ex);
324 }
325
326 return issues;
327
328 }
329
330 @SuppressWarnings("unchecked")
331 public List<Issue> findByCreator(Integer creatorId,
332 int maxExclusiveStatus) {
333
334 final List<Issue> issues;
335
336 try {
337 Query query = getSession().getNamedQuery("IssuesByCreatorQuery");
338 query.setInteger("creatorId", creatorId);
339 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
340 issues = query.list();
341 } catch (HibernateException ex) {
342 throw convertHibernateAccessException(ex);
343 }
344
345 return issues;
346
347 }
348
349 @SuppressWarnings("unchecked")
350 public List<Issue> findByCreatorInAvailableProjects(Integer creatorId,
351 int maxExclusiveStatus) {
352
353 final List<Issue> issues;
354
355 try {
356 Query query = getSession().getNamedQuery(
357 "IssuesByCreatorInAvailableProjectsQuery");
358 query.setInteger("creatorId", creatorId);
359 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
360 issues = query.list();
361 } catch (HibernateException ex) {
362 throw convertHibernateAccessException(ex);
363 }
364
365 return issues;
366
367 }
368
369 @SuppressWarnings("unchecked")
370 public List<Issue> findByNotification(Integer userId,
371 int maxExclusiveStatus) {
372
373 final List<Issue> issues;
374
375 try {
376 final Query query = getSession().getNamedQuery(
377 "IssuesByNotificationQuery");
378 query.setInteger("userId", userId);
379 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
380 issues = query.list();
381 } catch (HibernateException ex) {
382 throw convertHibernateAccessException(ex);
383 }
384
385 return issues;
386
387 }
388
389 @SuppressWarnings("unchecked")
390 public List<Issue> findByNotificationInAvailableProjects(Integer userId,
391 int maxExclusiveStatus) {
392
393 final List<Issue> issues;
394
395 try {
396 final Query query = getSession().getNamedQuery(
397 "IssuesByNotificationInAvailableProjectsQuery");
398 query.setInteger("userId", userId);
399
400 query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
401 issues = query.list();
402 } catch (HibernateException ex) {
403 throw convertHibernateAccessException(ex);
404 }
405
406 return issues;
407
408 }
409
410 @SuppressWarnings("unchecked")
411 public List<Issue> findByComponent(Integer componentId) {
412
413 final List<Issue> issues;
414
415 try {
416 final Query query = getSession().getNamedQuery(
417 "IssuesByComponentQuery");
418 query.setInteger("componentId", componentId);
419 issues = query.list();
420 } catch (HibernateException ex) {
421 throw convertHibernateAccessException(ex);
422 }
423
424 return issues;
425
426 }
427
428 public Long countByComponent(Integer componentId) {
429
430 final Long count;
431
432 try {
433 final Query query = getSession().getNamedQuery(
434 "IssueCountByComponentQuery");
435 query.setInteger("componentId", componentId);
436 count = (Long) query.uniqueResult();
437 } catch (HibernateException ex) {
438 throw convertHibernateAccessException(ex);
439 }
440
441 return count;
442
443 }
444
445 @SuppressWarnings("unchecked")
446 public List<Issue> findByVersion(Integer versionId) {
447
448 final List<Issue> issues;
449
450 try {
451 final Query query = getSession().getNamedQuery(
452 "IssuesByVersionQuery");
453 query.setInteger("versionId", versionId);
454 issues = query.list();
455 } catch (HibernateException ex) {
456 throw convertHibernateAccessException(ex);
457 }
458
459 return issues;
460
461 }
462
463 public Long countByVersion(Integer versionId) {
464
465 final Long count;
466
467 try {
468 final Query query = getSession().getNamedQuery(
469 "IssueCountByVersionQuery");
470 query.setInteger("versionId", versionId);
471 count = (Long) query.uniqueResult();
472 } catch (HibernateException ex) {
473 throw convertHibernateAccessException(ex);
474 }
475
476 return count;
477
478 }
479
480 public Date latestModificationDate(Integer projectId) {
481
482 final Date lastModifiedDate;
483
484 try {
485 final Query query = getSession().getNamedQuery(
486 "MaxIssueModificationDateQuery");
487 query.setInteger("projectId", projectId);
488 lastModifiedDate = (Date) query.uniqueResult();
489 } catch (HibernateException ex) {
490 throw convertHibernateAccessException(ex);
491 }
492
493 return lastModifiedDate;
494
495 }
496
497
498
499
500
501 @SuppressWarnings("unchecked")
502 public List<Issue> query(
503 IssueSearchQuery searchQuery,
504 final User user,
505 final Map<Integer, Set<PermissionType>> userPermissions) {
506
507 Criteria criteria = getSession().createCriteria(Issue.class);
508
509
510 Collection<Project> projects = Collections.checkedCollection((Collection<Project>)searchQuery.getProjectsObjects(projectDAO), Project.class);
511
512 if (projects.size() > 0) {
513 criteria.add(Restrictions.in("project", projects));
514 }
515
516
517 if (searchQuery.getSeverities().size() > 0) {
518 criteria.add(Restrictions.in("severity", searchQuery.getSeverities()));
519 }
520
521
522 if (searchQuery.getStatuses().size() > 0) {
523 criteria.add(Restrictions.in("status", searchQuery.getStatuses()));
524 }
525
526
527 if (searchQuery.getComponents().size() > 0) {
528 criteria.createCriteria("components").add(Restrictions.in("id", searchQuery.getComponents()));
529 }
530
531
532 if (searchQuery.getVersions().size() > 0) {
533 criteria.createCriteria("versions").add(Restrictions.in("id", searchQuery.getVersions()));
534 }
535
536
537 if (searchQuery.getCreator() != null) {
538 criteria.add(Restrictions.eq("creator", searchQuery.getCreator()));
539 }
540
541
542 if (searchQuery.getOwner() != null) {
543 criteria.add(Restrictions.eq("owner", searchQuery.getOwner()));
544 }
545
546
547 if (searchQuery.getText() != null && !searchQuery.getText().equals("")) {
548 criteria.createAlias("history", "history").
549 add(Restrictions.or(
550 Restrictions.ilike("description", "%" + searchQuery.getText() + "%"),
551 Restrictions.ilike("history.description", "%" + searchQuery.getText() + "%")
552 ));
553 }
554
555
556 if (searchQuery.getResolution() != null) {
557 criteria.add(Restrictions.eq("resolution", searchQuery.getResolution() + "%"));
558 }
559
560
561 if (searchQuery.getTargetVersion() != null) {
562 criteria.add(Restrictions.eq("targetVersion.id", searchQuery.getTargetVersion()));
563 }
564
565
566
567 String order = searchQuery.getOrderBy();
568 if ("id".equals(order)) {
569 } else if ("sev".equals(order)) {
570 criteria.addOrder(order("severity", true));
571
572 } else if ("proj".equals(order)) {
573 criteria.addOrder(order("project", true)).addOrder(order("status", false));
574
575 } else if ("owner".equals(order)) {
576 criteria.addOrder(order("owner", true)).addOrder(order("status", false));
577
578 } else if ("lm".equals(order)) {
579 criteria.addOrder(order("lastModifiedDate", true));
580
581 } else {
582 criteria.addOrder(order("status", true));
583
584 }
585 criteria.addOrder(order("id", true));
586
587 List<Issue> list = Collections.checkedList(Criteria.DISTINCT_ROOT_ENTITY.transformList(criteria.list()), Issue.class);
588
589
590 list = new LinkedList<Issue>(Collections.checkedCollection(CollectionUtils.select(list, new Predicate() {
591 public boolean evaluate(Object arg0) {
592 return IssueUtilities.canViewIssue((Issue) arg0, user, userPermissions);
593 }
594 }), Issue.class));
595
596
597
598
599 return list;
600
601 }
602 Order order(String propertyName, boolean asc) {
603 return asc? Order.asc(propertyName): Order.desc(propertyName);
604 }
605
606 public ProjectDAO getProjectDAO() {
607 return projectDAO;
608 }
609
610 public void setProjectDAO(ProjectDAO projectDAO) {
611 this.projectDAO = projectDAO;
612 }
613
614
615
616
617
618 @SuppressWarnings("unchecked")
619 public List<Issue> findByTargetVersion(Integer versionId) {
620
621 try {
622 final Query query = getSession().getNamedQuery("FindByTargetVersion");
623 query.setInteger("versionId", versionId);
624 return query.list();
625 } catch (HibernateException ex) {
626 throw convertHibernateAccessException(ex);
627 }
628
629
630 }
631
632
633 }