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