IssueDAOImpl.java

  1. package org.itracker.persistence.dao;

  3. import org.apache.commons.collections.CollectionUtils;
  4. import org.apache.commons.collections.Predicate;
  5. import org.apache.commons.collections.Transformer;
  6. import org.hibernate.Criteria;
  7. import org.hibernate.HibernateException;
  8. import org.hibernate.Query;
  9. import org.hibernate.criterion.Order;
  10. import org.hibernate.criterion.Restrictions;
  11. import org.itracker.model.*;
  12. import org.itracker.model.util.IssueUtilities;

  14. import java.util.*;

  16. /**
  17.  * Default implementation of <code>IssueDAO</code> using Hibernate.
  18.  *
  19.  * @author ready
  20.  */
  21. public class IssueDAOImpl extends BaseHibernateDAOImpl<Issue> implements IssueDAO {

  23.     private ProjectDAO projectDAO;

  25.     public Issue findByPrimaryKey(Integer issueId) {

  27.         try {
  28.             Issue issue = (Issue) getSession().get(Issue.class, issueId);
  29.             if (null != issue) {
  30.                 getSession().refresh(issue);
  31.             } else {
  32.                 throw new NoSuchEntityException("Issue " + issueId);
  33.             }
  34.             return issue;
  35.         } catch (HibernateException ex) {
  36.             throw convertHibernateAccessException(ex);
  37.         }
  38.     }

  40.     public Long countAllIssues() {

  42.         final Long count;

  44.         try {
  45.             final Query query = getSession().getNamedQuery("IssueCountAll");
  46.             count = (Long) query.uniqueResult();
  47.         } catch (HibernateException ex) {
  48.             throw convertHibernateAccessException(ex);
  49.         }

  51.         return count;

  53.     }

  55.     @SuppressWarnings("unchecked")
  56.     public List<Issue> findAll() {

  58.         final List<Issue> issues;

  60.         try {
  61.             issues = getSession().getNamedQuery("IssuesAllQuery").list();
  62.         } catch (HibernateException ex) {
  63.             throw convertHibernateAccessException(ex);
  64.         }

  66.         return issues;

  68.     }

  70.     @SuppressWarnings("unchecked")
  71.     public List<Issue> findByStatus(int status) {

  73.         try {
  74.             Query query = getSession().getNamedQuery("IssuesByStatusQuery");
  75.             query.setInteger("issueStatus", status);
  76.             return query.list();
  77.         } catch (HibernateException ex) {
  78.             throw convertHibernateAccessException(ex);
  79.         }

  81.     }

  83.     @SuppressWarnings("unchecked")
  84.     public List<Issue> findByStatusLessThan(int maxExclusiveStatus) {

  86.         final List<Issue> issues;

  88.         try {
  89.             Query query = getSession().getNamedQuery("IssuesByStatusLessThanQuery");
  90.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  91.             issues = query.list();
  92.         } catch (HibernateException ex) {
  93.             throw convertHibernateAccessException(ex);
  94.         }

  96.         return issues;

  98.     }

  100.     @SuppressWarnings("unchecked")
  101.     public List<Issue> findByStatusLessThanEqualTo(int maxStatus) {

  103.         final List<Issue> issues;

  105.         try {
  106.             Query query = getSession().getNamedQuery("IssuesByStatusLessThanEqualToQuery");
  107.             query.setInteger("maxStatus", maxStatus);
  108.             issues = query.list();
  109.         } catch (HibernateException ex) {
  110.             throw convertHibernateAccessException(ex);
  111.         }

  113.         return issues;

  115.     }

  117.     @SuppressWarnings("unchecked")
  118.     public List<Issue> findByStatusLessThanEqualToInAvailableProjects(int maxStatus) {

  120.         final List<Issue> issues;

  122.         try {
  123.             Query query = getSession().getNamedQuery(
  124.                     "IssuesByStatusLessThanEqualToInAvailableProjectsQuery");
  125.             query.setInteger("maxStatus", maxStatus);
  126.             issues = query.list();
  127.         } catch (HibernateException ex) {
  128.             throw convertHibernateAccessException(ex);
  129.         }

  131.         return issues;

  133.     }

  135.     @SuppressWarnings("unchecked")
  136.     public List<Issue> findBySeverity(int severity) {

  138.         final List<Issue> issues;

  140.         try {
  141.             Query query = getSession().getNamedQuery("IssuesBySeverityQuery");
  142.             query.setInteger("severity", severity);
  143.             issues = query.list();
  144.         } catch (HibernateException ex) {
  145.             throw convertHibernateAccessException(ex);
  146.         }

  148.         return issues;

  150.     }

  152.     @SuppressWarnings("unchecked")
  153.     public List<Issue> findByProject(Integer projectId) {

  155.         final List<Issue> issues;

  157.         try {
  158.             Query query = getSession().getNamedQuery("IssuesByProjectQuery");
  159.             query.setInteger("projectId", projectId);
  160.             issues = query.list();
  161.         } catch (HibernateException ex) {
  162.             throw convertHibernateAccessException(ex);
  163.         }

  165.         return issues;

  167.     }

  169.     public Long countByProject(Integer projectId) {

  171.         final Long count;

  173.         try {
  174.             final Query query = getSession().getNamedQuery(
  175.                     "IssueCountByProjectQuery");
  176.             query.setInteger("projectId", projectId);
  177.             count = (Long) query.uniqueResult();
  178.         } catch (HibernateException ex) {
  179.             throw convertHibernateAccessException(ex);
  180.         }

  182.         return count;

  184.     }

  186.     @SuppressWarnings("unchecked")
  187.     public List<Issue> findByProjectAndLowerStatus(Integer projectId,
  188.                                                    int maxExclusiveStatus) {

  190.         final List<Issue> issues;

  192.         try {
  193.             Query query = getSession().getNamedQuery(
  194.                     "IssuesByProjectAndLowerStatusQuery");
  195.             query.setInteger("projectId", projectId);
  196.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  197.             issues = query.list();
  198.         } catch (HibernateException ex) {
  199.             throw convertHibernateAccessException(ex);
  200.         }

  202.         return issues;

  204.     }

  206.     public Long countByProjectAndLowerStatus(Integer projectId,
  207.                                              int maxExclusiveStatus) {

  209.         final Long count;

  211.         try {
  212.             final Query query = getSession().getNamedQuery(
  213.                     "IssueCountByProjectAndLowerStatusQuery");
  214.             query.setInteger("projectId", projectId);
  215.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  216.             count = (Long) query.uniqueResult();
  217.         } catch (HibernateException ex) {
  218.             throw convertHibernateAccessException(ex);
  219.         }

  221.         return count;

  223.     }

  225.     @SuppressWarnings("unchecked")
  226.     public List<Issue> findByProjectAndHigherStatus(Integer projectId,
  227.                                                     int status) {

  229.         final List<Issue> issues;

  231.         try {
  232.             Query query = getSession().getNamedQuery(
  233.                     "IssuesByProjectAndHigherStatusQuery");
  234.             query.setInteger("projectId", projectId);
  235.             query.setInteger("minStatus", status);
  236.             issues = query.list();
  237.         } catch (HibernateException ex) {
  238.             throw convertHibernateAccessException(ex);
  239.         }

  241.         return issues;

  243.     }

  245.     public Long countByProjectAndHigherStatus(Integer projectId, int minStatus) {

  247.         final Long count;

  249.         try {
  250.             final Query query = getSession().getNamedQuery(
  251.                     "IssueCountByProjectAndHigherStatusQuery");
  252.             query.setInteger("projectId", projectId);
  253.             query.setInteger("minStatus", minStatus);
  254.             count = (Long) query.uniqueResult();
  255.         } catch (HibernateException ex) {
  256.             throw convertHibernateAccessException(ex);
  257.         }

  259.         return count;

  261.     }

  263.     @SuppressWarnings("unchecked")
  264.     public List<Issue> findByOwner(Integer ownerId, int maxExclusiveStatus) {

  266.         final List<Issue> issues;

  268.         try {
  269.             Query query = getSession().getNamedQuery("IssuesByOwnerQuery");
  270.             query.setInteger("ownerId", ownerId);
  271.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  272.             issues = query.list();
  273.         } catch (HibernateException ex) {
  274.             throw convertHibernateAccessException(ex);
  275.         }

  277.         return issues;

  279.     }

  281.     @SuppressWarnings("unchecked")
  282.     public List<Issue> findByOwnerInAvailableProjects(Integer ownerId,
  283.                                                       int maxExclusiveStatus) {

  285.         final List<Issue> issues;

  287.         try {
  288.             Query query = getSession().getNamedQuery(
  289.                     "IssuesByOwnerInAvailableProjectsQuery");
  290.             query.setInteger("ownerId", ownerId);
  291.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);

  293.             issues = query.list();
  294.         } catch (HibernateException ex) {
  295.             throw convertHibernateAccessException(ex);
  296.         }

  298.         return issues;

  300.     }

  302.     @SuppressWarnings("unchecked")
  303.     public List<Issue> findUnassignedIssues(int maxStatus) {

  305.         final List<Issue> issues;

  307.         try {
  308.             Query query = getSession().getNamedQuery("IssuesUnassignedQuery");
  309.             query.setInteger("maxStatus", maxStatus);

  311.             issues = query.list();
  312.         } catch (HibernateException ex) {
  313.             throw convertHibernateAccessException(ex);
  314.         }

  316.         return issues;

  318.     }

  320.     @SuppressWarnings("unchecked")
  321.     public List<Issue> findByCreator(Integer creatorId,
  322.                                      int maxExclusiveStatus) {

  324.         final List<Issue> issues;

  326.         try {
  327.             Query query = getSession().getNamedQuery("IssuesByCreatorQuery");
  328.             query.setInteger("creatorId", creatorId);
  329.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  330.             issues = query.list();
  331.         } catch (HibernateException ex) {
  332.             throw convertHibernateAccessException(ex);
  333.         }

  335.         return issues;

  337.     }

  339.     @SuppressWarnings("unchecked")
  340.     public List<Issue> findByCreatorInAvailableProjects(Integer creatorId,
  341.                                                         int maxExclusiveStatus) {

  343.         final List<Issue> issues;

  345.         try {
  346.             Query query = getSession().getNamedQuery(
  347.                     "IssuesByCreatorInAvailableProjectsQuery");
  348.             query.setInteger("creatorId", creatorId);
  349.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  350.             issues = query.list();
  351.         } catch (HibernateException ex) {
  352.             throw convertHibernateAccessException(ex);
  353.         }

  355.         return issues;

  357.     }

  359.     @SuppressWarnings("unchecked")
  360.     public List<Issue> findByNotification(Integer userId,
  361.                                           int maxExclusiveStatus) {

  363.         final List<Issue> issues;

  365.         try {
  366.             final Query query = getSession().getNamedQuery(
  367.                     "IssuesByNotificationQuery");
  368.             query.setInteger("userId", userId);
  369.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  370.             issues = query.list();
  371.         } catch (HibernateException ex) {
  372.             throw convertHibernateAccessException(ex);
  373.         }

  375.         return issues;

  377.     }

  379.     @SuppressWarnings("unchecked")
  380.     public List<Issue> findByNotificationInAvailableProjects(Integer userId,
  381.                                                              int maxExclusiveStatus) {

  383.         final List<Issue> issues;

  385.         try {
  386.             final Query query = getSession().getNamedQuery(
  387.                     "IssuesByNotificationInAvailableProjectsQuery");
  388.             query.setInteger("userId", userId);
  389.             //@ToDo Check this query.
  390.             query.setInteger("maxExclusiveStatus", maxExclusiveStatus);
  391.             issues = query.list();
  392.         } catch (HibernateException ex) {
  393.             throw convertHibernateAccessException(ex);
  394.         }

  396.         return issues;

  398.     }

  400.     @SuppressWarnings("unchecked")
  401.     public List<Issue> findByComponent(Integer componentId) {

  403.         final List<Issue> issues;

  405.         try {
  406.             final Query query = getSession().getNamedQuery(
  407.                     "IssuesByComponentQuery");
  408.             query.setInteger("componentId", componentId);
  409.             issues = query.list();
  410.         } catch (HibernateException ex) {
  411.             throw convertHibernateAccessException(ex);
  412.         }

  414.         return issues;

  416.     }

  418.     public Long countByComponent(Integer componentId) {

  420.         final Long count;

  422.         try {
  423.             final Query query = getSession().getNamedQuery(
  424.                     "IssueCountByComponentQuery");
  425.             query.setInteger("componentId", componentId);
  426.             count = (Long) query.uniqueResult();
  427.         } catch (HibernateException ex) {
  428.             throw convertHibernateAccessException(ex);
  429.         }

  431.         return count;

  433.     }

  435.     @SuppressWarnings("unchecked")
  436.     public List<Issue> findByVersion(Integer versionId) {

  438.         final List<Issue> issues;

  440.         try {
  441.             final Query query = getSession().getNamedQuery(
  442.                     "IssuesByVersionQuery");
  443.             query.setInteger("versionId", versionId);
  444.             issues = query.list();
  445.         } catch (HibernateException ex) {
  446.             throw convertHibernateAccessException(ex);
  447.         }

  449.         return issues;

  451.     }

  453.     public Long countByVersion(Integer versionId) {

  455.         final Long count;

  457.         try {
  458.             final Query query = getSession().getNamedQuery(
  459.                     "IssueCountByVersionQuery");
  460.             query.setInteger("versionId", versionId);
  461.             count = (Long) query.uniqueResult();
  462.         } catch (HibernateException ex) {
  463.             throw convertHibernateAccessException(ex);
  464.         }

  466.         return count;

  468.     }

  470.     public Date latestModificationDate(Integer projectId) {

  472.         final Date lastModifiedDate;

  474.         try {
  475.             final Query query = getSession().getNamedQuery(
  476.                     "MaxIssueModificationDateQuery");
  477.             query.setInteger("projectId", projectId);
  478.             lastModifiedDate = (Date) query.uniqueResult();
  479.         } catch (HibernateException ex) {
  480.             throw convertHibernateAccessException(ex);
  481.         }

  483.         return lastModifiedDate;

  485.     }

  487.     public List<Issue> findNextIssues(Integer issueId) {
  488.         List<Issue> issue;
  489.         try {
  490.             final Query query = getSession().getNamedQuery(
  491.                     "FindNextIssues");
  492.             query.setInteger("issueId", issueId);
  493.             issue = query.list();
  494.         } catch (HibernateException ex) {
  495.             throw convertHibernateAccessException(ex);
  496.         }
  497.         return issue;
  498.     }
  499.     public List<Issue> findPreviousIssues(Integer issueId) {
  500.         List<Issue> issue;
  501.         try {
  502.             final Query query = getSession().getNamedQuery(
  503.                     "FindPreviousIssues");
  504.             query.setInteger("issueId", issueId);
  505.             issue = query.list();
  506.         } catch (HibernateException ex) {
  507.             throw convertHibernateAccessException(ex);
  508.         }
  509.         return issue;
  510.     }

  512.     /**
  513.      * It doens't really make sense for this method to receive projectDAO, it's just a quick
  514.      * fix for the fact that IssueSearchQuery handles ids and not objects
  515.      */
  516.     @SuppressWarnings("unchecked")
  517.     public List<Issue> query(
  518.             IssueSearchQuery searchQuery,
  519.             final User user,
  520.             final Map<Integer, Set<PermissionType>> userPermissions) {

  522.         Criteria criteria = getSession().createCriteria(Issue.class);

  524.         // projects
  525.         Collection<Project> projects = Collections.checkedCollection((Collection<Project>) getProjectsObjects(searchQuery), Project.class);

  527.         if (projects.size() > 0) {
  528.             criteria.add(Restrictions.in("project", projects));
  529.         }

  531.         // severities
  532.         if (searchQuery.getSeverities().size() > 0) {
  533.             criteria.add(Restrictions.in("severity", searchQuery.getSeverities()));
  534.         }

  536.         // status
  537.         if (searchQuery.getStatuses().size() > 0) {
  538.             criteria.add(Restrictions.in("status", searchQuery.getStatuses()));
  539.         }

  541.         // componentes
  542.         if (searchQuery.getComponents().size() > 0) {
  543.             criteria.createCriteria("components").add(Restrictions.in("id", searchQuery.getComponents()));
  544.         }

  546.         // versions
  547.         if (searchQuery.getVersions().size() > 0) {
  548.             criteria.createCriteria("versions").add(Restrictions.in("id", searchQuery.getVersions()));
  549.         }

  551.         // creator
  552.         if (searchQuery.getCreator() != null) {
  553.             criteria.add(Restrictions.eq("creator", searchQuery.getCreator()));
  554.         }

  556.         // owner
  557.         if (searchQuery.getOwner() != null) {
  558.             criteria.add(Restrictions.eq("owner", searchQuery.getOwner()));
  559.         }

  561.         // description and history
  562.         if (searchQuery.getText() != null && !searchQuery.getText().equals("")) {
  563.             criteria.createAlias("history", "history").
  564.                     add(Restrictions.or(
  565.                             Restrictions.ilike("description", "%" + searchQuery.getText() + "%"),
  566.                             Restrictions.ilike("history.description", "%" + searchQuery.getText() + "%")
  567.                     ));
  568.         }

  570.         // resolution
  571.         if (searchQuery.getResolution() != null) {
  572.             criteria.add(Restrictions.eq("resolution", searchQuery.getResolution() + "%"));
  573.         }

  575.         // resolution
  576.         if (searchQuery.getTargetVersion() != null) {
  577.             criteria.add(Restrictions.eq("targetVersion.id", searchQuery.getTargetVersion()));
  578.         }


  581.         // sort
  582.         String order = searchQuery.getOrderBy();
  583.         if (!"id".equals(order)) {
  584.             if ("sev".equals(order)) {
  585.                 criteria.addOrder(order("severity", true));
  586.             } else if ("proj".equals(order)) {
  587.                 criteria.addOrder(order("project", true)).addOrder(order("status", false));
  588.             } else if ("owner".equals(order)) {
  589.                 criteria.addOrder(order("owner", true)).addOrder(order("status", false));
  590.             } else if ("lm".equals(order)) {
  591.                 criteria.addOrder(order("lastModifiedDate", true));
  592.             } else {
  593.                 criteria.addOrder(order("status", true));
  594.             }
  595.         }
  596.         criteria.addOrder(order("id", true));

  598.         List<Issue> list = Collections.checkedList(Criteria.DISTINCT_ROOT_ENTITY.transformList(criteria.list()), Issue.class);

  600.         // filter for permission
  601.         list = new LinkedList<Issue>(Collections.checkedCollection(CollectionUtils.select(list, new Predicate() {
  602.             public boolean evaluate(Object arg0) {
  603.                 return IssueUtilities.canViewIssue((Issue) arg0, user, userPermissions);
  604.             }
  605.         }), Issue.class));


  608.         return list;

  610.     }

  612.     // from the list of project ids this objects has, return a list of
  613.     // projects
  614.     public Collection<?> getProjectsObjects(final IssueSearchQuery query) {
  615.         return CollectionUtils.collect(query.getProjects(), new Transformer() {
  616.             public Object transform(Object arg0) {
  617.                 return projectDAO.findByPrimaryKey((Integer) arg0);
  618.             }
  619.         });
  620.     }
  621.     Order order(String propertyName, boolean asc) {
  622.         return asc ? Order.asc(propertyName) : Order.desc(propertyName);
  623.     }

  625.     public ProjectDAO getProjectDAO() {
  626.         return projectDAO;
  627.     }

  629.     public void setProjectDAO(ProjectDAO projectDAO) {
  630.         this.projectDAO = projectDAO;
  631.     }

  633.     /**
  634.      * {@inheritDoc}
  635.      */
  636.     @SuppressWarnings("unchecked")
  637.     public List<Issue> findByTargetVersion(Integer versionId) {

  639.         try {
  640.             final Query query = getSession().getNamedQuery("FindByTargetVersion");
  641.             query.setInteger("versionId", versionId);
  642.             return query.list();
  643.         } catch (HibernateException ex) {
  644.             throw convertHibernateAccessException(ex);
  645.         }


  648.     }


  651. }
Created with JaCoCo 0.8.5.201910111838