Examples with MetadataTableEditor org.talend.core.ui.metadata.editor.MetadataTableEditor used on opensource projects

Example 11 with MetadataTableEditor

use of org.talend.core.ui.metadata.editor.MetadataTableEditor in project tdi-studio-se by Talend.

the class MapperManager method selectInputXmlTree.

public void selectInputXmlTree(InputXmlTree inputTree) {
    if (inputTree != selectedInputTree) {
        selectedInputTree = inputTree;
        MetadataTableEditorView inputMetaEditorView = mapperUI.getTabFolderEditors().getInputMetaEditorView();
        List<IODataComponent> inputs = getMapperComponent().getIODataComponents().getInputs();
        IMetadataTable table = null;
        for (int i = 0; i < inputs.size(); i++) {
            IODataComponent ioDataComponent = inputs.get(i);
            if (inputTree.getName() != null && inputTree.getName().equals(ioDataComponent.getConnection().getName())) {
                table = ioDataComponent.getTable();
                break;
            }
        }
        if (table != null) {
            MetadataTableEditor editor = new MetadataTableEditor(table, selectedInputTree.getName());
            editor.setModifiedBeanListenable(inputMetaEditorView.getTableViewerCreator());
            IModifiedBeanListener<IMetadataColumn> columnListener = new IModifiedBeanListener<IMetadataColumn>() {

                @Override
                public void handleEvent(ModifiedBeanEvent<IMetadataColumn> event) {
                    fireCurrentDirectEditApply();
                    if (AbstractMetadataTableEditorView.ID_COLUMN_NAME.equals(event.column.getId())) {
                        if (event.index < selectedInputTree.getNodes().size()) {
                            TreeNode treeNode = selectedInputTree.getNodes().get(event.index);
                            if (treeNode != null) {
                                treeNode.setName((String) event.newValue);
                                processColumnNameChanged(treeNode);
                            }
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_TYPE.equals(event.column.getId())) {
                        if (event.index < selectedInputTree.getNodes().size()) {
                            TreeNode treeNode = selectedInputTree.getNodes().get(event.index);
                            if (treeNode != null) {
                                if (treeNode.getType() != null && treeNode.getType().equals(XmlMapUtil.DOCUMENT)) {
                                    List<TreeNode> oldLoops = new ArrayList<TreeNode>();
                                    if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
                                        oldLoops = XmlMapUtil.getMultiLoopsForXmlTree(selectedInputTree);
                                    }
                                    XmlMapUtil.detachNodeConnections(treeNode, getExternalData(), true);
                                    treeNode.getChildren().clear();
                                    if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
                                        selectedInputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedInputTree));
                                        List<TreeNode> newLoops = XmlMapUtil.getMultiLoopsForXmlTree(selectedInputTree);
                                        oldLoops.removeAll(newLoops);
                                        if (!oldLoops.isEmpty()) {
                                            XmlMapUtil.removeloopInOutputTree(MapperManager.this, oldLoops);
                                        }
                                    }
                                }
                                treeNode.setType((String) event.newValue);
                                if (XmlMapUtil.DOCUMENT.equals(event.newValue)) {
                                    XmlMapUtil.detachNodeConnections(treeNode, getExternalData(), true);
                                    TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                                    createTreeNode.setName("root");
                                    createTreeNode.setType(XmlMapUtil.DEFAULT_DATA_TYPE);
                                    createTreeNode.setNodeType(NodeType.ELEMENT);
                                    createTreeNode.setXpath(XmlMapUtil.getXPath(treeNode.getXpath(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                    createTreeNode.setLoop(true);
                                    createTreeNode.setMain(true);
                                    treeNode.getChildren().add(createTreeNode);
                                }
                                problemsAnalyser.checkProblems(selectedInputTree);
                                mapperUI.updateStatusBar();
                                inputTreeSchemaBeanListModified();
                            }
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_KEY.equals(event.column.getId())) {
                        if (event.index < selectedInputTree.getNodes().size()) {
                            TreeNode treeNode = selectedInputTree.getNodes().get(event.index);
                            treeNode.setKey((Boolean) event.newValue);
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_PATTERN.equals(event.column.getId())) {
                        if (event.index < selectedInputTree.getNodes().size()) {
                            TreeNode treeNode = selectedInputTree.getNodes().get(event.index);
                            treeNode.setPattern((String) event.newValue);
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_NULLABLE.equals(event.column.getId())) {
                        if (event.index < selectedInputTree.getNodes().size()) {
                            TreeNode treeNode = selectedInputTree.getNodes().get(event.index);
                            treeNode.setNullable((Boolean) event.newValue);
                        }
                    }
                }
            };
            editor.addModifiedBeanListener(columnListener);
            editor.addAfterOperationListListener(new IListenableListListener() {

                @Override
                public void handleEvent(ListenableListEvent event) {
                    if (event.type == TYPE.ADDED) {
                        EList<TreeNode> nodes = selectedInputTree.getNodes();
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;
                        if (event.index != null) {
                            int index = event.index;
                            for (IMetadataColumn column : metadataColumns) {
                                TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                                createTreeNode.setName(column.getLabel());
                                createTreeNode.setType(column.getTalendType());
                                createTreeNode.setNullable(column.isNullable());
                                createTreeNode.setPattern(column.getPattern());
                                createTreeNode.setXpath(XmlMapUtil.getXPath(selectedInputTree.getName(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                selectedInputTree.getNodes().add(index, createTreeNode);
                                index = index + 1;
                            }
                        }
                    } else if (event.type == TYPE.REMOVED) {
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
                        List treeNodeToRemove = new ArrayList();
                        for (IMetadataColumn column : metadataColumns) {
                            for (TreeNode node : selectedInputTree.getNodes()) {
                                if (node.getName() != null && node.getName().equals(column.getLabel())) {
                                    XmlMapUtil.detachNodeConnections(node, getExternalData(), true);
                                    treeNodeToRemove.add(node);
                                }
                            }
                        }
                        selectedInputTree.getNodes().removeAll(treeNodeToRemove);
                        if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
                            selectedInputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedInputTree));
                            List<TreeNode> oldLoops = new ArrayList<TreeNode>();
                            XmlMapUtil.getChildLoops(oldLoops, treeNodeToRemove);
                            if (!oldLoops.isEmpty()) {
                                XmlMapUtil.removeloopInOutputTree(MapperManager.this, oldLoops);
                            }
                        }
                        problemsAnalyser.checkProblems(selectedInputTree);
                        mapperUI.updateStatusBar();
                        inputTreeSchemaBeanListModified();
                    } else if (event.type == TYPE.SWAPED) {
                        List<Integer> listIndexTarget = event.indicesTarget;
                        List<Integer> listIndexOrignal = event.indicesOrigin;
                        for (int i = 0; i < listIndexOrignal.size(); i++) {
                            int orignal = listIndexOrignal.get(i);
                            int target = listIndexTarget.get(i);
                            if (orignal < selectedInputTree.getNodes().size()) {
                                TreeNode tempTreeNode = selectedInputTree.getNodes().get(orignal);
                                selectedInputTree.getNodes().remove(orignal);
                                selectedInputTree.getNodes().add(target, tempTreeNode);
                            }
                        }
                    } else if (event.type == TYPE.REPLACED) {
                        // fix for TDI-24071
                        List added = (List) event.addedObjects;
                        List removed = (List) event.removedObjects;
                        boolean needCheckOutput = false;
                        List<TreeNode> oldLoops = new ArrayList<TreeNode>();
                        if (selectedInputTree == mainInputTree && mainInputTree.isMultiLoops()) {
                            needCheckOutput = true;
                        }
                        List<IMetadataColumn> removedColumn = new ArrayList<IMetadataColumn>();
                        List<IMetadataColumn> addedColumn = new ArrayList<IMetadataColumn>();
                        if (!added.isEmpty()) {
                            addedColumn.addAll((List<IMetadataColumn>) added.get(0));
                        }
                        if (!removed.isEmpty()) {
                            removedColumn.addAll((List<IMetadataColumn>) removed.get(0));
                        }
                        Map<IMetadataColumn, TreeNode> nodeMap = new HashMap<IMetadataColumn, TreeNode>();
                        for (int i = 0; i < removedColumn.size(); i++) {
                            IMetadataColumn column = removedColumn.get(i);
                            TreeNode node = selectedInputTree.getNodes().get(i);
                            boolean found = false;
                            for (IMetadataColumn columnAdded : addedColumn) {
                                if (column.sameMetacolumnAs(columnAdded)) {
                                    nodeMap.put(columnAdded, node);
                                    found = true;
                                    break;
                                }
                            }
                            if (!found) {
                                XmlMapUtil.detachNodeConnections(node, getExternalData(), true);
                                // get old loops if doc column need to be delete
                                if (needCheckOutput) {
                                    XmlMapUtil.getChildLoops(oldLoops, node.getChildren());
                                }
                            }
                        }
                        // remove all
                        selectedInputTree.getNodes().clear();
                        // add all
                        for (IMetadataColumn column : addedColumn) {
                            TreeNode treeNode = nodeMap.get(column);
                            if (treeNode == null) {
                                treeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                                treeNode.setName(column.getLabel());
                                treeNode.setType(column.getTalendType());
                                treeNode.setNullable(column.isNullable());
                                treeNode.setPattern(column.getPattern());
                                treeNode.setXpath(XmlMapUtil.getXPath(selectedInputTree.getName(), treeNode.getName(), treeNode.getNodeType()));
                                if (XmlMapUtil.DOCUMENT.equals(column.getTalendType())) {
                                    TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createTreeNode();
                                    createTreeNode.setName("root");
                                    createTreeNode.setType(XmlMapUtil.DEFAULT_DATA_TYPE);
                                    createTreeNode.setNodeType(NodeType.ELEMENT);
                                    createTreeNode.setXpath(XmlMapUtil.getXPath(treeNode.getXpath(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                    createTreeNode.setLoop(true);
                                    createTreeNode.setMain(true);
                                    treeNode.getChildren().add(createTreeNode);
                                }
                            }
                            selectedInputTree.getNodes().add(treeNode);
                        }
                        // for multi loops ,incase the doc node with multi loop is deleted
                        selectedInputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedInputTree));
                        if (!oldLoops.isEmpty()) {
                            XmlMapUtil.removeloopInOutputTree(MapperManager.this, oldLoops);
                        }
                        mapperUI.updateStatusBar();
                    }
                }
            });
            inputMetaEditorView.setMetadataTableEditor(editor);
        }
        refreshTreeSchemaEditor(inputTree);
    }
}

Example 12 with MetadataTableEditor

use of org.talend.core.ui.metadata.editor.MetadataTableEditor in project tdi-studio-se by Talend.

the class MapperManager method selectOutputXmlTree.

public void selectOutputXmlTree(OutputXmlTree outputTree) {
    if (outputTree != selectedOutputTree) {
        selectedOutputTree = outputTree;
        MetadataTableEditorView outputMetaEditorView = mapperUI.getTabFolderEditors().getOutputMetaEditorView();
        List<IMetadataTable> metadataList = getMapperComponent().getMetadataList();
        IMetadataTable table = null;
        for (int i = 0; i < metadataList.size(); i++) {
            if (outputTree.getName() != null && outputTree.getName().equals(metadataList.get(i).getTableName())) {
                table = metadataList.get(i);
                break;
            }
        }
        if (outputTree.isErrorReject()) {
            for (IMetadataColumn column : table.getListColumns()) {
                if (ERROR_REJECT_MESSAGE.equals(column.getLabel()) || ERROR_REJECT_STACK_TRACE.equals(column.getLabel())) {
                    column.setCustom(true);
                }
            }
            CustomTableManager.addCustomManagementToTable(mapperUI.getTabFolderEditors().getOutputMetaEditorView(), true);
        }
        if (table != null) {
            MetadataTableEditor editor = new MetadataTableEditor(table, table.getTableName());
            outputMetaEditorView.setMetadataTableEditor(editor);
            editor.setModifiedBeanListenable(outputMetaEditorView.getTableViewerCreator());
            IModifiedBeanListener<IMetadataColumn> columnListener = new IModifiedBeanListener<IMetadataColumn>() {

                @Override
                public void handleEvent(ModifiedBeanEvent<IMetadataColumn> event) {
                    fireCurrentDirectEditApply();
                    if (AbstractMetadataTableEditorView.ID_COLUMN_NAME.equals(event.column.getId())) {
                        if (event.index < selectedOutputTree.getNodes().size()) {
                            TreeNode treeNode = selectedOutputTree.getNodes().get(event.index);
                            if (treeNode != null) {
                                treeNode.setName((String) event.newValue);
                                processColumnNameChanged(treeNode);
                            }
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_TYPE.equals(event.column.getId())) {
                        if (event.index < selectedOutputTree.getNodes().size()) {
                            OutputTreeNode treeNode = selectedOutputTree.getNodes().get(event.index);
                            if (treeNode != null) {
                                String oldValue = treeNode.getType();
                                treeNode.setType((String) event.newValue);
                                if (oldValue != null && oldValue.equals(XmlMapUtil.DOCUMENT)) {
                                    XmlMapUtil.detachNodeConnections(treeNode, getExternalData(), true);
                                    List<TreeNode> removedLoops = new ArrayList<TreeNode>();
                                    if (mainInputTree != null && mainInputTree.isMultiLoops()) {
                                        XmlMapUtil.getChildLoops(removedLoops, treeNode.getChildren());
                                    }
                                    treeNode.getChildren().clear();
                                    selectedOutputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedOutputTree));
                                    if (mainInputTree != null && mainInputTree.isMultiLoops()) {
                                        if (XmlMapUtil.hasDocument(selectedOutputTree)) {
                                            XmlMapUtil.removeLoopTableForOutput(selectedOutputTree, removedLoops, mainInputTree == null ? false : mainInputTree.isMultiLoops());
                                        } else {
                                            selectedOutputTree.getInputLoopNodesTables().clear();
                                            selectedOutputTree.getInputLoopNodesTables().add(XmlmapFactory.eINSTANCE.createInputLoopNodesTable());
                                        }
                                    }
                                }
                                if (XmlMapUtil.DOCUMENT.equals(event.newValue)) {
                                    XmlMapUtil.detachNodeConnections(treeNode, getExternalData(), true);
                                    OutputTreeNode createTreeNode = XmlmapFactory.eINSTANCE.createOutputTreeNode();
                                    createTreeNode.setName("root");
                                    createTreeNode.setType(XmlMapUtil.DEFAULT_DATA_TYPE);
                                    createTreeNode.setNodeType(NodeType.ELEMENT);
                                    createTreeNode.setXpath(XmlMapUtil.getXPath(treeNode.getXpath(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                    createTreeNode.setLoop(true);
                                    createTreeNode.setMain(true);
                                    treeNode.getChildren().add(createTreeNode);
                                }
                                problemsAnalyser.checkProblems(selectedOutputTree);
                                mapperUI.updateStatusBar();
                                outputTreeSchemaBeanListModified();
                            }
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_KEY.equals(event.column.getId())) {
                        if (event.index < selectedOutputTree.getNodes().size()) {
                            TreeNode treeNode = selectedOutputTree.getNodes().get(event.index);
                            treeNode.setKey((Boolean) event.newValue);
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_PATTERN.equals(event.column.getId())) {
                        if (event.index < selectedOutputTree.getNodes().size()) {
                            TreeNode treeNode = selectedOutputTree.getNodes().get(event.index);
                            treeNode.setPattern((String) event.newValue);
                        }
                    } else if (AbstractMetadataTableEditorView.ID_COLUMN_NULLABLE.equals(event.column.getId())) {
                        if (event.index < selectedOutputTree.getNodes().size()) {
                            TreeNode treeNode = selectedOutputTree.getNodes().get(event.index);
                            treeNode.setNullable((Boolean) event.newValue);
                        }
                    }
                }
            };
            editor.addModifiedBeanListener(columnListener);
            editor.addAfterOperationListListener(new IListenableListListener() {

                @Override
                public void handleEvent(ListenableListEvent event) {
                    if (event.type == TYPE.ADDED) {
                        EList<OutputTreeNode> nodes = selectedOutputTree.getNodes();
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.addedObjects;
                        if (event.index != null) {
                            int index = event.index;
                            for (IMetadataColumn column : metadataColumns) {
                                OutputTreeNode createTreeNode = XmlmapFactory.eINSTANCE.createOutputTreeNode();
                                createTreeNode.setName(column.getLabel());
                                createTreeNode.setType(column.getTalendType());
                                createTreeNode.setNullable(column.isNullable());
                                createTreeNode.setPattern(column.getPattern());
                                createTreeNode.setXpath(XmlMapUtil.getXPath(selectedOutputTree.getName(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                selectedOutputTree.getNodes().add(index, createTreeNode);
                                index = index + 1;
                            }
                        }
                    } else if (event.type == TYPE.REMOVED) {
                        List<IMetadataColumn> metadataColumns = (List<IMetadataColumn>) event.removedObjects;
                        List treeNodeToRemove = new ArrayList();
                        for (IMetadataColumn column : metadataColumns) {
                            for (TreeNode node : selectedOutputTree.getNodes()) {
                                if (node.getName() != null && node.getName().equals(column.getLabel())) {
                                    XmlMapUtil.detachNodeConnections(node, getExternalData(), true);
                                    treeNodeToRemove.add(node);
                                }
                            }
                        }
                        selectedOutputTree.getNodes().removeAll(treeNodeToRemove);
                        problemsAnalyser.checkProblems(selectedOutputTree);
                        mapperUI.updateStatusBar();
                        outputTreeSchemaBeanListModified();
                    } else if (event.type == TYPE.SWAPED) {
                        List<Integer> listIndexTarget = event.indicesTarget;
                        List<Integer> listIndexOrignal = event.indicesOrigin;
                        for (int i = 0; i < listIndexOrignal.size(); i++) {
                            int orignal = listIndexOrignal.get(i);
                            int target = listIndexTarget.get(i);
                            if (orignal < selectedOutputTree.getNodes().size()) {
                                OutputTreeNode tempTreeNode = selectedOutputTree.getNodes().get(orignal);
                                selectedOutputTree.getNodes().remove(orignal);
                                selectedOutputTree.getNodes().add(target, tempTreeNode);
                            }
                        }
                    } else if (event.type == TYPE.REPLACED) {
                        // fix for TDI-24071
                        List added = (List) event.addedObjects;
                        List removed = (List) event.removedObjects;
                        List<IMetadataColumn> removedColumn = new ArrayList<IMetadataColumn>();
                        List<IMetadataColumn> addedColumn = new ArrayList<IMetadataColumn>();
                        if (!added.isEmpty()) {
                            addedColumn.addAll((List<IMetadataColumn>) added.get(0));
                        }
                        if (!removed.isEmpty()) {
                            removedColumn.addAll((List<IMetadataColumn>) removed.get(0));
                        }
                        Map<IMetadataColumn, OutputTreeNode> nodeMap = new HashMap<IMetadataColumn, OutputTreeNode>();
                        for (int i = 0; i < removedColumn.size(); i++) {
                            IMetadataColumn column = removedColumn.get(i);
                            OutputTreeNode node = selectedOutputTree.getNodes().get(i);
                            boolean found = false;
                            for (IMetadataColumn columnAdded : addedColumn) {
                                if (column.sameMetacolumnAs(columnAdded)) {
                                    nodeMap.put(columnAdded, node);
                                    found = true;
                                    break;
                                }
                            }
                            if (!found) {
                                XmlMapUtil.detachNodeConnections(node, getExternalData(), true);
                            }
                        }
                        // remove all
                        boolean needCheck = false;
                        if (selectedOutputTree.isMultiLoops()) {
                            needCheck = true;
                        }
                        selectedOutputTree.getNodes().clear();
                        // add all
                        for (IMetadataColumn column : addedColumn) {
                            OutputTreeNode treeNode = nodeMap.get(column);
                            if (treeNode == null) {
                                treeNode = XmlmapFactory.eINSTANCE.createOutputTreeNode();
                                treeNode.setName(column.getLabel());
                                treeNode.setType(column.getTalendType());
                                treeNode.setNullable(column.isNullable());
                                treeNode.setPattern(column.getPattern());
                                treeNode.setXpath(XmlMapUtil.getXPath(selectedInputTree.getName(), treeNode.getName(), treeNode.getNodeType()));
                                if (XmlMapUtil.DOCUMENT.equals(column.getTalendType())) {
                                    TreeNode createTreeNode = XmlmapFactory.eINSTANCE.createOutputTreeNode();
                                    createTreeNode.setName("root");
                                    createTreeNode.setType(XmlMapUtil.DEFAULT_DATA_TYPE);
                                    createTreeNode.setNodeType(NodeType.ELEMENT);
                                    createTreeNode.setXpath(XmlMapUtil.getXPath(treeNode.getXpath(), createTreeNode.getName(), createTreeNode.getNodeType()));
                                    createTreeNode.setLoop(true);
                                    createTreeNode.setMain(true);
                                    treeNode.getChildren().add(createTreeNode);
                                }
                            }
                            selectedOutputTree.getNodes().add(treeNode);
                        }
                        if (needCheck) {
                            selectedOutputTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(selectedOutputTree));
                        }
                        mapperUI.updateStatusBar();
                        mapperUI.updateStatusBar();
                    }
                }
            });
        }
        refreshTreeSchemaEditor(outputTree);
    }
}