org.argeo.slc.core/src/main/java/org/argeo/slc/hibernate/structure/tree/TreeSRegistryDaoHibernate.java

   1 package org.argeo.slc.hibernate.structure.tree;
   2
   3 import java.util.List;
   4
   5 import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
   6
   7 import org.apache.commons.logging.Log;
   8 import org.apache.commons.logging.LogFactory;
   9
  10 import org.argeo.slc.core.structure.SimpleSElement;
  11 import org.argeo.slc.core.structure.StructureElement;
  12 import org.argeo.slc.core.structure.StructureRegistry;
  13 import org.argeo.slc.core.structure.tree.TreeSPath;
  14 import org.argeo.slc.core.structure.tree.TreeSRegistry;
  15 import org.argeo.slc.dao.structure.tree.TreeSPathDao;
  16 import org.argeo.slc.dao.structure.tree.TreeSRegistryDao;
  17 import org.hibernate.Session;
  18
  19 /**
  20  * The Hibernate implementation for tree-based structure registry.
  21  *
  22  * @see TreeSRegistry
  23  */
  24 public class TreeSRegistryDaoHibernate extends HibernateDaoSupport implements
  25                 TreeSRegistryDao {
  26
  27         private TreeSPathDao treeSPathDao;
  28
  29         private static Log log = LogFactory.getLog(TreeSRegistryDaoHibernate.class);
  30
  31         public void create(TreeSRegistry registry) {
  32                 getHibernateTemplate().save(registry);
  33         }
  34
  35         public void update(TreeSRegistry registryArg) {
  36                 Session session = getSession();
  37                 session.beginTransaction();
  38                 TreeSRegistry registry = (TreeSRegistry)session.merge(registryArg);
  39                 session.update(registry);
  40                 session.getTransaction().commit();
  41         }
  42
  43         public TreeSRegistry getActiveTreeSRegistry() {
  44                 List<?> list = getHibernateTemplate().find(
  45                                 "from TreeSRegistry where status=?",
  46                                 TreeSRegistry.STATUS_ACTIVE);
  47                 if (list.size() == 0) {
  48                         return null;
  49                 } else {
  50                         return (TreeSRegistry) list.get(0);
  51                 }
  52         }
  53
  54         public void syncPath(TreeSRegistry registryArg,
  55                         StructureRegistry<TreeSPath> localRegistry, TreeSPath pathArg) {
  56                 Session session = getSession();
  57                 session.beginTransaction();
  58                 TreeSRegistry registry = (TreeSRegistry)session.merge(registryArg);
  59                 TreeSPath path = (TreeSPath)session.merge(pathArg);
  60                 if (log.isTraceEnabled())
  61                         log.trace("Session#" + session.hashCode() + " " + session);
  62                 syncPathImpl(registry, localRegistry, path, session);
  63                 session.update(registry);
  64                 session.getTransaction().commit();
  65         }
  66
  67         private void syncPathImpl(TreeSRegistry registry,
  68                         StructureRegistry<TreeSPath> localRegistry, TreeSPath path,
  69                         Session session) {
  70                 if (path.getParent() != null) {
  71                         TreeSPath parent = treeSPathDao.getOrCreate(path.getParent());
  72                         syncPathImpl(registry, localRegistry, parent, session);
  73                 }
  74
  75                 if (log.isTraceEnabled())
  76                         log.trace("Synchronize path " + path);
  77
  78                 if (registry.getElement(path) == null) {
  79                         final StructureElement element = getElement(registry,
  80                                         localRegistry, path, session);
  81                         StructureElement elementPersisted = (StructureElement) session
  82                                         .merge(element);
  83                         registry.register(path, elementPersisted);
  84                         // update(registry);
  85
  86                         if (log.isTraceEnabled())
  87                                 log.trace("No element in persisted structure for " + path
  88                                                 + ", merged to " + elementPersisted);
  89                 } else {
  90                         if (localRegistry != null) {
  91                                 StructureElement element = getElement(registry, localRegistry,
  92                                                 path, session);
  93
  94                                 if (element != null) {
  95                                         StructureElement elementPersisted = (StructureElement) session
  96                                                         .merge(element);
  97                                         registry.register(path, elementPersisted);
  98                                         // update(registry);
  99                                         if (log.isTraceEnabled())
 100                                                 log
 101                                                                 .trace("Update existing element in persisted structure for "
 102                                                                                 + path
 103                                                                                 + ", merged to "
 104                                                                                 + elementPersisted);
 105                                 }
 106                         }
 107                 }
 108
 109         }
 110
 111         public void setTreeSPathDao(TreeSPathDao treeSPathDao) {
 112                 this.treeSPathDao = treeSPathDao;
 113         }
 114
 115         protected StructureElement getElement(TreeSRegistry registry,
 116                         StructureRegistry<TreeSPath> localRegistry, TreeSPath path,
 117                         Session session) {
 118                 StructureElement element;
 119                 if (localRegistry != null) {
 120                         element = localRegistry.getElement(path);
 121                         if (session.getSessionFactory()
 122                                         .getClassMetadata(element.getClass()) == null) {
 123                                 if (log.isTraceEnabled())
 124                                         log.trace("Replace non-hibernate element " + element
 125                                                         + " by a simple element.");
 126                                 element = new SimpleSElement(element.getLabel());
 127                         }
 128                 } else {
 129                         element = new SimpleSElement(path.getName());
 130                 }
 131                 return element;
 132         }
 133 }