Examples with TreeNode org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode used on opensource projects

Example 71 with TreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode in project tdi-studio-se by Talend.

the class InsertNewColumnCommand method execute.

@Override
public void execute() {
    if (rq == null || objects.getToTransfer() == null || targetEditPart == null || dropType == null) {
        return;
    }
    Object targetModel = targetEditPart.getModel();
    for (Object obj : objects.getToTransfer()) {
        AbstractNode createdNode = rq.getNewObject();
        // INPUT => OUTPUT INSERT
        if (objects.getType() == TransferdType.INPUT) {
            TreeNodeEditPart part = (TreeNodeEditPart) obj;
            TreeNode sourceNode = (TreeNode) part.getModel();
            String expression = XmlMapUtil.convertToExpression(sourceNode.getXpath());
            switch(dropType) {
                case DROP_INSERT_OUTPUT:
                    int index = -1;
                    OutputXmlTree outputTree = null;
                    if (targetModel instanceof OutputTreeNode) {
                        OutputTreeNode targetNode = (OutputTreeNode) targetModel;
                        if (targetNode.eContainer() instanceof OutputXmlTree) {
                            outputTree = (OutputXmlTree) targetNode.eContainer();
                            index = outputTree.getNodes().indexOf(targetNode);
                        }
                    } else if (targetModel instanceof OutputXmlTree) {
                        outputTree = (OutputXmlTree) targetModel;
                    }
                    if (outputTree != null) {
                        boolean fillNode = fillTreeNode(outputTree.getNodes(), sourceNode, outputTree.getName(), expression, (OutputTreeNode) createdNode);
                        if (!fillNode) {
                            return;
                        }
                        if (index != -1) {
                            outputTree.getNodes().add(index, (OutputTreeNode) createdNode);
                        } else {
                            outputTree.getNodes().add((OutputTreeNode) createdNode);
                        }
                        createConnection(sourceNode, createdNode);
                        AbstractInOutTree abstractTree = XmlMapUtil.getAbstractInOutTree(sourceNode);
                        createOutputMetadataColumn(abstractTree.getName(), outputTree.getName(), sourceNode, createdNode.getName(), index);
                    }
                    break;
                case DROP_INSERT_VAR:
                    VarNode targetVar = (VarNode) targetModel;
                    VarNode varNode = (VarNode) createdNode;
                    if (targetVar.eContainer() instanceof VarTable) {
                        VarTable varTable = (VarTable) targetVar.eContainer();
                        String validSourceName = validSourceNodeName(varTable.getNodes(), sourceNode);
                        String name = getUniqueTableEntry(varTable.getNodes(), validSourceName);
                        varNode.setName(name);
                        varNode.setType(sourceNode.getType());
                        varNode.setExpression(expression);
                        varTable.getNodes().add(varTable.getNodes().indexOf(targetVar), varNode);
                        createConnection(sourceNode, createdNode);
                    }
                    break;
                case DROP_INSERT_INPUT:
                    if (targetModel instanceof InputXmlTree) {
                        InputXmlTree inputTree = (InputXmlTree) targetModel;
                        boolean fillNode = fillTreeNode(inputTree.getNodes(), sourceNode, inputTree.getName(), expression, (TreeNode) createdNode);
                        if (!fillNode) {
                            return;
                        }
                        inputTree.getNodes().add((TreeNode) createdNode);
                        createLookupConnection(sourceNode, (TreeNode) createdNode);
                        AbstractInOutTree abstractTree = XmlMapUtil.getAbstractInOutTree(sourceNode);
                        createInputMetadataColumn(abstractTree.getName(), inputTree.getName(), sourceNode, createdNode.getName(), -1);
                    }
                default:
                    break;
            }
        } else // VAR => OUTPUT INSERT
        if (objects.getType() == TransferdType.VAR) {
            VarNodeEditPart part = (VarNodeEditPart) obj;
            VarNode sourceNode = (VarNode) part.getModel();
            //$NON-NLS-1$
            String tableName = "Var";
            if (sourceNode.eContainer() instanceof VarTable) {
                tableName = ((VarTable) sourceNode.eContainer()).getName();
            }
            //$NON-NLS-1$
            String expression = tableName + "." + sourceNode.getName();
            if (dropType == DropType.DROP_INSERT_OUTPUT) {
                int index = -1;
                OutputXmlTree outputTree = null;
                if (targetModel instanceof OutputTreeNode) {
                    OutputTreeNode targetNode = (OutputTreeNode) targetModel;
                    if (targetNode.eContainer() instanceof OutputXmlTree) {
                        outputTree = (OutputXmlTree) targetNode.eContainer();
                        index = outputTree.getNodes().indexOf(targetNode);
                    }
                } else if (targetModel instanceof OutputXmlTree) {
                    outputTree = (OutputXmlTree) targetModel;
                }
                if (outputTree != null) {
                    OutputTreeNode outputNode = (OutputTreeNode) createdNode;
                    String name = getUniqueTableEntry(outputTree.getNodes(), sourceNode.getName());
                    outputNode.setName(name);
                    outputNode.setType(sourceNode.getType());
                    outputNode.setExpression(expression);
                    outputNode.setXpath(XmlMapUtil.getXPath(outputTree.getName(), outputNode.getName(), outputNode.getNodeType()));
                    if (index != -1) {
                        outputTree.getNodes().add(index, (OutputTreeNode) createdNode);
                    } else {
                        outputTree.getNodes().add((OutputTreeNode) createdNode);
                    }
                    createConnection(sourceNode, createdNode);
                    createOutputMetadataColumn(null, outputTree.getName(), sourceNode, createdNode.getName(), index);
                // List<IMetadataTable> metadataTargets = manager.getMapperComponent().getMetadataList();
                // IMetadataTable metadataTarget = null;
                // if (metadataTargets != null) {
                // for (IMetadataTable target : metadataTargets) {
                // if (target.getTableName().equals(outputTree.getName())) {
                // metadataTarget = target;
                // }
                // }
                // if (metadataTarget != null) {
                // IMetadataColumn createNewColumn = new MetadataColumn();
                // createNewColumn.setLabel(outputNode.getName());
                // createNewColumn.setTalendType(outputNode.getType());
                // createNewColumn.setNullable(true);
                // metadataTarget.getListColumns().add(createNewColumn);
                // }
                // }
                }
            }
        }
    }
    switch(dropType) {
        case DROP_INSERT_OUTPUT:
            manager.getMapperUI().getTabFolderEditors().getOutputMetaEditorView().getTableViewerCreator().refresh();
        case DROP_INSERT_INPUT:
            manager.getMapperUI().getTabFolderEditors().getOutputMetaEditorView().getTableViewerCreator().refresh();
    }
}

