feat(tables): improve/formalize support for tables being added to more than 1 app.

- Add map of redirects to MetaDataOutput (to redirect a user from links to a table through an app that they don't have access to, instead to an app that they do have access to).
- Add concept of app-affinity to QAppMetaData (where a table (etc) is placed in an app, the developer can then also specify the affinity value for that table in that app).
- Update QInstance.getTablePath to return the path with the highest affinity value for a table in multiple apps

Also, in MetaDataAction:
- consolidate calls to PermissionsHelper.getPermissionCheckResult and customizer.allowXyz into new denyObject() method (one, to shorten all call sites, but also, to catch some cases where one was called but not the other)

Author: darinkelkhoff

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/actions/metadata/MetaDataAction.java

@@ -22,6 +22,7 @@
 package com.kingsrook.qqq.backend.core.model.actions.metadata;
 
 
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import com.kingsrook.qqq.backend.core.model.actions.AbstractActionOutput;
@@ -54,6 +55,7 @@ public class MetaDataOutput extends AbstractActionOutput
    private QBrandingMetaData               branding;
    private Map<String, List<QHelpContent>> helpContents;
 
+   private Map<String, String> redirects;
 
 
    /*******************************************************************************
@@ -273,4 +275,68 @@ public Map<String, List<QHelpContent>> getHelpContents()
    {
       return helpContents;
    }
+
+
+
+   /*******************************************************************************
+    * Getter for redirects
+    * @see #withRedirects(Map)
+    *******************************************************************************/
+   public Map<String, String> getRedirects()
+   {
+      return (this.redirects);
+   }
+
+
+
+   /*******************************************************************************
+    * Setter for redirects
+    * @see #withRedirects(Map)
+    *******************************************************************************/
+   public void setRedirects(Map<String, String> redirects)
+   {
+      this.redirects = redirects;
+   }
+
+
+
+   /*******************************************************************************
+    * Fluent setter for redirects
+    *
+    * @param redirects
+    * Map of string to string, where the key is the URL path to redirect from, and
+    * the value is the URL path to redirect to.
+    *
+    * <p>The core {@link com.kingsrook.qqq.backend.core.actions.metadata.MetaDataAction}
+    * will build some of these redirects automatically, e.g., for the use case of a
+    * table in multiple apps, but where a user doesn't have permission to all of those apps.</p>
+    *
+    * <p>An app may build its own redirects via a
+    * {@link com.kingsrook.qqq.backend.core.actions.metadata.MetaDataActionCustomizerInterface},
+    * for whatever custom logic is needed.</p>
+    *
+    * @return this
+    *******************************************************************************/
+   public MetaDataOutput withRedirects(Map<String, String> redirects)
+   {
+      this.redirects = redirects;
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    * Fluent setter to add a single redirect.
+    * @see #withRedirects(Map)
+    ***************************************************************************/
+   public MetaDataOutput withRedirect(String from, String to)
+   {
+      if(this.redirects == null)
+      {
+         this.redirects = new LinkedHashMap<>();
+      }
+      this.redirects.put(from, to);
+      return (this);
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/actions/metadata/MetaDataOutput.java

@@ -24,11 +24,13 @@
 
 import java.util.ArrayList;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import com.fasterxml.jackson.annotation.JsonIgnore;
@@ -153,6 +155,8 @@ public class QInstance
    private Map<String, String> memoizedTablePaths   = new HashMap<>();
    private Map<String, String> memoizedProcessPaths = new HashMap<>();
 
+   private ListingHash<String, PathWithAffinity> memoizedPathsMap = null;
+
    private JoinGraph joinGraph;
 
 
@@ -250,9 +254,30 @@ public String getTablePath(String tableName) throws QException
       {
          QContext.withTemporaryContext(new CapturedContext(QContext.getQInstance(), new QSystemUserSession()), () ->
          {
-            MetaDataInput  input  = new MetaDataInput();
-            MetaDataOutput output = new MetaDataAction().execute(input);
-            memoizedTablePaths.put(tableName, searchAppTree(output.getAppTree(), tableName, AppTreeNodeType.TABLE, ""));
+            ////////////////////////////////////////////////////////
+            // get the (memoized) map of name to paths+affinities //
+            ////////////////////////////////////////////////////////
+            ListingHash<String, PathWithAffinity> memoizedPathsMap = getMemoizedPathsMap();
+
+            //////////////////////////////////////////
+            // get the list of paths for this table //
+            //////////////////////////////////////////
+            List<PathWithAffinity> pathWithAffinityList = memoizedPathsMap.get(tableName);
+            if(CollectionUtils.nullSafeHasContents(pathWithAffinityList))
+            {
+               ///////////////////////////////////////////////////////////////////////////
+               // sort the list of paths by affinity (desc), and return the first entry //
+               ///////////////////////////////////////////////////////////////////////////
+               pathWithAffinityList.sort(Comparator.comparing(PathWithAffinity::affinity).reversed());
+               memoizedTablePaths.put(tableName, pathWithAffinityList.getFirst().path);
+            }
+            else
+            {
+               //////////////////////////////////////////////
+               // else, if there are no paths, return null //
+               //////////////////////////////////////////////
+               memoizedTablePaths.put(tableName, null);
+            }
          });
       }
 
@@ -261,6 +286,81 @@ public String getTablePath(String tableName) throws QException
 
 
 
+   /***************************************************************************
+    * Get the memoizedPathsMap, building it if necessary.
+    * @see #buildPathsMap()
+    ***************************************************************************/
+   private ListingHash<String, PathWithAffinity> getMemoizedPathsMap() throws QException
+   {
+      if(memoizedPathsMap == null)
+      {
+         memoizedPathsMap = buildPathsMap();
+      }
+
+      return memoizedPathsMap;
+   }
+
+
+
+   /***************************************************************************
+    * build a map (ListingHash) keyed by object (e.g., table, process) names,
+    * with values being lists (typically singletons, but for tables in multiple
+    * apps, multi-valued) of records, containing the path to the table within
+    * an app, and an appAffinity value - indicating which app is preferred to
+    * be used for the table (e.g., in global contexts).
+    *
+    ***************************************************************************/
+   private ListingHash<String, PathWithAffinity> buildPathsMap() throws QException
+   {
+      MetaDataInput                         input    = new MetaDataInput();
+      MetaDataOutput                        output   = new MetaDataAction().execute(input);
+      ListingHash<String, PathWithAffinity> pathsMap = new ListingHash<>();
+      populatePathsMap(pathsMap, output.getAppTree(), "");
+      return (pathsMap);
+   }
+
+
+
+   /***************************************************************************
+    * recursive implementation used by buildPathsMap() to traverse the appTree
+    * and populate the pathsMap.
+    *
+    * @param pathsMap the map to populate (output parameter)
+    * @param appTreeNodes the nodes to process (for top-level call should be
+    *                     the app tree root nodes (from MetaDataAction).
+    * @param path the current path being built (e.g., accumulates entries with
+    *             recursive calls)
+    * @see #buildPathsMap()
+    ***************************************************************************/
+   private void populatePathsMap(ListingHash<String, PathWithAffinity> pathsMap, List<AppTreeNode> appTreeNodes, String path)
+   {
+      for(AppTreeNode appTreeNode : appTreeNodes)
+      {
+         if(appTreeNode.getType().equals(AppTreeNodeType.APP) && CollectionUtils.nullSafeHasContents(appTreeNode.getChildren()))
+         {
+            populatePathsMap(pathsMap, appTreeNode.getChildren(), path + "/" + appTreeNode.getName());
+         }
+         else
+         {
+            Integer affinity = Objects.requireNonNullElse(appTreeNode.getAppAffinity(), Integer.MIN_VALUE);
+            pathsMap.add(appTreeNode.getName(), new PathWithAffinity(path + "/" + appTreeNode.getName(), affinity));
+         }
+      }
+   }
+
+
+
+   /***************************************************************************
+    * private record to associate a path (through apps to a table, process, etc)
+    * with an affinity value indicating which app is preferred to be used for
+    * the table (e.g., in global contexts).
+    ***************************************************************************/
+   private record PathWithAffinity(String path, Integer affinity)
+   {
+   }
+
+
+
    /*******************************************************************************
     * Get the full path to a process - note - this will be regardless of whether or
     * not the active session/user has access to the process.  You may want to also call

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/QInstance.java

@@ -39,13 +39,15 @@
  ** These objects are organized into a tree - where each Node can have 0 or more
  ** other Nodes as children.
  *******************************************************************************/
-public class AppTreeNode
+public class AppTreeNode implements Cloneable
 {
    private AppTreeNodeType   type;
    private String            name;
    private String            label;
    private List<AppTreeNode> children;
 
+   private Integer appAffinity;
+
    private QIcon icon;
 
 
@@ -166,4 +168,67 @@ public void addChild(AppTreeNode childTreeNode)
       }
       children.add(childTreeNode);
    }
+
+
+
+   /*******************************************************************************
+    * Getter for appAffinity
+    * @see #withAppAffinity(Integer)
+    *******************************************************************************/
+   public Integer getAppAffinity()
+   {
+      return (this.appAffinity);
+   }
+
+
+
+   /*******************************************************************************
+    * Setter for appAffinity
+    * @see #withAppAffinity(Integer)
+    *******************************************************************************/
+   public void setAppAffinity(Integer appAffinity)
+   {
+      this.appAffinity = appAffinity;
+   }
+
+
+
+   /*******************************************************************************
+    * Fluent setter for appAffinity
+    *
+    * @param appAffinity
+    * appAffinity level for this child node, as it is related to its parent app.
+    * See {@link QAppMetaData#setChildAppAffinity(String, Integer)}.
+    * @return this
+    *******************************************************************************/
+   public AppTreeNode withAppAffinity(Integer appAffinity)
+   {
+      this.appAffinity = appAffinity;
+      return (this);
+   }
+
+
+
+   /***************************************************************************
+    *
+    ***************************************************************************/
+   @Override
+   public AppTreeNode clone()
+   {
+      try
+      {
+         AppTreeNode clone = (AppTreeNode) super.clone();
+         if(children != null)
+         {
+            clone.children = new ArrayList<>();
+            children.forEach(child -> clone.children.add(child.clone()));
+         }
+         return clone;
+      }
+      catch(CloneNotSupportedException e)
+      {
+         throw new AssertionError();
+      }
+   }
+
 }

qqq-backend-core/src/main/java/com/kingsrook/qqq/backend/core/model/metadata/frontend/AppTreeNode.java

@@ -44,10 +44,12 @@
  *******************************************************************************/
 public class QAppMetaData implements QAppChildMetaData, MetaDataWithPermissionRules, TopLevelMetaDataInterface
 {
+   public static final Integer DEFAULT_SORT_ORDER = 500;
+
    private String name;
    private String label;
 
-   private Integer sortOrder = 500;
+   private Integer sortOrder = DEFAULT_SORT_ORDER;
 
    private QPermissionRules permissionRules;
 
@@ -59,6 +61,8 @@ public class QAppMetaData implements QAppChildMetaData, MetaDataWithPermissionRu
    private List<String>      widgets;
    private List<QAppSection> sections;
 
+   private Map<String, Integer> childAppAffinities;
+
    private Map<String, QSupplementalAppMetaData> supplementalMetaData;
 
 
@@ -521,4 +525,44 @@ public QAppMetaData withSupplementalMetaData(Map<String, QSupplementalAppMetaDat
       return (this);
    }
 
+
+
+   /***************************************************************************
+    * set an appAffinity for a child.  Higher values are higher affinity, with
+    * null (the default) considered the lowest. Tiebreaking behavior is not
+    * specified and may differ by use-case (e.g., by front-end), though app
+    * sort-order is recommended.
+    *
+    * <p>The purpose of this appAffinity is not about ordering the children of this
+    * app - but rather - for cases where the same object (e.g. a table) is
+    * referenced by multiple apps, and we want to control which app should be
+    * displayed first when the object is referenced.</p>
+    *
+    * @param childName name of child (e.g., a table name) to set appAffinity for
+    * @param appAffinity appAffinity level, or null to clear any existing appAffinity.
+    *                 Higher values are higher affinity.  null is lowest.
+    ***************************************************************************/
+   public void setChildAppAffinity(String childName, Integer appAffinity)
+   {
+      if(this.childAppAffinities == null)
+      {
+         this.childAppAffinities = new HashMap<>();
+      }
+
+      this.childAppAffinities.put(childName, appAffinity);
+   }
+
+
+
+   /***************************************************************************
+    * get the appAffinity assigned to this child (by name) for this app - null if not set.
+    *
+    * @param childName name of child (e.g., a table name) to get appAffinity for
+    * @return appAffinity level, or null if not set.
+    ***************************************************************************/
+   public Integer getChildAppAffinity(String childName)
+   {
+      return (this.childAppAffinities == null ? null : this.childAppAffinities.get(childName));
+   }
+
 }