plugins/org.argeo.slc.client.ui.dist/src/main/java/org/argeo/slc/client/ui/dist/model/ModularDistBaseElem.java

   1 package org.argeo.slc.client.ui.dist.model;
   2
   3 import javax.jcr.Node;
   4 import javax.jcr.NodeIterator;
   5 import javax.jcr.RepositoryException;
   6 import javax.jcr.query.QueryManager;
   7 import javax.jcr.query.QueryResult;
   8 import javax.jcr.query.qom.Constraint;
   9 import javax.jcr.query.qom.QueryObjectModel;
  10 import javax.jcr.query.qom.QueryObjectModelFactory;
  11 import javax.jcr.query.qom.Selector;
  12
  13 import org.argeo.ArgeoException;
  14 import org.argeo.slc.SlcException;
  15 import org.argeo.slc.jcr.SlcNames;
  16 import org.argeo.slc.jcr.SlcTypes;
  17
  18 /**
  19  * Abstract the base a given modular distribution set that is the parent all
  20  * versions of the same distribution
  21  */
  22 public class ModularDistBaseElem extends DistParentElem {
  23
  24         final static public String AETHER_CATEGORY_BASE = "categoryBase";
  25         final static public String AETHER_BINARIES_TYPE = "binaries";
  26         final static public String AETHER_DEP_TYPE = "dep";
  27         private String type;
  28         private Node artifactBase;
  29
  30         public ModularDistBaseElem(WorkspaceElem wkspElem, String name,
  31                         Node artifactBase, String type) {
  32                 super(name, wkspElem.inHome(), wkspElem.isReadOnly());
  33                 setParent(wkspElem);
  34                 this.artifactBase = artifactBase;
  35                 this.type = type;
  36         }
  37
  38         public Node getCategoryBase() {
  39                 // TODO clean this
  40                 if (type.equals(AETHER_CATEGORY_BASE))
  41                         return artifactBase;
  42                 else
  43                         try {
  44                                 return artifactBase.getParent();
  45                         } catch (RepositoryException e) {
  46                                 throw new SlcException("unable tyo get parent node for "
  47                                                 + artifactBase, e);
  48                         }
  49         }
  50
  51         /**
  52          * Override normal behavior to initialize children only when first requested
  53          */
  54         @Override
  55         public synchronized boolean hasChildren() {
  56                 if (isLoaded()) {
  57                         return super.hasChildren();
  58                 } else {
  59                         return true;
  60                 }
  61         };
  62
  63         /**
  64          * Override normal behavior to initialize children only when first requested
  65          */
  66         @Override
  67         public synchronized Object[] getChildren() {
  68                 if (isLoaded()) {
  69                         return super.getChildren();
  70                 } else {
  71                         // initialize current object
  72                         try {
  73                                 NodeIterator ni = getDistVersions();
  74                                 while (ni != null && ni.hasNext()) {
  75                                         Node curNode = ni.nextNode();
  76                                         addChild(new ModularDistVersionElem(this, curNode
  77                                                         .getProperty(SlcNames.SLC_ARTIFACT_VERSION)
  78                                                         .getString(), curNode));
  79                                 }
  80                                 return super.getChildren();
  81                         } catch (RepositoryException re) {
  82                                 throw new ArgeoException(
  83                                                 "Unexcpected error while initializing children SingleJcrNode",
  84                                                 re);
  85                         }
  86                 }
  87         }
  88
  89         private NodeIterator getDistVersions() {
  90                 try {
  91                         if (AETHER_CATEGORY_BASE.equals(type))
  92                                 return null;
  93
  94                         QueryManager queryManager = artifactBase.getSession()
  95                                         .getWorkspace().getQueryManager();
  96                         QueryObjectModelFactory factory = queryManager.getQOMFactory();
  97                         Selector source = factory.selector(
  98                                         SlcTypes.SLC_MODULAR_DISTRIBUTION,
  99                                         SlcTypes.SLC_MODULAR_DISTRIBUTION);
 100                         Constraint constraint = factory.descendantNode(
 101                                         source.getSelectorName(), artifactBase.getPath());
 102                         // Ordering order = factory.descending(factory.propertyValue(
 103                         // source.getSelectorName(), SlcNames.SLC_ARTIFACT_VERSION));
 104                         // Ordering[] orderings = { order };
 105                         QueryObjectModel query = factory.createQuery(source, constraint,
 106                                         null, null);
 107                         QueryResult queryResult = query.execute();
 108                         return queryResult.getNodes();
 109                 } catch (RepositoryException e) {
 110                         throw new SlcException(
 111                                         "Unable to version for modular distribution: " + getName(),
 112                                         e);
 113                 }
 114         }
 115
 116         public String getType() {
 117                 return type;
 118         }
 119
 120 }