Changeset 6455

Timestamp:

May 9, 2014, 10:31:05 AM (8 years ago)

Author:

Nicklas Nordborg

Message:

Fixes #1805: Item overview fail to load upstream extracts from physical bioassays

Location:

trunk/src/core/net/sf/basedb/util/overview

Files:

• NodeAttribute.java (modified) (2 diffs)
• filter/HasAttributeFilter.java (modified) (4 diffs)
• loader/ExtractLoader.java (modified) (6 diffs)

trunk/src/core/net/sf/basedb/util/overview/NodeAttribute.java

@@ -21 +21 @@
 */
 package net.sf.basedb.util.overview;
+
+import java.util.Set;
 
 import net.sf.basedb.core.Extract;
@@ -45 +47 @@
   */
   public static NodeAttribute<Extract> EXTRACT = new NodeAttribute<Extract>();
+  
+  /**
+    Store the ID values of extracts that should be followed on
+    upstream paths as long as the current extract is not among
+    one of the given parent extracts.
+    @since 3.3
+  */
+  public static NodeAttribute<Set<Integer>> EXTRACT_PATH = new NodeAttribute<Set<Integer>>();
 
   

trunk/src/core/net/sf/basedb/util/overview/filter/HasAttributeFilter.java

@@ -28 +28 @@
 /**
   A filter implementation that checks if a value for a given attribute
-  existsin on a node. It will evaluate to true for all {@link Node}:s that
+  exists on a node. It will evaluate to true for all {@link Node}:s that
   has a value for a specific attribute.
 
@@ -40 +40 @@
   
   private final NodeAttribute<?> attribute;
+  private final Object value;
   
   /**
@@ -48 +49 @@
   public HasAttributeFilter(NodeAttribute<?> attribute)
   {
+    this(attribute, null);
+  }
+  
+  /**
+    Create a filter that finds nodes that has a specific value for the given
+    attribute.
+    @param attribute The attribute to check
+    @param value The value that must match
+    @since 3.3
+  */
+  public HasAttributeFilter(NodeAttribute<?> attribute, Object value)
+  {
     this.attribute = attribute;
+    this.value = value;
   }
 
@@ -58 +72 @@
   public boolean evaluate(Node node)
   {
-    return node.hasAttribute(attribute);
+    if (value == null)
+    {
+      return node.hasAttribute(attribute);
+    }
+    else
+    {
+      return value.equals(node.getAttribute(attribute));
+    }
   }
   // -----------------------------

trunk/src/core/net/sf/basedb/util/overview/loader/ExtractLoader.java

@@ -43 +43 @@
 import net.sf.basedb.core.query.Hql;
 import net.sf.basedb.core.query.Restrictions;
+import net.sf.basedb.util.biomaterial.ChildrenTransformer;
+import net.sf.basedb.util.collections.BasicItemToIdTransformer;
 import net.sf.basedb.util.overview.Fix;
 import net.sf.basedb.util.overview.NodeAttribute;
@@ -53 +55 @@
 import net.sf.basedb.util.overview.Node;
 import net.sf.basedb.util.overview.node.NodeFactory;