Example 72 with TreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode in project tdi-studio-se by Talend.

the class InsertNewColumnCommand method creatMeatadataColumn.

private void creatMeatadataColumn(IMetadataColumn columnSource, String targetNodeName, AbstractNode sourceNode, IMetadataTable metadataTarget, int index) {
    IMetadataColumn createNewColumn = null;
    if (columnSource != null) {
        // dnd schema column
        createNewColumn = new MetadataColumn(columnSource);
        createNewColumn.setLabel(targetNodeName);
    } else {
        // dnd doc child
        createNewColumn = new MetadataColumn();
        createNewColumn.setLabel(targetNodeName);
        createNewColumn.setType(sourceNode.getType());
        createNewColumn.setTalendType(sourceNode.getType());
        if (sourceNode instanceof TreeNode) {
            createNewColumn.setKey(((TreeNode) sourceNode).isKey());
            createNewColumn.setNullable(((TreeNode) sourceNode).isNullable());
            createNewColumn.setPattern(((TreeNode) sourceNode).getPattern());
        }
    }
    if (index != -1) {
        metadataTarget.getListColumns().add(index, createNewColumn);
    } else {
        metadataTarget.getListColumns().add(createNewColumn);
    }
}

Example 73 with TreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode in project tdi-studio-se by Talend.

the class XmlMapService method checkXMLMapDifferents.

