Changeset 6934

Timestamp:

Jun 22, 2015, 3:37:26 PM (8 years ago)

Author:

Nicklas Nordborg

Message:

References #1950: Add support for any-to-any link filters in table lists views

Redesigned the hibernate filter definitions to make it possible to only activate the filters for a single item type (=the item type reutned by a query) at a time.

Location:

trunk/src/core/net/sf/basedb/core

Files:

• AbstractEntityQuery.java (modified) (1 diff)
• HibernateUtil.java (modified) (8 diffs)
• QueryRuntimeFilterManager.java (modified) (3 diffs)
• filter-def-template.xml (moved) (moved from trunk/src/core/net/sf/basedb/core/filter-def.hbm.xml)

trunk/src/core/net/sf/basedb/core/AbstractEntityQuery.java

@@ -359 +359 @@
     if (requiredFilter != null || optionalFilter != null)
     {
-      filterManager = new QueryRuntimeFilterManager(dc);
+      filterManager = new QueryRuntimeFilterManager(dc, getItemType());
       if (requiredFilter != null) requiredFilter.enableFilters(filterManager, this, dc);
       if (optionalFilter != null) optionalFilter.enableFilters(filterManager, this, dc);

trunk/src/core/net/sf/basedb/core/HibernateUtil.java

@@ -55 +55 @@
 import java.util.ArrayList;
 import java.util.Enumeration;
+import java.util.HashMap;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Iterator;
 import java.util.Date;
+import java.util.Map;
 import java.util.jar.JarEntry;
 import java.util.jar.JarFile;
@@ -67 +69 @@
 import java.sql.DatabaseMetaData;
 import java.sql.SQLException;
+import java.io.IOException;
 import java.net.URL;
 
@@ -302 +305 @@
         }
       }
+
       
       // Load the XML mapping files and register them with Hibernate
       final URL dtdFile = HibernateUtil.class.getResource("/org/hibernate/hibernate-mapping-3.0.dtd");
+      Map<String, Element> filterTemplate = loadFilterTemplate(dtdFile);
       DOMOutputter out = new DOMOutputter();
       for (URL url : mappingFiles)
@@ -310 +315 @@
         log.info("Loading mapping file: " + url);
         Document dom = XmlUtil2.getValidatedXml(url, dtdFile);
-        manipulateDocument(dom);
+        manipulateDocument(dom, filterTemplate);
         cfg.addDocument(out.output(dom));
       }
@@ -334 +339 @@
     
   */
