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