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