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