use of org.talend.designer.xmlmap.model.emf.xmlmap.InputXmlTree in project tdi-studio-se by Talend.
the class SetLoopAction method run.
@Override
public void run() {
TreeNode model = (TreeNode) nodePart.getModel();
TreeNode docRoot = XmlMapUtil.getTreeNodeRoot(model);
AbstractInOutTree abstractTree = (AbstractInOutTree) docRoot.eContainer();
boolean isLookup = abstractTree != mapperManager.getMainInputTree() && !(abstractTree instanceof OutputXmlTree);
// remove old group
if (model instanceof OutputTreeNode) {
OutputTreeNode outputNode = (OutputTreeNode) model;
if (docRoot != null) {
XmlMapUtil.cleanSubGroup(outputNode);
List<TreeNode> newLoopUpGroups = new ArrayList<TreeNode>();
findUpGroupNode(newLoopUpGroups, outputNode);
// clean all groups except the ancestor of new loop
XmlMapUtil.cleanSubGroup(docRoot, newLoopUpGroups);
// reset the group in case some element ancestor of loop element are not group but under the group
if (!newLoopUpGroups.isEmpty()) {
TreeNode rootGroup = newLoopUpGroups.get(newLoopUpGroups.size() - 1);
upsetGroup(outputNode, rootGroup);
}
}
}
if (!isLookup) {
// TDI-20147
List<TreeNode> loopNodes = new ArrayList<TreeNode>();
checkSubElementIsLoop(model, loopNodes);
checkParentElementIsLoop(model, loopNodes);
if (!loopNodes.isEmpty()) {
if (MessageDialog.openConfirm(Display.getDefault().getActiveShell(), Messages.getString("SetLoopAction.cleanSubLoopTitle"), Messages.getString("SetLoopAction.cleanSubLoopMessages"))) {
} else {
return;
}
}
for (TreeNode treeNode : loopNodes) {
treeNode.setLoop(false);
}
model.setLoop(true);
XmlMapUtil.clearMainNode(model);
XmlMapUtil.upsetMainNode(model);
abstractTree.setMultiLoops(XmlMapUtil.checkMultiLoopsStatus(abstractTree));
if (input) {
// check if child is mapped to output remove the old loop in output node
XmlMapUtil.removeloopInOutputTree(mapperManager, loopNodes);
// disable the function to add sourceloop into InputLoopNodesTable automatically
// add input loopNodes to InputLoopNodesTable
// addInputLoopNodesToOutput(model, model);
} else {
// clean the InputLoopNodesTable for the old loops
InputXmlTree mainInput = mapperManager.getMainInputTree();
XmlMapUtil.removeLoopTableForOutput((OutputXmlTree) abstractTree, loopNodes, mainInput == null ? false : mainInput.isMultiLoops());
}
} else {
if (docRoot != null) {
cleanSubLoop(docRoot);
}
model.setLoop(true);
XmlMapUtil.clearMainNode(docRoot);
XmlMapUtil.upsetMainNode(model);
}
if (abstractTree != null) {
mapperManager.getProblemsAnalyser().checkProblems(abstractTree);
mapperManager.getMapperUI().updateStatusBar();
}
}
use of org.talend.designer.xmlmap.model.emf.xmlmap.InputXmlTree 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();
}
}
use of org.talend.designer.xmlmap.model.emf.xmlmap.InputXmlTree in project tdi-studio-se by Talend.
the class XmlMapComponent method isRunRefSubProcessAtStart.
@Override
public boolean isRunRefSubProcessAtStart(String connectionName) {
XmlMapData externalEmfData = (XmlMapData) getExternalEmfData();
List<InputXmlTree> inputTrees = new ArrayList<InputXmlTree>(externalEmfData.getInputTrees());
for (InputXmlTree table : inputTrees) {
if (table.getName().equals(connectionName)) {
String lookupMode = table.getLookupMode();
if (XML_MAP_LOOKUP_MODE.RELOAD.name().equals(lookupMode) || XML_MAP_LOOKUP_MODE.CACHE_OR_RELOAD.name().equals(lookupMode)) {
return false;
}
}
}
return true;
}
use of org.talend.designer.xmlmap.model.emf.xmlmap.InputXmlTree 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;
}
use of org.talend.designer.xmlmap.model.emf.xmlmap.InputXmlTree 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;
}
Aggregations