REPORT-68740 【迭代】【数据集管理优化】数据集+数据列（不包含数据集），操作按钮未对应灰化

【问题原因】之前做的是，只取选中的有效数据集，然后做复制、粘贴、删除等操作
【改动思路】1. 应产品要求改成同时选中数据集+独立数据列时，复制粘贴删除等操作置灰；2. 将UI相关的代码移到TableDataTree里，TableDataTreeSearchManager那边仅保留搜索结果集用来判断节点是否应该展示以及节点是否应该展开
【review建议】无

designer-base/src/main/java/com/fr/design/data/datapane/TableDataTree.java

@@ -1,8 +1,10 @@
 package com.fr.design.data.datapane;
 
 import com.fr.base.BaseUtils;
+import com.fr.data.impl.storeproc.StoreProcedure;
 import com.fr.design.constants.UIConstants;
 import com.fr.design.data.datapane.management.search.TableDataTreeSearchManager;
+import com.fr.design.data.tabledata.wrapper.AbstractTableDataWrapper;
 import com.fr.design.data.tabledata.wrapper.TableDataWrapper;
 import com.fr.design.gui.itree.refreshabletree.ExpandMutableTreeNode;
 import com.fr.design.gui.itree.refreshabletree.UserObjectRefreshJTree;
@@ -19,7 +21,9 @@ import javax.swing.tree.TreePath;
 import java.awt.Color;
 import java.awt.Component;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * TableData Tree
@@ -27,6 +31,10 @@ import java.util.List;
 public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
     private static final long serialVersionUID = 1L;
 
+    private static final String TABLE_DATA_NODE = "tableData";
+
+    private static final String COLUMN_NODE = "column";
+
     /**
      * Constructor.
      */
@@ -87,6 +95,7 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
         this.tableDataTreeCellRenderer = tableDataTreeCellRenderer;
     }
 
