TreeTestResultDaoHibernate.java

   1 /*
   2  * Copyright (C) 2010 Mathieu Baudier <mbaudier@argeo.org>
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *         http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.argeo.slc.hibernate.test.tree;
  18
  19 import java.sql.SQLException;
  20 import java.util.Date;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.SortedMap;
  24
  25 import org.argeo.slc.SlcException;
  26 import org.argeo.slc.core.attachment.SimpleAttachment;
  27 import org.argeo.slc.core.structure.tree.TreeSPath;
  28 import org.argeo.slc.core.test.SimpleResultPart;
  29 import org.argeo.slc.core.test.tree.PartSubList;
  30 import org.argeo.slc.core.test.tree.TreeTestResult;
  31 import org.argeo.slc.dao.test.tree.TreeTestResultDao;
  32 import org.argeo.slc.structure.StructureElement;
  33 import org.argeo.slc.test.TestResult;
  34 import org.hibernate.HibernateException;
  35 import org.hibernate.Session;
  36 import org.springframework.orm.hibernate3.HibernateCallback;
  37 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
  38 import org.springframework.util.Assert;
  39
  40 /**
  41  * The Hibernate implementation for tree-based result of the test result dao.
  42  *
  43  * @see TreeTestResult
  44  */
  45 public class TreeTestResultDaoHibernate extends HibernateDaoSupport implements
  46                 TreeTestResultDao {
  47
  48         public void create(TestResult testResult) {
  49                 getHibernateTemplate().save(testResult);
  50         }
  51
  52         public void update(TestResult testResult) {
  53                 getHibernateTemplate().saveOrUpdate(testResult);
  54         }
  55
  56         public TreeTestResult getTestResult(String uuid) {
  57                 List<?> list = getHibernateTemplate().find(
  58                                 "from TreeTestResult where uuid=?", uuid);
  59                 if (list.size() == 0) {
  60                         return null;
  61                 } else {
  62                         return (TreeTestResult) list.get(0);
  63                 }
  64
  65         }
  66
  67         @SuppressWarnings("unchecked")
  68         public List<TreeTestResult> listTestResults() {
  69                 return (List<TreeTestResult>) getHibernateTemplate().find(
  70                                 "from TreeTestResult");
  71         }
  72
  73         @SuppressWarnings("unchecked")
  74         public List<TreeTestResult> listResults(TreeSPath path) {
  75                 List<TreeTestResult> list = getHibernateTemplate().find(
  76                                 "from TreeTestResult res where ? in indices(res.resultParts)",
  77                                 path.getAsUniqueString());
  78                 return list;
  79         }
  80
  81         public void close(final String testResultId, final Date closeDate) {
  82                 getHibernateTemplate().execute(new HibernateCallback() {
  83
  84                         public Object doInHibernate(Session session)
  85                                         throws HibernateException, SQLException {
  86                                 TreeTestResult treeTestResult = getTreeTestResult(session,
  87                                                 testResultId);
  88                                 treeTestResult.setCloseDate(closeDate);
  89                                 session.update(treeTestResult);
  90                                 return treeTestResult;
  91                         }
  92                 });
  93         }
  94
  95         public void addResultPart(final String testResultId, final TreeSPath path,
  96                         final SimpleResultPart resultPart,
  97                         final Map<TreeSPath, StructureElement> relatedElements) {
  98
  99                 getHibernateTemplate().execute(new HibernateCallback() {
 100
 101                         public Object doInHibernate(Session session)
 102                                         throws HibernateException, SQLException {
 103                                 TreeTestResult treeTestResult = getTreeTestResult(session,
 104                                                 testResultId);
 105                                 PartSubList lst = treeTestResult.getResultParts().get(path);
 106                                 if (lst == null) {
 107                                         lst = new PartSubList();
 108                                         treeTestResult.getResultParts().put(path, lst);
 109                                 }
 110                                 lst.getParts().add(resultPart);
 111                                 if (relatedElements != null)
 112                                         treeTestResult.getElements().putAll(relatedElements);
 113
 114                                 session.update(treeTestResult);
 115                                 return treeTestResult;
 116                         }
 117                 });
 118
 119         }
 120
 121         public void addAttachment(final String testResultId,
 122                         final SimpleAttachment attachment) {
 123                 getHibernateTemplate().execute(new HibernateCallback() {
 124
 125                         public Object doInHibernate(Session session)
 126                                         throws HibernateException, SQLException {
 127                                 TreeTestResult treeTestResult = getTreeTestResult(session,
 128                                                 testResultId);
 129
 130                                 // Check is there is already such an attachment
 131                                 Assert.notNull(attachment, "attachment is null");
 132                                 Assert.notNull(session, "session is null");
 133                                 SimpleAttachment att = (SimpleAttachment) session.get(
 134                                                 attachment.getClass(), attachment.getUuid());
 135                                 if (att != null)
 136                                         throw new SlcException(
 137                                                         "There is already an attachement with id "
 138                                                                         + attachment.getUuid());
 139
 140                                 treeTestResult.getAttachments().add(attachment);
 141                                 session.update(treeTestResult);
 142                                 return treeTestResult;
 143                         }
 144                 });
 145
 146         }
 147
 148         protected TreeTestResult getTreeTestResult(Session session,
 149                         String testResultId) {
 150                 TreeTestResult treeTestResult = (TreeTestResult) session.get(
 151                                 TreeTestResult.class, testResultId);
 152                 if (treeTestResult == null)
 153                         throw new SlcException("No result with id " + testResultId);
 154                 return treeTestResult;
 155         }
 156
 157         public void updateAttributes(final String testResultId,
 158                         final SortedMap<String, String> attributes) {
 159                 getHibernateTemplate().execute(new HibernateCallback() {
 160
 161                         public Object doInHibernate(Session session)
 162                                         throws HibernateException, SQLException {
 163                                 TreeTestResult treeTestResult = getTreeTestResult(session,
 164                                                 testResultId);
 165                                 treeTestResult.setAttributes(attributes);
 166
 167                                 session.update(treeTestResult);
 168                                 return treeTestResult;
 169                         }
 170                 });
 171         }
 172
 173 }