-import net.sf.basedb.util.query.MultiQueryIterator;
 
 /**
@@ -254 +255 @@
     ItemQuery<Extract> query = (ItemQuery<Extract>)context.initQuery(
         product.getCreationEvent().getSources(), "name");
+    
+    // Check if we are follwing a specific paths of extracts due to DerivedBioAssay.getExtract
+    Node extractPath = parentNode.getFirstParent(new HasAttributeFilter(NodeAttribute.EXTRACT_PATH));
+    if (extractPath != null)
+    {
+      // Yes, we are following a specific paths of extracts...
+      // Is the parent item still on the path?
+      if (extractPath.getAttribute(NodeAttribute.EXTRACT_PATH).contains(product.getId()))
+      {
+        // Yes, but is the parent item one of the specified extract on a DerivedBioassay?
+        if (parentNode.getFirstParent(new HasAttributeFilter(NodeAttribute.EXTRACT, product)) == null)
+        {
+          // No, so we have not found the 'exit' extract
+          // and we must only load extracts that are part of the path
+          query.restrict(Restrictions.in(Hql.property("id"), Expressions.parameter("extracts")));
+          query.setParameter("extracts", extractPath.getAttribute(NodeAttribute.EXTRACT_PATH), Type.INT);
+        }
+      }
+    }
+    
     ItemResultIterator<Extract> it = query.iterate(dc);
     int numExtracts = 0;
@@ -316 +337 @@
 
     ItemQuery<Extract> query = context.initQuery(bioAssay.getExtracts(0), "name");
-    ItemQuery<Extract> extraQuery = null;
-
     // If we have followed this path from derived bioassays that has specified an 
     // extract we should only load the same extracts when following the path upstreams
-    // We look for both 
-    Set<Integer> extractIds = getExtractChain(bioAssayNode);
-    if (extractIds.size() > 0) 
-    {
-      query.restrict(
-        Restrictions.in(Hql.property("id"), Expressions.parameter("extracts"))
-        );
-      query.setParameter("extracts", extractIds, Type.INT);
-
-      extraQuery = context.initQuery(bioAssay.getExtracts(0), "name");
-      extraQuery.join(Hql.leftJoin("creationEvent", "cevt"));
-      extraQuery.join(Hql.leftJoin("cevt", "sources", "sss", null, false));
+    Set<Extract> extracts = getExtractChain(bioAssayNode);
+    if (extracts.size() > 0) 
+    {
+      // Since we don't know exactly how far upstreams the given extrcts are we
+      // must first find all child items (recursively)
+      Set<Integer> allChildren = getAllChildren(dc, extracts);
+      // We keep the set of all child extracts since we need that later
+      // when moving up the parent chain (see createPooledReverseNode)
+      bioAssayNode.setAttribute(NodeAttribute.EXTRACT_PATH, allChildren);
       
-      extraQuery.restrict(
-        Restrictions.in(Hql.property("sss", "bioMaterial"), Expressions.parameter("extracts"))
-        );
-      extraQuery.setParameter("extracts", extractIds, Type.INT);
-    }
-    Iterator<Extract> it = MultiQueryIterator.get(dc, query, extraQuery);
+      // An we must of course limit the extracts on this level also
+      query.restrict(Restrictions.in(Hql.property("id"), Expressions.parameter("extracts")));
+      query.setParameter("extracts", allChildren, Type.INT);
+    }
+    Iterator<Extract> it = query.iterate(dc);
     while (it.hasNext())
     {
@@ -348 +363 @@
       createItemNode(nf, extract, extract, false, folderNode, ChildNodeDirection.REVERSE);
     }
-    postValidateFolder(nf, folderNode, bioAssayNode, extractIds.size() > 0);
+    postValidateFolder(nf, folderNode, bioAssayNode, extracts.size() > 0);
     return folderNode;
   }
@@ -459 +474 @@
   }
   
-  private Set<Integer> getExtractChain(Node node)
+  private Set<Extract> getExtractChain(Node node)
   {
     List<Node> nodesWithExtract = node.findAll(new HasAttributeFilter(NodeAttribute.EXTRACT));
-    Set<Integer> extractIds = new HashSet<Integer>(nodesWithExtract.size());
+    Set<Extract> extracts = new HashSet<Extract>(nodesWithExtract.size());
     for (Node n : nodesWithExtract)
     {
-      extractIds.add(n.getAttribute(NodeAttribute.EXTRACT).getId());
-    }
-    return extractIds;
+      extracts.add(n.getAttribute(NodeAttribute.EXTRACT));
+    }
+    return extracts;
+  }
+  
+  private Set<Integer> getAllChildren(DbControl dc, Set<Extract> parents)
+  {
+    Set<Extract> all = new HashSet<Extract>();
+    ChildrenTransformer<Extract> transformer = new ChildrenTransformer<Extract>(dc, true, Extract.getQuery());
+    transformer.transform(parents, all);
+    BasicItemToIdTransformer idTransformer = new BasicItemToIdTransformer();
+    Set<Integer> allIds = new HashSet<Integer>(all.size());
+    idTransformer.transform(all, allIds);
+    return allIds;
   }