+    @Override
     protected void refreshTreeNode(ExpandMutableTreeNode eTreeNode, String childName) {
         if (interceptRefresh(eTreeNode)) {
             return;
@@ -178,11 +187,11 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
         ExpandMutableTreeNode[] dsTreeNodes = loadChildTreeNodes(root);
         root.removeAllChildren();
         for (ExpandMutableTreeNode dsTreeNode : dsTreeNodes) {
-            if (TableDataTreeSearchManager.getInstance().nodeMatches(dsTreeNode)) {
+            if (TableDataTreeSearchManager.getInstance().nodeNameMatches(dsTreeNode.getUserObject().toString())) {
                 // 加载数据列节点
                 loadAndAddChildTreeChild(dsTreeNode);
                 // 处理子节点的展开
-                TableDataTreeSearchManager.getInstance().dealWithNodeExpand(dsTreeNode);
+                dealWithNodeExpand(dsTreeNode);
                 // 添加数据集子节点
                 root.add(dsTreeNode);
             }
@@ -196,7 +205,7 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
      * @return
      */
     private ExpandMutableTreeNode loadAndAddChildTreeChild(ExpandMutableTreeNode treeNode) {
-        if (TableDataTreeSearchManager.getInstance().isTreeNodeStoreProcedure(treeNode)) {
+        if (isTreeNodeStoreProcedure(treeNode)) {
             // 如果是存储过程，则再加载一次其子表节点，这里比较坑的就是存储过程不能使用loadChildTreeNodes
             int tableChildCounts = treeNode.getChildCount();
             ExpandMutableTreeNode[] childs = new ExpandMutableTreeNode[tableChildCounts];
@@ -215,9 +224,36 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
         return treeNode;
     }
 
+    /**
+     * 处理节点的展开，如果此节点是存储过程，还会处理其子表节点的展开
+     * 只针对数据集节点
+     *
+     * @param treeNode
+     * @return
+     */
+    public ExpandMutableTreeNode dealWithNodeExpand(ExpandMutableTreeNode treeNode) {
+        String tableDataName = treeNode.getUserObject().toString();
+        // 主要还是处理存储过程
+        if (isTreeNodeStoreProcedure(treeNode)) {
+            int childCount = treeNode.getChildCount();
+            for (int i = 0; i < childCount; i++) {
+                ExpandMutableTreeNode child = (ExpandMutableTreeNode) treeNode.getChildAt(i);
+                String nodeName = tableDataName + "_" + child.getUserObject().toString();
+                if (TableDataTreeSearchManager.getInstance().nodeCanExpand(nodeName)) {
+                    child.setExpanded(true);
+                }
+            }
+        }
+        if (TableDataTreeSearchManager.getInstance().nodeCanExpand(treeNode.getUserObject().toString())) {
+            treeNode.setExpanded(true);
+        }
+        return treeNode;
+    }
+
     /*
      * p:获得选中的NameObject = name + tabledata.
      */
+    @Override
     public NameObject getSelectedNameObject() {
         TreePath selectedTreePath = this.getSelectionPath();
         if (selectedTreePath == null) {
@@ -248,27 +284,47 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
     }
 
     /**
-     * 获得选中的NameObject的list，只会返回数据集节点的NameObject
+     * 获得选中的数据集节点的NameObject的数组，只会返回数据集节点的NameObject
      * 当多选了数据集或数据列时，也只返回选中的数据集
      */
-    public NameObject[] getSelectedNameObjects() {
+    public NameObject[] getSelectedTableDataNodes() {
+        Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
+        List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
+        if (tableDataNodes == null) {
+            return new NameObject[0];
+        }
+        return tableDataNodes.stream().map(node -> (NameObject) node.getUserObject()).toArray(NameObject[]::new);
+    }
+
+    /**
+     * 获取选中的数据集节点和列名节点
+     * 其中存储过程的子表节点不计入数据集节点中，仅存储过程节点本身计入数据集节点
+     * @return
+     */
+    private Map<String, List<ExpandMutableTreeNode>> getSelectedTableDataNodesAndColumnNodes() {
         TreePath[] selectedTreePaths = this.getSelectionPaths();
         if (selectedTreePaths == null) {
-            return new NameObject[0];
+            return new HashMap<>();
         }
-        List<NameObject> result = new ArrayList<>();
+        Map<String, List<ExpandMutableTreeNode>> resultMap = new HashMap<>();
+        List<ExpandMutableTreeNode> tableDataNodes = new ArrayList<>();
+        List<ExpandMutableTreeNode> columnNodes = new ArrayList<>();
+        resultMap.put(TABLE_DATA_NODE, tableDataNodes);
+        resultMap.put(COLUMN_NODE, columnNodes);
         for (TreePath selectedTreePath : selectedTreePaths) {
             if (selectedTreePath == null) {
                 continue;
             }
             ExpandMutableTreeNode selectedTreeNode = (ExpandMutableTreeNode) selectedTreePath.getLastPathComponent();
-            Object selectedUserObject = selectedTreeNode.getUserObject();
+            if (isTableDataNodes(selectedTreeNode)) {
-            // 只考虑数据集节点
+                // 数据集节点
-            if (selectedUserObject instanceof NameObject && ((NameObject) selectedUserObject).getObject() instanceof TableDataWrapper) {
+                tableDataNodes.add(selectedTreeNode);
-                result.add((NameObject) selectedUserObject);
+            } else {
+                // 列名节点
+                columnNodes.add(selectedTreeNode);
             }
         }
-        return result.toArray(new NameObject[0]);
+        return resultMap;
     }
 
     /**
@@ -276,8 +332,57 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
      *
      * @return
      */
-    public int getSelectedDsCounts() {
+    public int getSelectedTableDataCounts() {
-        return getSelectedNameObjects().length;
+        return getSelectedTableDataNodes().length;
+    }
+
+    /**
+     * 是否存在单独选了数据列节点，但没选其对应数据集的情况
+     * @return
+     */
+    public boolean hasSelectedIndependentColumns() {
+        Map<String, List<ExpandMutableTreeNode>> tableDataNodesAndColumnNodes = getSelectedTableDataNodesAndColumnNodes();
+        List<ExpandMutableTreeNode> tableDataNodes = tableDataNodesAndColumnNodes.get(TABLE_DATA_NODE);
+        List<ExpandMutableTreeNode> columnNodes = tableDataNodesAndColumnNodes.get(COLUMN_NODE);
+        if (columnNodes == null || columnNodes.size() == 0) {
+            // 未选中数据列
+            return false;
+        }
+        if (tableDataNodes == null || tableDataNodes.size() == 0) {
+            // 选中数据列而未选中数据集
+            return true;
+        }
+        boolean result = false;
+        for (ExpandMutableTreeNode columnNode : columnNodes) {
+            ExpandMutableTreeNode tableDataNode = getBelongedTableDataNodes(columnNode);
+            if (!tableDataNodes.contains(tableDataNode)) {
+                result = true;
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 获取一个节点归属的数据集层级父节点
+     * @param treeNode
+     * @return
+     */
+    private ExpandMutableTreeNode getBelongedTableDataNodes(ExpandMutableTreeNode treeNode) {
+        if (isTableDataNodes(treeNode)) {
+            return treeNode;
+        }
+        return getBelongedTableDataNodes((ExpandMutableTreeNode) treeNode.getParent());
+    }
+
+    private boolean isTableDataNodes(ExpandMutableTreeNode treeNode) {
+        if (treeNode == null) {
+            return false;
+        }
+        Object userObject = treeNode.getUserObject();
+        if (userObject instanceof NameObject && ((NameObject) userObject).getObject() instanceof AbstractTableDataWrapper) {
+            return true;
+        }
+        return false;
     }
 
     public TableDataWrapper[] getSelectedDatas() {
@@ -345,4 +450,20 @@ public class TableDataTree extends UserObjectRefreshJTree<TableDataSourceOP> {
 
         treeModel.reload(root);
     }
+
+    /**
+     * 判断此节点是否为存储过程
+     *
+     * @param treeNode
+     * @return
+     */
+    public boolean isTreeNodeStoreProcedure(ExpandMutableTreeNode treeNode) {
+        Object userObject = treeNode.getUserObject();
+        if (userObject instanceof NameObject) {
+            NameObject nameObject = (NameObject) userObject;
+            TableDataWrapper tableDataWrapper = (TableDataWrapper) nameObject.getObject();
+            return tableDataWrapper.getTableData() instanceof StoreProcedure;
+        }
+        return false;
+    }
 }

designer-base/src/main/java/com/fr/design/data/datapane/TableDataTreePane.java

@@ -18,7 +18,6 @@ import com.fr.design.data.datapane.management.search.pane.TableDataSearchRemindP
 import com.fr.design.data.datapane.management.search.pane.TreeSearchToolbarPane;
 import com.fr.design.data.datapane.management.search.searcher.TableDataSearchMode;
 import com.fr.design.data.datapane.management.search.TableDataTreeSearchManager;
-import com.fr.design.data.datapane.management.search.searcher.TreeSearchStatus;
 import com.fr.design.data.tabledata.StoreProcedureWorkerListener;
 import com.fr.design.data.tabledata.tabledatapane.AbstractTableDataPane;
 import com.fr.design.data.tabledata.tabledatapane.DBTableDataPane;
@@ -629,10 +628,10 @@ public class TableDataTreePane extends BasicTableDataTreePane {
             return;
         }
         // 获取选中的数据集数量
-        int selectioncount = getDataTree().getSelectedDsCounts();
+        int selectioncount = getDataTree().getSelectedTableDataCounts();
         if (op.getDataMode() == SERVER_TABLE_DATA) {
             // 服务器数据集下，选中数据集数量为1时，可以预览
-            if (selectioncount == 1) {
+            if (selectioncount == 1 && !getDataTree().hasSelectedIndependentColumns()) {
                 previewTableDataAction.setEnabled(true);
             }
             // 其它保持false状态
@@ -640,12 +639,12 @@ public class TableDataTreePane extends BasicTableDataTreePane {
         }
         // 模板数据集时，粘贴可用
         pasteAction.setEnabled(true);
-        if (selectioncount == 0) {
+        if (selectioncount == 0 || getDataTree().hasSelectedIndependentColumns()) {
-            // 其它保持false状态
+            // 未选中数据集，或存在单独选中的数据列时，其它保持false状态
             return;
         }
         if (selectioncount == 1) {
-            // 选中单个数据集时，才可以编译、预览
+            // 仅选中单个数据集时，才可以编译、预览
             editAction.setEnabled(true);
             previewTableDataAction.setEnabled(true);
         }
@@ -1013,7 +1012,7 @@ public class TableDataTreePane extends BasicTableDataTreePane {
 
         @Override
         public void actionPerformed(ActionEvent e) {
-            NameObject[] selectedNameObjects = tableDataTree.getSelectedNameObjects();
+            NameObject[] selectedNameObjects = tableDataTree.getSelectedTableDataNodes();
             if (selectedNameObjects == null || selectedNameObjects.length == 0) {
                 FineLoggerFactory.getLogger().error("Table Data to remove is null or not selected");
                 return;
@@ -1077,7 +1076,7 @@ public class TableDataTreePane extends BasicTableDataTreePane {
 
         @Override
         public void actionPerformed(ActionEvent e) {
-            NameObject[] selectedNameObjects = tableDataTree.getSelectedNameObjects();
+            NameObject[] selectedNameObjects = tableDataTree.getSelectedTableDataNodes();
             Map<String, AbstractTableDataWrapper> dataWrapperMap = TableDataTreeClipboard.getInstance().transferNameObjectArray2Map(selectedNameObjects);
             TableDataTreeClipboard.getInstance().addToClip(dataWrapperMap);
         }

designer-base/src/main/java/com/fr/design/data/datapane/management/search/TableDataTreeSearchManager.java

@@ -222,64 +222,21 @@ public class TableDataTreeSearchManager {
      * 节点是否应该添加到搜索结果树的根节点中
      * 只针对数据集节点
      *
-     * @param treeNode 数据集节点
+     * @param treeNodeName 数据集节点名称
      * @return
      */
-    public boolean nodeMatches(ExpandMutableTreeNode treeNode) {
+    public boolean nodeNameMatches(String treeNodeName) {
-        String nodeName = treeNode.getUserObject().toString();
+        return treeSearcher.nodeMatches(treeNodeName);
-        return treeSearcher.nodeMatches(nodeName);
     }
 
     /**
      * 节点是否应该展开
      *
-     * @param treeNode
+     * @param treeNodeName 节点名称
      * @return
      */
-    public boolean nodeCanExpand(ExpandMutableTreeNode treeNode) {
+    public boolean nodeCanExpand(String treeNodeName) {
-        String dsName = treeNode.getUserObject().toString();
+        return treeSearcher.nodeCanExpand(treeNodeName);
-        return treeSearcher.nodeCanExpand(dsName);
-    }
-
-    /**
-     * 处理节点的展开，如果此节点是存储过程，还会处理其子表节点的展开
-     * 只针对数据集节点
-     *
-     * @param treeNode
-     * @return
-     */
-    public ExpandMutableTreeNode dealWithNodeExpand(ExpandMutableTreeNode treeNode) {
-        String tableDataName = treeNode.getUserObject().toString();
-        // 主要还是处理存储过程
-        if (isTreeNodeStoreProcedure(treeNode)) {
-            int childCount = treeNode.getChildCount();
-            for (int i = 0; i < childCount; i++) {
-                ExpandMutableTreeNode child = (ExpandMutableTreeNode) treeNode.getChildAt(i);
-                if (treeSearcher.nodeCanExpand(tableDataName + "_" + child.getUserObject().toString())) {
-                    child.setExpanded(true);
-                }
-            }
-        }
-        if (nodeCanExpand(treeNode)) {
-            treeNode.setExpanded(true);
-        }
-        return treeNode;
-    }
-
-    /**
-     * 判断此节点是否为存储过程
-     *
-     * @param treeNode
-     * @return
-     */
-    public boolean isTreeNodeStoreProcedure(ExpandMutableTreeNode treeNode) {
-        Object userObject = treeNode.getUserObject();
-        if (userObject instanceof NameObject) {
-            NameObject nameObject = (NameObject) userObject;
-            TableDataWrapper tableDataWrapper = (TableDataWrapper) nameObject.getObject();
-            return tableDataWrapper.getTableData() instanceof StoreProcedure;
-        }
-        return false;
     }
 
     public boolean isInSearchMode() {

designer-base/src/main/java/com/fr/design/data/datapane/management/search/control/common/TableDataSearchTask.java

@@ -40,18 +40,16 @@ public class TableDataSearchTask implements TreeSearchTask {
     public void run() {
         TreeSearchResult result;
         try {
-            if (TableDataTreeSearchManager.getInstance().getTreeSearchStatus() != TreeSearchStatus.SEARCHING) {
-                return;
-            }
             if (isTableDataStoreProcedure(tableDataWrapper)) {
-                dealWithStoreProcedureTableDataWrapper((StoreProcedureDataWrapper) tableDataWrapper);
+                result = dealWithStoreProcedureTableDataWrapper((StoreProcedureDataWrapper) tableDataWrapper);
             } else {
-                dealWithCommonTableDataWrapper(tableDataWrapper);
+                result = dealWithCommonTableDataWrapper(tableDataWrapper);
             }
         } catch (Throwable e) {
             FineLoggerFactory.getLogger().error(e, e.getMessage());
-            dealWithErrorTableDataWrapper(tableDataWrapper);
+            result = dealWithErrorTableDataWrapper(tableDataWrapper);
         }
+        callback.done(result);
     }
 
     /**
@@ -59,8 +57,8 @@ public class TableDataSearchTask implements TreeSearchTask {
      *
      * @param tableDataWrapper
      */
-    private void dealWithErrorTableDataWrapper(TableDataWrapper tableDataWrapper) {
+    private TreeSearchResult dealWithErrorTableDataWrapper(TableDataWrapper tableDataWrapper) {
-        callback.done(new TableDataSearchResult.Builder().buildSuccess(false).build());
+        return new TableDataSearchResult.Builder().buildSuccess(false).build();
     }
 
     /**
@@ -68,18 +66,17 @@ public class TableDataSearchTask implements TreeSearchTask {
      *
      * @param tableDataWrapper
      */
-    private void dealWithCommonTableDataWrapper(TableDataWrapper tableDataWrapper) {
+    private TreeSearchResult dealWithCommonTableDataWrapper(TableDataWrapper tableDataWrapper) {
         String tableDataName = tableDataWrapper.getTableDataName();
         boolean isTableDataNameMatch = isMatchSearch(tableDataName, searchText);
         List<String> columnNameList = tableDataWrapper.calculateColumnNameList();
         boolean isColumnMatch = columnNameList.stream().anyMatch(columnName -> isMatchSearch(columnName, searchText));
-        TableDataSearchResult result = new TableDataSearchResult.Builder()
+        return new TableDataSearchResult.Builder()
                 .buildSuccess(true)
                 .buildAddToMatch(isTableDataNameMatch || isColumnMatch ? Arrays.asList(tableDataName) : new ArrayList<>())
                 .buildAddToExpand(isColumnMatch ? Arrays.asList(tableDataName) : new ArrayList<>())
                 .buildAddToCalculated(Arrays.asList(tableDataName))
                 .build();
-        callback.done(result);
     }
 
     /**
@@ -87,7 +84,7 @@ public class TableDataSearchTask implements TreeSearchTask {
      *
      * @param procedureDataWrapper
      */
-    private void dealWithStoreProcedureTableDataWrapper(StoreProcedureDataWrapper procedureDataWrapper) {
+    private TreeSearchResult dealWithStoreProcedureTableDataWrapper(StoreProcedureDataWrapper procedureDataWrapper) {
         // 存储过程数据集名称，例如 Proc1_Table1
         String tableDataName = procedureDataWrapper.getTableDataName();
         // 存储过程名称，例如 Proc1
@@ -116,13 +113,13 @@ public class TableDataSearchTask implements TreeSearchTask {
             addToExpand.add(tableDataName);
         }
         addToCalculated.add(tableDataName);
-        TableDataSearchResult result = new TableDataSearchResult.Builder()
+        return new TableDataSearchResult.Builder()
                 .buildSuccess(true)
                 .buildAddToMatch(new ArrayList<>(addToMatch))
                 .buildAddToExpand(new ArrayList<>(addToExpand))
                 .buildAddToCalculated(new ArrayList<>(addToCalculated))
                 .build();
-        callback.done(result);
+
     }
 
     /**

designer-base/src/main/java/com/fr/design/data/datapane/management/search/control/pre/TableDataPreSearchTask.java

@@ -29,9 +29,6 @@ public class TableDataPreSearchTask implements TreeSearchTask {
     public void run() {
         TreeSearchResult result;
         try {
-            if (TableDataTreeSearchManager.getInstance().getTreeSearchStatus() != TreeSearchStatus.SEARCH_NOT_BEGIN) {
-                return;
-            }
             tableDataWrapper.calculateColumnNameList();
             result = new TableDataSearchResult.Builder()
                     .buildSuccess(true)