| /***************************************************************** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| ****************************************************************/ |
| |
| package org.apache.cayenne.modeler.editor.dbimport; |
| |
| import org.apache.cayenne.dbsync.reverse.dbimport.Catalog; |
| import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeColumn; |
| import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeProcedure; |
| import org.apache.cayenne.dbsync.reverse.dbimport.ExcludeTable; |
| import org.apache.cayenne.dbsync.reverse.dbimport.IncludeColumn; |
| import org.apache.cayenne.dbsync.reverse.dbimport.IncludeProcedure; |
| import org.apache.cayenne.dbsync.reverse.dbimport.IncludeTable; |
| import org.apache.cayenne.dbsync.reverse.dbimport.ReverseEngineering; |
| import org.apache.cayenne.dbsync.reverse.dbimport.Schema; |
| import org.apache.cayenne.modeler.dialog.db.load.DbImportTreeNode; |
| |
| import javax.swing.tree.TreePath; |
| import java.awt.Color; |
| |
| /** |
| * @since 4.1 |
| */ |
| class DbImportNodeHandler { |
| |
| private static final Color ACCEPT_COLOR = new Color(60,179,113); |
| private static final Color EXCLUDE_COLOR = new Color(178, 0, 0); |
| static final Color NON_INCLUDE_COLOR = Color.LIGHT_GRAY; |
| static final Color LABEL_COLOR = Color.BLACK; |
| private static final int EXCLUDE_TABLE_RATE = -10000; |
| |
| private boolean existFirstLevelIncludeTable; |
| private boolean existCatalogsOrSchemas; |
| private boolean hasEntitiesInEmptyContainer; |
| private DbImportTreeNode dbSchemaNode; |
| private DbImportTree reverseEngineeringTree; |
| |
| private boolean namesIsEqual(DbImportTreeNode reverseEngineeringNode) { |
| if (isContainer(reverseEngineeringNode)) { |
| return dbSchemaNode.getSimpleNodeName().equals(reverseEngineeringNode.getSimpleNodeName()); |
| } else { |
| return (dbSchemaNode.getSimpleNodeName().toLowerCase().matches(reverseEngineeringNode.getSimpleNodeName().toLowerCase())); |
| } |
| } |
| |
| boolean isContainer(DbImportTreeNode node) { |
| return (node.getUserObject().getClass() == Schema.class) || (node.getUserObject().getClass() == Catalog.class); |
| } |
| |
| private boolean isEmptyContainer(DbImportTreeNode rootNode) { |
| return ((getChildIncludeTableCount(rootNode) == 0) && (!existFirstLevelIncludeTable)); |
| } |
| |
| boolean isParentIncluded() { |
| return ((dbSchemaNode.getParent() != null) && (((DbImportTreeNode) dbSchemaNode.getParent()).isColorized())); |
| } |
| |
| // Compare node with current rendered node |
| public boolean nodesIsEqual(DbImportTreeNode reverseEngineeringNode) { |
| TreePath[] paths = reverseEngineeringTree.getSelectionPaths(); |
| for (TreePath path : paths != null ? paths : new TreePath[0]) { |
| DbImportTreeNode node = (DbImportTreeNode) path.getLastPathComponent(); |
| if ((nodesClassesComparation(node.getUserObject().getClass(), dbSchemaNode.getUserObject().getClass())) |
| && namesIsEqual(node) |
| && (dbSchemaNode.getLevel() >= node.getLevel()) |
| && (dbSchemaNode.parentsIsEqual(node))) { |
| return true; |
| } |
| } |
| if ((nodesClassesComparation(reverseEngineeringNode.getUserObject().getClass(), dbSchemaNode.getUserObject().getClass())) |
| && namesIsEqual(reverseEngineeringNode) |
| && (dbSchemaNode.getLevel() >= reverseEngineeringNode.getLevel()) |
| && (dbSchemaNode.parentsIsEqual(reverseEngineeringNode))) { |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean checkTreesLevels(DbImportTree dbTree) { |
| if (dbTree.getRootNode().getChildCount() == 0) { |
| return false; |
| } |
| DbImportTreeNode dbNode = (DbImportTreeNode) dbTree.getRootNode().getChildAt(0); |
| int childCount = reverseEngineeringTree.getRootNode().getChildCount(); |
| for (int i = 0; i < childCount; i++) { |
| if (((DbImportTreeNode) reverseEngineeringTree.getRootNode().getChildAt(i)). |
| getUserObject().getClass() == Catalog.class) { |
| if (dbNode.getUserObject().getClass() == Catalog.class || dbNode.getUserObject().getClass() == IncludeTable.class) { |
| return true; |
| } else { |
| return false; |
| } |
| } |
| } |
| return true; |
| } |
| |
| // Compare reverseEngineeringNode with node.getParent() |
| private boolean compareWithParent(DbImportTreeNode reverseEngineeringNode) { |
| if ((reverseEngineeringNode == null) || (dbSchemaNode.getParent() == null)) { |
| return false; |
| } |
| if ((((DbImportTreeNode)dbSchemaNode.getParent()).getUserObject().getClass() == reverseEngineeringNode.getUserObject().getClass()) |
| && (((DbImportTreeNode)dbSchemaNode.getParent()).getSimpleNodeName().equals(reverseEngineeringNode.getSimpleNodeName())) |
| && (((DbImportTreeNode)dbSchemaNode.getParent()).getLevel() >= reverseEngineeringNode.getLevel()) |
| && (((DbImportTreeNode)dbSchemaNode.getParent())).parentsIsEqual(reverseEngineeringNode)) { |
| return true; |
| } |
| return false; |
| } |
| |
| // Get child IncludeTable's count in node, if exists |
| private int getChildIncludeTableCount(DbImportTreeNode parentNode) { |
| if (parentNode.isIncludeTable()) { |
| return 1; |
| } |
| int childCount = parentNode.getChildCount(); |
| int result = 0; |
| for (int i = 0; i < childCount; i++) { |
| DbImportTreeNode tmpNode = (DbImportTreeNode) parentNode.getChildAt(i); |
| if (tmpNode.isIncludeTable()) { |
| result++; |
| } |
| } |
| return result; |
| } |
| |
| // Find Exclude-node in configuration |
| private boolean foundExclude(DbImportTreeNode rootNode) { |
| int childCount = rootNode.getChildCount(); |
| for (int i = 0; i < childCount; i++) { |
| DbImportTreeNode tmpNode = (DbImportTreeNode) rootNode.getChildAt(i); |
| if (tmpNode.getChildCount() > 0) { |
| if (tmpNode.isExcludeTable() || tmpNode.isExcludeProcedure()) { |
| return true; |
| } |
| } |
| if (dbSchemaNode.getParent() != null) { |
| if (nodesIsEqual(tmpNode)) { |
| if (tmpNode.isExcludeTable() || tmpNode.isExcludeProcedure()) { |
| return true; |
| } |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /* |
| * Recursively traverse DbImportTree, |
| * Increment result if rendered node exists in configuration tree, |
| * Subtract EXCLUDE_TABLE_RATE from result, if found Exclude-node for rendered node, |
| * Return 0, if rendered node not found. |
| */ |
| int traverseTree(DbImportTreeNode rootNode) { |
| hasEntitiesInEmptyContainer = false; |
| int traverseResult = 0; |
| int childCount = rootNode.getChildCount(); |
| boolean hasProcedures = false; |
| |
| // Case for empty reverse engineering, which has a include/exclude tables/procedures |
| if ((childCount == 0) && (nodesIsEqual(rootNode))) { |
| traverseResult++; |
| } |
| |
| if (nodesIsEqual(rootNode)) { |
| traverseResult++; |
| } |
| |
| ReverseEngineering reverseEngineering = reverseEngineeringTree.getReverseEngineering(); |
| if ((reverseEngineering.getCatalogs().isEmpty()) && (reverseEngineering.getSchemas().isEmpty()) |
| && (reverseEngineering.getIncludeTables().isEmpty()) |
| && (!dbSchemaNode.isIncludeProcedure())) { |
| traverseResult++; |
| } |
| |
| if (nodesIsEqual(rootNode) && isEmptyContainer(rootNode)) { |
| hasEntitiesInEmptyContainer = true; |
| if (foundExclude(rootNode)) { |
| return EXCLUDE_TABLE_RATE; |
| } |
| return 1; |
| } |
| |
| if (compareWithParent(rootNode) && (!rootNode.isReverseEngineering()) && |
| isEmptyContainer(rootNode) && (dbSchemaNode.isIncludeTable())) { |
| hasEntitiesInEmptyContainer = true; |
| if (foundExclude(rootNode)) { |
| return EXCLUDE_TABLE_RATE; |
| } |
| return 1; |
| } |
| |
| if (hasEntitiesInEmptyContainer) { |
| for (int i = 0; i < childCount; i++) { |
| DbImportTreeNode tmpNode = (DbImportTreeNode) rootNode.getChildAt(i); |
| if (dbSchemaNode.isIncludeProcedure() && (nodesIsEqual(tmpNode))) { |
| int tmpNodeChildCount = tmpNode.getChildCount(); |
| if (tmpNodeChildCount > 0) { |
| traverseResult += traverseTree((DbImportTreeNode) rootNode.getChildAt(i)); |
| } |
| traverseResult++; |
| hasProcedures = true; |
| } |
| } |
| if ((!rootNode.isExcludeTable()) && (!nodesIsEqual(rootNode)) |
| && (!dbSchemaNode.isIncludeProcedure()) &&(!dbSchemaNode.isIncludeColumn())) { |
| traverseResult++; |
| } else { |
| if ((!hasProcedures) && (!dbSchemaNode.isIncludeProcedure())) { |
| traverseResult += EXCLUDE_TABLE_RATE; |
| } |
| } |
| } |
| |
| for (int i = 0; i < childCount; i++) { |
| DbImportTreeNode tmpNode = (DbImportTreeNode) rootNode.getChildAt(i); |
| if (tmpNode.getChildCount() > 0) { |
| traverseResult += traverseTree(tmpNode); |
| if (tmpNode.isExcludeTable() || tmpNode.isExcludeProcedure()) { |
| traverseResult += EXCLUDE_TABLE_RATE; |
| } |
| } else if (compareWithParent(tmpNode) && !(existFirstLevelIncludeTable)) { |
| if (!dbSchemaNode.isIncludeProcedure()) { |
| traverseResult++; |
| } |
| } |
| if (dbSchemaNode.getParent() != null) { |
| if (nodesIsEqual(tmpNode)) { |
| if (tmpNode.isExcludeTable() || tmpNode.isExcludeProcedure()) { |
| traverseResult += EXCLUDE_TABLE_RATE; |
| } |
| traverseResult++; |
| } |
| } |
| } |
| return traverseResult; |
| } |
| |
| Color getColorByNodeType(DbImportTreeNode node) { |
| if ((reverseEngineeringTree.getSelectionPaths() != null) &&(reverseEngineeringTree.getSelectionPaths().length > 1)) { |
| for (TreePath path : reverseEngineeringTree.getSelectionPaths()) { |
| DbImportTreeNode pathNode = (DbImportTreeNode) path.getLastPathComponent(); |
| if (pathNode.getSimpleNodeName().equals(dbSchemaNode.getSimpleNodeName())) { |
| if (pathNode.isExcludeTable() || pathNode.isExcludeProcedure() || node.isExcludeColumn()) { |
| return EXCLUDE_COLOR; |
| } else { |
| return ACCEPT_COLOR; |
| } |
| } |
| } |
| } |
| if (node.isExcludeTable() || node.isExcludeProcedure() || node.isExcludeColumn()) { |
| return EXCLUDE_COLOR; |
| } else { |
| return ACCEPT_COLOR; |
| } |
| } |
| |
| void findFirstLevelIncludeTable() { |
| DbImportTreeNode root = reverseEngineeringTree.getRootNode(); |
| int childCount = root.getChildCount(); |
| existFirstLevelIncludeTable = false; |
| existCatalogsOrSchemas = false; |
| for (int i = 0; i < childCount; i++) { |
| DbImportTreeNode tmpNode = (DbImportTreeNode) root.getChildAt(i); |
| if (tmpNode.isIncludeTable()) { |
| existFirstLevelIncludeTable = true; |
| } |
| if (isContainer(tmpNode)) { |
| existCatalogsOrSchemas = true; |
| } |
| } |
| } |
| |
| // Check, is DatabaseTree started with IncludeTable or IncludeProcedure |
| boolean isFirstNodeIsPrimitive(DbImportTree tree) { |
| final int firstChildIndex = 0; |
| DbImportTreeNode root = tree.getRootNode(); |
| if (root.getChildCount() == 0) { |
| return false; |
| } |
| DbImportTreeNode firstElement = (DbImportTreeNode) root.getChildAt(firstChildIndex); |
| if (firstElement.isIncludeTable() || firstElement.isIncludeProcedure()) { |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean nodesClassesComparation(Class firstClass, Class secondClass) { |
| if (firstClass.equals(secondClass)) { |
| return true; |
| } |
| if ((firstClass.equals(IncludeTable.class)) && (secondClass.equals(ExcludeTable.class))) { |
| return true; |
| } |
| if ((firstClass.equals(ExcludeTable.class)) && (secondClass.equals(IncludeTable.class))) { |
| return true; |
| } |
| if ((firstClass.equals(IncludeProcedure.class)) && (secondClass.equals(ExcludeProcedure.class))) { |
| return true; |
| } |
| if ((firstClass.equals(ExcludeProcedure.class)) && (secondClass.equals(IncludeProcedure.class))) { |
| return true; |
| } |
| if ((firstClass.equals(ExcludeColumn.class)) && (secondClass.equals(IncludeColumn.class))) { |
| return true; |
| } |
| if ((firstClass.equals(IncludeColumn.class)) && (secondClass.equals(ExcludeColumn.class))) { |
| return true; |
| } |
| return false; |
| } |
| |
| public boolean isExistCatalogsOrSchemas() { |
| return existCatalogsOrSchemas; |
| } |
| |
| public boolean getHasEntitiesInEmptyContainer() { |
| return hasEntitiesInEmptyContainer; |
| } |
| |
| public void setHasEntitiesInEmptyContainer(boolean newFlag) { |
| hasEntitiesInEmptyContainer = newFlag; |
| } |
| |
| public void setDbSchemaNode(DbImportTreeNode dbSchemaNode) { |
| this.dbSchemaNode = dbSchemaNode; |
| } |
| |
| public void setReverseEngineeringTree(DbImportTree reverseEngineeringTree) { |
| this.reverseEngineeringTree = reverseEngineeringTree; |
| } |
| } |
