runtime/org.argeo.slc.support.hibernate/src/main/java/org/argeo/slc/hibernate/test/tree/TreeTestResultDaoHibernate.java

   1 package org.argeo.slc.hibernate.test.tree;
   2
   3 import java.sql.SQLException;
   4 import java.util.Date;
   5 import java.util.List;
   6 import java.util.Map;
   7
   8 import org.argeo.slc.SlcException;
   9 import org.argeo.slc.core.attachment.SimpleAttachment;
  10 import org.argeo.slc.core.structure.tree.TreeSPath;
  11 import org.argeo.slc.core.test.SimpleResultPart;
  12 import org.argeo.slc.core.test.tree.PartSubList;
  13 import org.argeo.slc.core.test.tree.TreeTestResult;
  14 import org.argeo.slc.dao.test.tree.TreeTestResultDao;
  15 import org.argeo.slc.structure.StructureElement;
  16 import org.argeo.slc.test.TestResult;
  17 import org.hibernate.HibernateException;
  18 import org.hibernate.Session;
  19 import org.springframework.orm.hibernate3.HibernateCallback;
  20 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  21 import org.springframework.util.Assert;
  22
  23 /**
  24  * The Hibernate implementation for tree-based result of the test result dao.
  25  *
  26  * @see TreeTestResult
  27  */
  28 public class TreeTestResultDaoHibernate extends HibernateDaoSupport implements
  29                 TreeTestResultDao {
  30
  31         public void create(TestResult testResult) {
  32                 getHibernateTemplate().save(testResult);
  33         }
  34
  35         public void update(TestResult testResult) {
  36                 getHibernateTemplate().saveOrUpdate(testResult);
  37         }
  38
  39         public TreeTestResult getTestResult(String uuid) {
  40                 List<?> list = getHibernateTemplate().find(
  41                                 "from TreeTestResult where uuid=?", uuid);
  42                 if (list.size() == 0) {
  43                         return null;
  44                 } else {
  45                         return (TreeTestResult) list.get(0);
  46                 }
  47
  48         }
  49
  50         @SuppressWarnings("unchecked")
  51         public List<TreeTestResult> listTestResults() {
  52                 return (List<TreeTestResult>) getHibernateTemplate().find(
  53                                 "from TreeTestResult");
  54         }
  55
  56         @SuppressWarnings("unchecked")
  57         public List<TreeTestResult> listResults(TreeSPath path) {
  58                 List<TreeTestResult> list = getHibernateTemplate().find(
  59                                 "from TreeTestResult res where ? in indices(res.resultParts)",
  60                                 path.getAsUniqueString());
  61                 return list;
  62         }
  63
  64         public void close(final String testResultId, final Date closeDate) {
  65                 getHibernateTemplate().execute(new HibernateCallback() {
  66
  67                         public Object doInHibernate(Session session)
  68                                         throws HibernateException, SQLException {
  69                                 TreeTestResult treeTestResult = getTreeTestResult(session,
  70                                                 testResultId);
  71                                 treeTestResult.setCloseDate(closeDate);
  72                                 session.update(treeTestResult);
  73                                 return treeTestResult;
  74                         }
  75                 });
  76         }
  77
  78         public void addResultPart(final String testResultId, final TreeSPath path,
  79                         final SimpleResultPart resultPart,
  80                         final Map<TreeSPath, StructureElement> relatedElements) {
  81
  82                 getHibernateTemplate().execute(new HibernateCallback() {
  83
  84                         public Object doInHibernate(Session session)
  85                                         throws HibernateException, SQLException {
  86                                 TreeTestResult treeTestResult = getTreeTestResult(session,
  87                                                 testResultId);
  88                                 PartSubList lst = treeTestResult.getResultParts().get(path);
  89                                 if (lst == null) {
  90                                         lst = new PartSubList();
  91                                         treeTestResult.getResultParts().put(path, lst);
  92                                 }
  93                                 lst.getParts().add(resultPart);
  94                                 if (relatedElements != null)
  95                                         treeTestResult.getElements().putAll(relatedElements);
  96
  97                                 session.update(treeTestResult);
  98                                 return treeTestResult;
  99                         }
 100                 });
 101
 102         }
 103
 104         public void addAttachment(final String testResultId,
 105                         final SimpleAttachment attachment) {
 106                 getHibernateTemplate().execute(new HibernateCallback() {
 107
 108                         public Object doInHibernate(Session session)
 109                                         throws HibernateException, SQLException {
 110                                 TreeTestResult treeTestResult = getTreeTestResult(session,
 111                                                 testResultId);
 112
 113                                 // Check is there is already such an attachment
 114                                 Assert.notNull(attachment, "attachment is null");
 115                                 Assert.notNull(session, "session is null");
 116                                 SimpleAttachment att = (SimpleAttachment) session.get(
 117                                                 attachment.getClass(), attachment.getUuid());
 118                                 if (att != null)
 119                                         throw new SlcException(
 120                                                         "There is already an attachement with id "
 121                                                                         + attachment.getUuid());
 122
 123                                 treeTestResult.getAttachments().add(attachment);
 124                                 session.update(treeTestResult);
 125                                 return treeTestResult;
 126                         }
 127                 });
 128
 129         }
 130
 131         protected TreeTestResult getTreeTestResult(Session session,
 132                         String testResultId) {
 133                 TreeTestResult treeTestResult = (TreeTestResult) session.get(
 134                                 TreeTestResult.class, testResultId);
 135                 if (treeTestResult == null)
 136                         throw new SlcException("No result with id " + testResultId);
 137                 return treeTestResult;
 138         }
 139
 140         public void updateAttributes(final String testResultId,
 141                         final Map<String, String> attributes) {
 142                 getHibernateTemplate().execute(new HibernateCallback() {
 143
 144                         public Object doInHibernate(Session session)
 145                                         throws HibernateException, SQLException {
 146                                 TreeTestResult treeTestResult = getTreeTestResult(session,
 147                                                 testResultId);
 148                                 treeTestResult.setAttributes(attributes);
 149
 150                                 session.update(treeTestResult);
 151                                 return treeTestResult;
 152                         }
 153                 });
 154         }
 155
 156 }