/*
     * (non-Javadoc)
     * 
     * @see org.talend.core.service.IXmlMapService#checkXMLMapDifferents(org.talend.core.model.process.INode,
     * org.talend.core.model.process.INode)
     */
@Override
public boolean checkXMLMapDifferents(INode testNode, INode originalNode) {
    AbstractExternalData oriExternalData = originalNode.getExternalNode().getExternalEmfData();
    AbstractExternalData testExternalData = testNode.getExternalNode().getExternalEmfData();
    if (oriExternalData == null && testExternalData == null) {
        return false;
    }
    if (oriExternalData == null || testExternalData == null) {
        return true;
    }
    if (!(oriExternalData instanceof XmlMapData) || !(testExternalData instanceof XmlMapData)) {
        return false;
    }
    Map<String, String> inputConnNameMap = getInputConnectionNameMap(testNode);
    XmlMapData oriXmlData = (XmlMapData) oriExternalData;
    XmlMapData testXmlData = (XmlMapData) testExternalData;
    EList<InputXmlTree> oriInputs = oriXmlData.getInputTrees();
    EList<OutputXmlTree> oriOutputs = oriXmlData.getOutputTrees();
    EList<VarTable> oriVars = oriXmlData.getVarTables();
    EList<InputXmlTree> testInputs = testXmlData.getInputTrees();
    EList<OutputXmlTree> testOutputs = testXmlData.getOutputTrees();
    EList<VarTable> testVars = testXmlData.getVarTables();
    if (oriInputs.size() != testInputs.size()) {
        return true;
    }
    if (oriOutputs.size() != testOutputs.size()) {
        return true;
    }
    if (oriVars.size() != testVars.size()) {
        return true;
    }
    for (InputXmlTree oriInput : oriInputs) {
        String oriName = oriInput.getName();
        InputXmlTree testInput = null;
        for (InputXmlTree input : testInputs) {
            if (input.getName().equals(oriName)) {
                testInput = input;
                break;
            }
        }
        if (testInput == null) {
            testInput = getInputXmlTree(testNode, testInputs, oriName);
        }
        if (testInput == null) {
            return true;
        }
        if (oriInput.isActivateExpressionFilter() != testInput.isActivateExpressionFilter()) {
            return true;
        }
        if (oriInput.getExpressionFilter() != testInput.getExpressionFilter()) {
            return true;
        }
        if (oriInput.isMinimized() != testInput.isMinimized()) {
            return true;
        }
        if (oriInput.isActivateCondensedTool() != testInput.isActivateCondensedTool()) {
            return true;
        }
        EList<TreeNode> oriEntrys = oriInput.getNodes();
        EList<TreeNode> testEntrys = testInput.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (TreeNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (TreeNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (checkExpression(oriEntry.getExpression(), testEntry.getExpression(), inputConnNameMap)) {
                        return true;
                    }
                    break;
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    for (OutputXmlTree oriOutput : oriOutputs) {
        String oriName = oriOutput.getName();
        OutputXmlTree testOutput = null;
        for (OutputXmlTree output : testOutputs) {
            if (output.getName().equals(oriName)) {
                testOutput = output;
                break;
            }
        }
        if (testOutput == null) {
            testOutput = getOutputXmlTree(testNode, testOutputs, oriName);
        }
        if (testOutput == null) {
            return true;
        }
        if (oriOutput.isActivateExpressionFilter() != testOutput.isActivateExpressionFilter()) {
            return true;
        }
        if (oriOutput.getExpressionFilter() != testOutput.getExpressionFilter()) {
            return true;
        }
        if (oriOutput.isMinimized() != testOutput.isMinimized()) {
            return true;
        }
        if (oriOutput.isActivateCondensedTool() != testOutput.isActivateCondensedTool()) {
            return true;
        }
        EList<OutputTreeNode> oriEntrys = oriOutput.getNodes();
        EList<OutputTreeNode> testEntrys = testOutput.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (OutputTreeNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (OutputTreeNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (found) {
                        if (checkChildOutputTreeNode(oriEntry, testEntry, inputConnNameMap)) {
                            return true;
                        }
                    }
                    break;
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    for (VarTable oriVar : oriVars) {
        String oriName = oriVar.getName();
        VarTable testVar = null;
        for (VarTable var : testVars) {
            if (var.getName().equals(oriName)) {
                testVar = var;
                break;
            }
        }
        if (testVar == null) {
            return true;
        }
        if (oriVar.isMinimized() != testVar.isMinimized()) {
            return true;
        }
        EList<VarNode> oriEntrys = oriVar.getNodes();
        EList<VarNode> testEntrys = testVar.getNodes();
        if (oriEntrys.size() != testEntrys.size()) {
            return true;
        }
        for (VarNode oriEntry : oriEntrys) {
            String oriEntryName = oriEntry.getName();
            boolean found = false;
            for (VarNode testEntry : testEntrys) {
                if (oriEntryName.equals(testEntry.getName())) {
                    found = true;
                    if (checkExpression(oriEntry.getExpression(), testEntry.getExpression(), inputConnNameMap)) {
                        return true;
                    }
                }
            }
            if (!found) {
                return true;
            }
        }
    }
    return false;
}

Example 74 with TreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode in project tdi-studio-se by Talend.

the class XmlMapService method externalEmfDataClone.

/*
     * (non-Javadoc)
     * 
     * @see
     * org.talend.core.service.IXmlMapService#externalEmfDataClone(org.talend.designer.core.model.utils.emf.talendfile
     * .AbstractExternalData)
     */
@Override
public AbstractExternalData externalEmfDataClone(AbstractExternalData externalEmfData) {
    if (!(externalEmfData instanceof XmlMapData)) {
        return externalEmfData;
    }
    Map<EObject, EObject> nodeMaps = new HashMap<EObject, EObject>();
    XmlMapData newXmlMapData = XmlmapFactory.eINSTANCE.createXmlMapData();
    XmlMapData xmlMapData = (XmlMapData) externalEmfData;
    EList<InputXmlTree> oriInputs = xmlMapData.getInputTrees();
    EList<OutputXmlTree> oriOutputs = xmlMapData.getOutputTrees();
    EList<VarTable> oriVars = xmlMapData.getVarTables();
    EList<IConnection> oriConns = xmlMapData.getConnections();
    for (IConnection oriConn : oriConns) {
        if (oriConn instanceof INodeConnection) {
            AbstractNode sourceNode = ((INodeConnection) oriConn).getSource();
            AbstractNode targetNode = ((INodeConnection) oriConn).getTarget();
            EObject source = null;
            if (nodeMaps.get(sourceNode) != null) {
                source = nodeMaps.get(sourceNode);
            } else {
                source = cloneTreeNode(sourceNode);
                nodeMaps.put(sourceNode, source);
            }
            EObject target = null;
            if (nodeMaps.get(targetNode) != null) {
                target = nodeMaps.get(targetNode);
            } else {
                target = cloneTreeNode(targetNode);
                nodeMaps.put(targetNode, target);
            }
            if (oriConn instanceof Connection) {
                new XmlMapConnectionBuilder().createConnection((AbstractNode) source, (AbstractNode) target, newXmlMapData);
            } else if (oriConn instanceof LookupConnection) {
                new XmlMapConnectionBuilder().createLookupConnection((TreeNode) source, (TreeNode) target, newXmlMapData);
            }
        } else if (oriConn instanceof FilterConnection) {
            AbstractNode sourceNode = ((FilterConnection) oriConn).getSource();
            AbstractInOutTree targetNode = ((FilterConnection) oriConn).getTarget();
            EObject source = null;
            if (nodeMaps.get(sourceNode) != null) {
                source = nodeMaps.get(sourceNode);
            } else {
                source = cloneTreeNode(sourceNode);
                nodeMaps.put(sourceNode, source);
            }
            EObject target = null;
            if (nodeMaps.get(targetNode) != null) {
                target = nodeMaps.get(targetNode);
            } else {
                target = cloneTreeNode(targetNode);
                nodeMaps.put(targetNode, target);
            }
            new XmlMapConnectionBuilder().createFilterConnection((AbstractNode) source, (AbstractInOutTree) target, newXmlMapData);
        }
    }
    for (InputXmlTree inputXml : oriInputs) {
        InputXmlTree newInputXml = null;
        if (nodeMaps.get(inputXml) == null) {
            newInputXml = (InputXmlTree) cloneTreeNode(inputXml);
        } else {
            newInputXml = (InputXmlTree) nodeMaps.get(inputXml);
        }
        if (inputXml.getNodes() != null) {
            for (TreeNode treeNode : inputXml.getNodes()) {
                EObject obj = nodeMaps.get(treeNode);
                if ((obj != null) && !newInputXml.getNodes().contains(obj)) {
                    newInputXml.getNodes().add((TreeNode) obj);
                }
            }
        }
        if (!newXmlMapData.getInputTrees().contains(newInputXml)) {
            newXmlMapData.getInputTrees().add(newInputXml);
        }
        nodeMaps.put(inputXml, newInputXml);
    }
    for (OutputXmlTree outputXml : oriOutputs) {
        OutputXmlTree newOutputXml = null;
        if (nodeMaps.get(outputXml) == null) {
            newOutputXml = (OutputXmlTree) cloneTreeNode(outputXml);
        } else {
            newOutputXml = (OutputXmlTree) nodeMaps.get(outputXml);
        }
        if (outputXml.getNodes() != null) {
            for (OutputTreeNode treeNode : outputXml.getNodes()) {
                EObject obj = nodeMaps.get(treeNode);
                if ((obj != null) && !newOutputXml.getNodes().contains(obj)) {
                    newOutputXml.getNodes().add((OutputTreeNode) obj);
                }
            }
        }
        // }
        if (!newXmlMapData.getOutputTrees().contains(newOutputXml)) {
            newXmlMapData.getOutputTrees().add(newOutputXml);
        }
        nodeMaps.put(outputXml, newOutputXml);
    }
    for (VarTable varXml : oriVars) {
        VarTable newVarXml = null;
        if (nodeMaps.get(varXml) == null) {
            newVarXml = XmlmapFactory.eINSTANCE.createVarTable();
            newVarXml.setMinimized(varXml.isMinimized());
            newVarXml.setName(varXml.getName());
            if (varXml.getNodes() != null) {
                for (VarNode treeNode : varXml.getNodes()) {
                    EObject obj = nodeMaps.get(treeNode);
                    if (obj != null) {
                        newVarXml.getNodes().add((VarNode) obj);
                    }
                }
            }
            if (!newXmlMapData.getVarTables().contains(newVarXml)) {
                newXmlMapData.getVarTables().add(newVarXml);
            }
            nodeMaps.put(varXml, newVarXml);
        }
    }
    return newXmlMapData;
}

Example 75 with TreeNode

use of org.talend.designer.xmlmap.model.emf.xmlmap.TreeNode in project tdi-studio-se by Talend.

the class XmlMapService method checkChildOutputTreeNode.

private boolean checkChildOutputTreeNode(TreeNode oriEntry, TreeNode testEntry, Map<String, String> inputConnNameMap) {
    if (checkExpression(oriEntry.getExpression(), testEntry.getExpression(), inputConnNameMap)) {
        return true;
    }
    EList<TreeNode> oriList = oriEntry.getChildren();
    EList<TreeNode> testList = testEntry.getChildren();
    if (oriList == null && testList == null) {
        return false;
    }
    if (oriList == null || testList == null) {
        return true;
    }
    if (oriList.size() != testList.size()) {
        return true;
    }
    for (TreeNode oriNode : oriList) {
        boolean found = false;
        for (TreeNode testNode : testList) {
            if (oriNode.getName().equals(testNode.getName())) {
                found = true;
                if (found) {
                    if (checkChildOutputTreeNode(oriNode, testNode, inputConnNameMap)) {
                        return true;
                    }
                }
                break;
            }
        }
        if (!found) {
            return true;
        }
    }
    return false;
}