-  private static void manipulateDocument(Document dom)
-  {
-    // Get the <class> tag
-    Element classTag = dom.getRootElement().getChild("class");
-    String className = classTag != null ? classTag.getAttributeValue("name") : null;
-    // We are only interested in <hibernate-mapping> with <class> elements
-    if (className == null) return;
-    
-    // Extended properties
-    if (ExtendedProperties.isExtendable(className))
-    {
-      addExtendedProperties(classTag, className);
-    }
-    
-    // Permission filters
-    addFilterConditions(classTag, className);
-    
-    // Unit symbol need to be case-sensitive
-    if (className.endsWith("UnitSymbolData"))
-    {
-      fixUnitSymbolColumnDefinition(classTag);
+  private static void manipulateDocument(Document dom, Map<String, Element> filterTemplate)
+  {
+    Element root = dom.getRootElement();
+    
+    // Load all <class> and <subclass> tags in the document
+    Iterator<Element> it = root.getDescendants(new org.jdom2.filter.AbstractFilter<Element>()
+      {
+        private static final long serialVersionUID = 1L;
+
+        @Override
+        public Element filter(Object obj)
+        {
+          if (!(obj instanceof Element)) return null;
+  
+          Element e = (Element)obj;
+          String name = e.getName();
+          return "class".equals(name) || "subclass".equals(name) ? e : null;
+        }
+      });
+    
+    // Copy to a list since we can't use the iterater and add elements to the
+    // document at the same time (ConcurrentModificationException)
+    List<Element> classTags = new ArrayList<Element>();
+    while (it.hasNext())
+    {
+      classTags.add(it.next());
+    }
+    
+    for (Element classTag: classTags)
+    {
+      String className = classTag.getAttributeValue("name");
+    
+      // Extended properties
+      if (ExtendedProperties.isExtendable(className))
+      {
+        addExtendedProperties(classTag, className);
+      }
+    
+      // Permission filters
+      addFilterConditions(classTag, className, filterTemplate);
+      
+      // Unit symbol need to be case-sensitive
+      if (className.endsWith("UnitSymbolData"))
+      {
+        fixUnitSymbolColumnDefinition(classTag);
+      }
     }
   }
@@ -395 +425 @@
   
   /**
+    Load filter definitions from 'filter-def-template.xml'. Store in map
+    using the name of the filter as key.
+    @since 3.6
+  */
+  private static Map<String, Element> loadFilterTemplate(final URL dtdFile)
+    throws IOException
+  {
+    Document filterDef = XmlUtil2.getValidatedXml(HibernateUtil.class.getResource("/net/sf/basedb/core/filter-def-template.xml"), dtdFile);
+    Map<String, Element> filters = new HashMap<String, Element>();
+    for (Element filter : filterDef.getRootElement().getChildren())
+    {
+      filters.put(filter.getAttributeValue("name"), filter);
+    }
+    return filters;
+  }
+  
+  /**
     Add &lt;filter&gt; conditions to the given class tag.
     @param classTag An Element representing a &lt;class&gt; tag
@@ -400 +447 @@
     @since 2.17
   */
-  private static void addFilterConditions(Element classTag, String className)
+  private static void addFilterConditions(Element classTag, String className, Map<String, Element> filterTemplate)
   {
     try
     {
       Class<?> c = Class.forName(className);
+      Item itemType = Item.fromClass(c);
       log.info("Adding 'denyAll' filter to "+c.getName());
-      classTag.addContent(createFilterElement("denyAll", "`id` != `id`"));
+      System.out.println("Class: " + c + "; itemType: " + itemType);
+      if (itemType == null) return;
+      
+      defineFilter(classTag, itemType, "denyAll", "`id` != `id`", filterTemplate);
       if (NewsData.class.isAssignableFrom(c))
       {
         log.info("Adding 'todaysNews' filter to "+c.getName());
-        classTag.addContent(createFilterElement("todaysNews", 
-            ":today >= `start_date` AND (:today <= `end_date` OR `end_date` IS NULL)"));
+        defineFilter(classTag, itemType, "todaysNews", 
+            ":today >= `start_date` AND (:today <= `end_date` OR `end_date` IS NULL)", filterTemplate);
       }
       if (MessageData.class.isAssignableFrom(c))
       {
         log.info("Adding 'ownedBy' filter to " + c.getName());
-        classTag.addContent(createFilterElement("ownedBy", ":owner = `to_user_id`"));
+        defineFilter(classTag, itemType, "ownedBy", ":owner = `to_user_id`", filterTemplate);
       }
       if (AnnotationData.class.isAssignableFrom(c))
       {
         log.info("Adding 'annotationTypes' filter to " + c.getName());
-        classTag.addContent(createFilterElement("annotationTypes", "`annotationtype_id` IN (:annotationTypes)"));
+        defineFilter(classTag, itemType, "annotationTypes", "`annotationtype_id` IN (:annotationTypes)", filterTemplate);
       }
       if (RemovableData.class.isAssignableFrom(c))
       {
         log.info("Adding 'isRemoved' filter to "+c.getName());
-        classTag.addContent(createFilterElement("isRemoved", ":removed = `removed`"));
+        defineFilter(classTag, itemType, "isRemoved", ":removed = `removed`", filterTemplate);
       }
       if (AnnotatableData.class.isAssignableFrom(c))
       {
         log.info("Adding 'isAnnotatated' filter to "+c.getName());
-        classTag.addContent(createFilterElement("isAnnotated", ":annotated = (`annotationset_id` IS NOT NULL)"));
+        defineFilter(classTag, itemType, "isAnnotated", ":annotated = (`annotationset_id` IS NOT NULL)", filterTemplate);
       }
       if (OwnableData.class.isAssignableFrom(c))
       {
         log.info("Adding 'ownedBy' filter to "+c.getName());
-        classTag.addContent(createFilterElement("ownedBy", ":owner = `owner`"));
+        defineFilter(classTag, itemType, "ownedBy", ":owner = `owner`", filterTemplate);
         
         log.info("Adding 'notOwnedBy' filter to "+c.getName());
-        classTag.addContent(createFilterElement("notOwnedBy", ":owner != `owner`"));
+        defineFilter(classTag, itemType, "notOwnedBy", ":owner != `owner`", filterTemplate);
   
         log.info("Adding 'memberOf' filter to "+c.getName());
-        classTag.addContent(createFilterElement("memberOf", ":owner != `owner` AND `id` IN (:items)"));
+        defineFilter(classTag, itemType, "memberOf", ":owner != `owner` AND `id` IN (:items)", filterTemplate);
   
         log.info("Adding 'ownedByOrMemberOf' filter to "+c.getName());
-        classTag.addContent(createFilterElement("ownedByOrMemberOf", "(:owner = `owner` OR `id` IN (:items))"));
+        defineFilter(classTag, itemType, "ownedByOrMemberOf", "(:owner = `owner` OR `id` IN (:items))", filterTemplate);
       }
       else if (UserData.class.isAssignableFrom(c))
       {
         log.info("Adding 'memberOf' filter to "+c.getName());
-        classTag.addContent(createFilterElement("memberOf", "(`id` IN (:items) OR `id` = :owner)"));
+        defineFilter(classTag, itemType, "memberOf", "(`id` IN (:items) OR `id` = :owner)", filterTemplate);
       }
       else
       {
         log.info("Adding 'memberOf' filter to "+c.getName());
-        classTag.addContent(createFilterElement("memberOf", "`id` IN (:items)"));
+        defineFilter(classTag, itemType, "memberOf", "`id` IN (:items)", filterTemplate);
       }
       if (ShareableData.class.isAssignableFrom(c))
       {
         log.info("Adding 'sharedTo' filter to "+c.getName());
-        classTag.addContent(createFilterElement("sharedTo", ":owner != `owner` AND `itemkey_id` IN (:itemKeys)"));
+        defineFilter(classTag, itemType, "sharedTo", ":owner != `owner` AND `itemkey_id` IN (:itemKeys)", filterTemplate);
   
         log.info("Adding 'inProject' filter to "+c.getName());
-        classTag.addContent(createFilterElement("inProject", "`projectkey_id` IN (:projectKeys)"));
+        defineFilter(classTag, itemType, "inProject", "`projectkey_id` IN (:projectKeys)", filterTemplate);
   
         log.info("Adding 'ownedByOrSharedTo' filter to "+c.getName());
-        classTag.addContent(createFilterElement("ownedByOrSharedTo", "(:owner = `owner` OR `itemkey_id` IN (:itemKeys))"));
+        defineFilter(classTag, itemType, "ownedByOrSharedTo", "(:owner = `owner` OR `itemkey_id` IN (:itemKeys))", filterTemplate);
   
         log.info("Adding 'ownedByOrInProject' filter to "+c.getName());
-        classTag.addContent(createFilterElement("ownedByOrInProject", 
-            "(:owner = `owner` OR `projectkey_id` IN (:projectKeys))"));
+        defineFilter(classTag, itemType, "ownedByOrInProject", 
+            "(:owner = `owner` OR `projectkey_id` IN (:projectKeys))", filterTemplate);
   
         log.info("Adding 'sharedToOrInProject' filter to "+c.getName());
-        classTag.addContent(createFilterElement("sharedToOrInProject", 
-            "((:owner != `owner` AND `itemkey_id` IN (:itemKeys)) OR `projectkey_id` IN (:projectKeys))"));
+        defineFilter(classTag, itemType, "sharedToOrInProject", 
+            "((:owner != `owner` AND `itemkey_id` IN (:itemKeys)) OR `projectkey_id` IN (:projectKeys))", filterTemplate);
   
         log.info("Adding 'ownedByOrSharedToOrInProject' filter to "+c.getName());
-        classTag.addContent(createFilterElement("ownedByOrSharedToOrInProject", 
-            "(:owner = `owner` OR `itemkey_id` IN (:itemKeys) OR `projectkey_id` IN (:projectKeys))"));
+        defineFilter(classTag, itemType, "ownedByOrSharedToOrInProject", 
+            "(:owner = `owner` OR `itemkey_id` IN (:itemKeys) OR `projectkey_id` IN (:projectKeys))", filterTemplate);
       }
     }
@@ -488 +539 @@
     
   /**
-    Create a &lt;filter&gt; tag using the given name and condition.
-    @since 2.17
-  */
-  private static Element createFilterElement(String name, String condition)
-  {
+    Define a filter for on the given class.
+    @since 3.6
+  */
+  private static void defineFilter(Element classTag, Item itemType, String name, String condition, Map<String, Element> filterTemplate)
+  {
+    // Load the template
+    Element filterSource = filterTemplate.get(name);
+    if (filterSource == null) return;
+
+    // Define the filter by cloning the template onto the
+    // root element and set the name including the item type.
+    Element filterDef = filterSource.clone();
+    filterDef.setAttribute("name", name + itemType.name());
+    classTag.getDocument().getRootElement().addContent(filterDef);
+
+    // Second part of the filter definition goes inside the
+    // class tag
     Element element = new Element("filter");
-    element.setAttribute("name", name);
+    element.setAttribute("name", name + itemType.name());
     element.setAttribute("condition", condition);
-    return element;
+    classTag.addContent(element);
+    
+    System.out.println("Adding filter def: " + filterDef.getAttributeValue("name") + " to " + classTag.getAttributeValue("name"));
+    
   }
   

trunk/src/core/net/sf/basedb/core/QueryRuntimeFilterManager.java

@@ -49 +49 @@
   private final org.hibernate.Session session;
 
+  private final Item itemType;
+  
   /**
     Create a new manager for the <code>DbControl</code>.
+    The manager will only manage filters for queries returning
+    item of the given item type.
   */
-  QueryRuntimeFilterManager(DbControl dc)
+  QueryRuntimeFilterManager(DbControl dc, Item itemType)
   {
     this.enabledFilters = new HashSet<String>();
     this.session = dc.getHibernateSession();
+    this.itemType = itemType;
   }
   
@@ -67 +72 @@
   {
     org.hibernate.Filter filter = null;
-    if (!enabledFilters.contains(filterName))
+    String name = filterName + itemType.name();
+    if (!enabledFilters.contains(name))
     {
-      filter = HibernateUtil.enableFilter(session, filterName);
-      enabledFilters.add(filterName);
+      filter = HibernateUtil.enableFilter(session, name);
+      enabledFilters.add(name);
     }
     return filter;
@@ -81 +87 @@
   void disableFilter(String filterName)
   {
-    if (enabledFilters.contains(filterName))
+    String name = filterName + itemType.name();
+    if (enabledFilters.contains(name))
     {
-      HibernateUtil.disableFilter(session, filterName);
-      enabledFilters.remove(filterName);
+      HibernateUtil.disableFilter(session, name);
+      enabledFilters.remove(name);
     }
   }