org.argeo.slc.core/src/main/java/org/argeo/slc/core/test/tree/TreeTestResultPersister.java

   1 package org.argeo.slc.core.test.tree;
   2
   3 import org.apache.commons.logging.Log;
   4 import org.apache.commons.logging.LogFactory;
   5
   6 import org.argeo.slc.core.structure.SimpleSElement;
   7 import org.argeo.slc.core.structure.StructureElement;
   8 import org.argeo.slc.core.structure.StructureRegistry;
   9 import org.argeo.slc.core.structure.tree.TreeSPath;
  10 import org.argeo.slc.core.structure.tree.TreeSRegistry;
  11 import org.argeo.slc.dao.structure.tree.TreeSPathDao;
  12 import org.argeo.slc.dao.structure.tree.TreeSRegistryDao;
  13 import org.argeo.slc.dao.test.TestResultDao;
  14 import org.argeo.slc.dao.test.tree.TreeTestResultDao;
  15
  16 /**
  17  * Listener persisting tree-based results.
  18  *
  19  * @see TreeTestResult
  20  */
  21 public class TreeTestResultPersister extends AsynchronousTreeTestResultListener {
  22         private static Log log = LogFactory.getLog(TreeTestResultPersister.class);
  23
  24         private TreeTestResultDao testResultDao;
  25         private TreeSPathDao treeSPathDao;
  26         private TreeSRegistryDao treeSRegistryDao;
  27
  28         @Override
  29         protected void resultPartAdded(PartStruct partStruct) {
  30                 try {
  31                         TreeTestResult persistedResult = testResultDao
  32                                         .getTestResult(partStruct.uuid);
  33
  34                         if (persistedResult == null) {
  35                                 testResultDao.create(partStruct.result);
  36                         } else {
  37                                 testResultDao.update(partStruct.result);
  38                         }
  39                         /*
  40                          * TreeSPath path = treeSPathDao.getOrCreate(partStruct.path);
  41                          *
  42                          * StructureRegistry<TreeSPath> localRegistry = partStruct.result
  43                          * .getRegistry(); TreeSRegistry registry =
  44                          * getOrCreateTreeSRegistry(path);
  45                          * treeSRegistryDao.syncPath(registry, localRegistry, path);
  46                          *
  47                          * if (persistedResult == null) { persistedResult = new
  48                          * TreeTestResult();
  49                          * persistedResult.setNumericResultId(partStruct.resultId);
  50                          * PartSubList subList = new PartSubList();
  51                          * subList.getParts().add(partStruct.part);
  52                          * persistedResult.getResultParts().put(path, subList);
  53                          *
  54                          * testResultDao.create(persistedResult); } else { PartSubList
  55                          * subList = persistedResult.getResultParts() .get(path); if
  56                          * (subList == null) { subList = new PartSubList();
  57                          * persistedResult.getResultParts().put(path, subList); }
  58                          * persistedResult.getResultParts().get(path).getParts().add(
  59                          * partStruct.part);
  60                          *
  61                          * if (log.isTraceEnabled()) { log.trace("ResultId:" +
  62                          * persistedResult.getTestResultId()); log.trace("ResultParts size:" +
  63                          * persistedResult.getResultParts().size()); log.trace("Sublist
  64                          * size:" + subList.getParts().size()); log.trace("Part: " +
  65                          * partStruct.part); } testResultDao.update(persistedResult); }
  66                          */
  67                 } catch (Exception e) {
  68                         log.error("Could not persist part for result #" + partStruct.uuid,
  69                                         e);
  70                 }
  71         }
  72
  73         @Override
  74         protected void postClose(TreeTestResult testResult) {
  75                 TreeTestResult persistedResult = (TreeTestResult) testResultDao
  76                                 .getTestResult(testResult.getUuid());
  77
  78                 if (persistedResult != null) {
  79                         persistedResult.setCloseDate(testResult.getCloseDate());
  80                         testResultDao.update(persistedResult);
  81                 }
  82                 if (log.isDebugEnabled())
  83                         log.debug("Closed result persister for result "
  84                                         + testResult.getUuid());
  85         }
  86
  87         private TreeSRegistry getOrCreateTreeSRegistry(TreeSPath path) {
  88                 TreeSRegistry registry = treeSRegistryDao.getActiveTreeSRegistry();
  89                 if (registry == null) {
  90                         registry = new TreeSRegistry();
  91                         registry.setStatus(TreeSRegistry.STATUS_ACTIVE);
  92                         treeSRegistryDao.create(registry);
  93                         return treeSRegistryDao.getActiveTreeSRegistry();
  94                 } else {
  95                         return registry;
  96                 }
  97         }
  98
  99         /** Sets the DAO to use in order to persist the results. */
 100         public void setTestResultDao(TreeTestResultDao testResultDao) {
 101                 this.testResultDao = testResultDao;
 102         }
 103
 104         /** Sets the tree structure path DAO. */
 105         public void setTreeSPathDao(TreeSPathDao treeSPathDao) {
 106                 this.treeSPathDao = treeSPathDao;
 107         }
 108
 109         /** Sets the tree structure registry DAO. */
 110         public void setTreeSRegistryDao(TreeSRegistryDao treeSRegistryDao) {
 111                 this.treeSRegistryDao = treeSRegistryDao;
 112         }
 113
 114 }