/**
* DOC qiang.zhang Comment method "getUNIQUENAME".
*
* @param node
* @return
*/
public static String getUNIQUENAME(NodeType node) {
List<ElementParameterType> parameters = node.getElementParameter();
for (ElementParameterType elementParam : parameters) {
if (elementParam.getName().equals("UNIQUE_NAME")) { // $NON-NLS-1$
return elementParam.getValue();
}
}
return ""; //$NON-NLS-1$
}
protected static boolean checkIsDeactivated(NodeType nodeType) {
@SuppressWarnings("unchecked")
List<ElementParameterType> params = nodeType.getElementParameter();
for (ElementParameterType param : params) {
if (param.getName().equals("Activate")) {
return "false".equals(param.getValue());
}
}
return false;
}
public static boolean isContains(ParametersType paType, String paramName) {
EList listParamType = paType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null && paramName.equals(pType.getName())) {
return true;
}
}
return false;
}
public static ElementParameterType findElementParameterType(ParametersType paType, String name) {
EList listParamType = paType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
String name2 = pType.getName();
if (name2 != null && name2.equals(name)) {
return pType;
}
}
return null;
}
public static String getParameterValue(ParametersType paType, String paramName) {
if (paType == null) {
return null;
}
EList listParamType = paType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null && paramName.equals(pType.getName())) {
return pType.getValue();
}
}
return null;
}
public void transform(NodeType node) {
if (ComponentUtilities.getNodeProperty(node, name) == null) {
ComponentUtilities.addNodeProperty(node, name, field);
}
String host = "", port = "";
boolean hostDone = false, portDone = false;
for (Object o : node.getElementParameter()) {
ElementParameterType para = (ElementParameterType) o;
if ("HOST".equals(para.getName())) {
host = para.getValue();
hostDone = true;
}
if ("PORT".equals(para.getName())) {
port = para.getValue();
portDone = true;
}
if (hostDone && portDone) break;
}
for (Object o : node.getElementParameter()) {
ElementParameterType para = (ElementParameterType) o;
if ("DB_VERSION".equals(para.getName())) { // $NON-NLS-1$
if (para.getValue().startsWith("hadoop-0.20.2-dev-core.jar")) {
ComponentUtilities.setNodeValue(
node, name, "\"maprfs://\"+" + host + "+\":\" + " + port + " + \"/\"");
} else {
ComponentUtilities.setNodeValue(node, name, "\"hdfs://\"+" + host + "+\":\" + " + port);
}
break;
}
}
}
public static void setParameterValue(ParametersType paType, String paramName, Object value) {
if (value == null) {
return;
}
EList listParamType = paType.getElementParameter();
if (!isContains(paType, paramName)) {
ElementParameterType etype = TalendFileFactory.eINSTANCE.createElementParameterType();
etype.setName(paramName);
listParamType.add(etype);
}
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null && paramName.equals(pType.getName())) {
pType.setValue(value.toString());
return;
}
}
}
@Override
public List<ModuleNeeded> getModulesNeededForJobs() throws PersistenceException {
List<ModuleNeeded> importNeedsList = new ArrayList<ModuleNeeded>();
IProxyRepositoryFactory repositoryFactory =
CoreRuntimePlugin.getInstance().getRepositoryService().getProxyRepositoryFactory();
ERepositoryObjectType jobType = ERepositoryObjectType.PROCESS;
if (jobType != null) {
List<IRepositoryViewObject> jobs = repositoryFactory.getAll(jobType, true);
for (IRepositoryViewObject cur : jobs) {
if (!cur.isDeleted()) {
ProcessItem item = (ProcessItem) cur.getProperty().getItem();
if (item == null || item.getProcess() == null) {
continue;
}
List<NodeType> nodes = item.getProcess().getNode();
for (NodeType node : nodes) {
List<ElementParameterType> elementParameter = node.getElementParameter();
for (ElementParameterType elementParam : elementParameter) {
if (elementParam.getField() != null
&& elementParam.getField().equals(EParameterFieldType.MODULE_LIST.getName())) {
String uniquename = coreSerivce.getParameterUNIQUENAME(node);
ModuleNeeded toAdd =
new ModuleNeeded(
Messages.getString("AbstractEMFRepositoryFactory.job")
+ item.getProperty().getLabel(), // $NON-NLS-1$
elementParam.getValue(),
Messages.getString("AbstractEMFRepositoryFactory.requiredComponent")
+ uniquename
+ ".",
true); //$NON-NLS-1$ //$NON-NLS-2$
importNeedsList.add(toAdd);
}
}
}
}
}
}
return importNeedsList;
}
/**
* wchen Comment method "updateParameters".
*
* @param node
* @param attrMap
* @param statAndLogs
*/
private void updateParameters(final Node node, final NamedNodeMap attrMap, List statAndLogs) {
boolean added = false;
for (Object obj : statAndLogs) {
ElementParameterType type = (ElementParameterType) obj;
if (type.getName().equals(attrMap.getNamedItem("name").getTextContent())) { // $NON-NLS-1$
type.setValue(node.getTextContent());
added = true;
}
}
// if there is no such parameter in current settings add one
TalendFileFactory talendF = TalendFileFactory.eINSTANCE;
if (added == false) {
ElementParameterType type = talendF.createElementParameterType();
type.setName(attrMap.getNamedItem("name").getTextContent()); // $NON-NLS-1$
type.setValue(node.getTextContent());
statAndLogs.add(type);
}
}
public static ElementParameterType getElemeterParameterType(IElementParameter param) {
if (param == null) {
return null;
}
ElementParameterType targetPramType = TalendFileFactory.eINSTANCE.createElementParameterType();
if (param.getParentParameter() != null) {
targetPramType.setName(
param.getParentParameter().getName() + ":" + param.getName()); // $NON-NLS-1$
} else {
targetPramType.setName(param.getName());
}
targetPramType.setField(param.getFieldType().getName());
targetPramType.setContextMode(param.isContextMode());
Object value = param.getValue();
if (param.getFieldType().equals(EParameterFieldType.TABLE) && value != null) {
List<Map<String, Object>> tableValues = (List<Map<String, Object>>) value;
for (Map<String, Object> currentLine : tableValues) {
for (int i = 0; i < param.getListItemsDisplayCodeName().length; i++) {
ElementValueType elementValue = TalendFileFactory.eINSTANCE.createElementValueType();
elementValue.setElementRef(param.getListItemsDisplayCodeName()[i]);
Object o = currentLine.get(param.getListItemsDisplayCodeName()[i]);
IElementParameter tmpParam = null;
Object[] listItemsValue = param.getListItemsValue();
if (listItemsValue.length > i) {
tmpParam = (IElementParameter) listItemsValue[i];
}
String strValue = ""; // $NON-NLS-1$
if (o instanceof Integer && tmpParam != null) {
if (tmpParam.getListItemsValue().length == 0) {
strValue = ""; // $NON-NLS-1$
} else {
strValue = (String) tmpParam.getListItemsValue()[(Integer) o];
}
} else {
if (o instanceof String) {
strValue = (String) o;
} else {
if (o instanceof Boolean) {
strValue = ((Boolean) o).toString();
}
}
}
if (tmpParam != null && tmpParam.getFieldType().equals(EParameterFieldType.PASSWORD)) {
elementValue.setValue(strValue, true);
} else {
elementValue.setValue(strValue);
}
//
Object object =
currentLine.get(param.getListItemsDisplayCodeName()[i] + IEbcdicConstant.REF_TYPE);
if (object != null) {
elementValue.setType((String) object);
}
targetPramType.getElementValue().add(elementValue);
}
}
} else {
if (value == null) {
targetPramType.setValue(""); // $NON-NLS-1$
} else {
if (value instanceof Boolean) {
targetPramType.setValue(((Boolean) value).toString());
} else {
if (value instanceof String) {
targetPramType.setRawValue(value.toString());
}
}
}
}
return targetPramType;
}
/**
* load project settings to no-opened process
*
* @param elemParam
* @param projectPaType
*/
public static void loadElementParameters(
ParametersType processType, ParametersType projectPaType, EParameterName paramName) {
EList listParamType = projectPaType.getElementParameter();
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
EList processParameters = processType.getElementParameter();
ElementParameterType processParam = null;
for (int i = 0; i < processParameters.size(); i++) {
ElementParameterType paramType = (ElementParameterType) processParameters.get(i);
if (paramType.getName().equals(pType.getName())
&& paramType.getField() != null
&& paramType.getField().equals(pType.getField())) {
processParam = paramType;
} else if (pType.getName().contains(":")) {
StringTokenizer token = new StringTokenizer(pType.getName(), ":"); // $NON-NLS-1$
String parentId = token.nextToken();
String childId = token.nextToken();
String[] split = paramType.getName().split(":");
if (split.length != 2) {
continue;
}
String complexName = paramName + ":" + childId;
if (complexName.equals(paramType.getName())) {
processParam = paramType;
}
}
if (processParam != null) {
break;
}
}
if (processParam != null) {
processParam.setValue(pType.getValue());
} else {
TalendFileFactory fileFact = TalendFileFactory.eINSTANCE;
ElementParameterType processTypes = fileFact.createElementParameterType();
processTypes.setName(pType.getName());
processTypes.setField(pType.getField());
processTypes.setValue(pType.getValue());
processType.getElementParameter().add(processTypes);
}
}
}
/**
* load the Element's parameters to EMF Model
*
* @param elemParam
* @param paType
*/
public static void loadElementParameters(
Element elemParam, ParametersType paType, String repParamName) {
if (paType == null || elemParam == null) {
return;
}
EList listParamType = paType.getElementParameter();
ElementParameterType repositoryParam = null;
if (repParamName != null && !repParamName.equals("")) {
repositoryParam = findElementParameterType(paType, repParamName);
} else {
repositoryParam =
findElementParameterType(
paType,
EParameterName.PROPERTY_TYPE.getName()
+ ":"
+ EParameterName.PROPERTY_TYPE.getName());
}
IElementParameter statsDBType = null;
IElementParameter implicitDBType = null;
IElementParameter statsDBVersion = null;
IElementParameter implicitDBVersion = null;
for (int j = 0; j < listParamType.size(); j++) {
ElementParameterType pType = (ElementParameterType) listParamType.get(j);
if (pType != null) {
String pTypeName = pType.getName();
if (pTypeName != null && !"".equals(pTypeName)) {
IElementParameter param = elemParam.getElementParameter(pTypeName);
if (pTypeName.equals("DB_TYPE")) { // $NON-NLS-1$
statsDBType = param;
} else if (pTypeName.equals("DB_VERSION")) { // $NON-NLS-1$
statsDBVersion = param;
} else if (pTypeName.equals("DB_TYPE_IMPLICIT_CONTEXT")) { // $NON-NLS-1$
implicitDBType = param;
} else if (pTypeName.equals("DB_VERSION_IMPLICIT_CONTEXT")) { // $NON-NLS-1$
implicitDBVersion = param;
}
if (param != null) {
String name = param.getName();
param.setContextMode(pType.isContextMode());
if (param.isReadOnly()
&& !(EParameterName.UNIQUE_NAME.getName().equals(name)
|| EParameterName.VERSION.getName().equals(name))) {
continue; // if the parameter is read only, don't load
// it (this will prevent to overwrite the
// value)
}
String value = null;
if ("STATANDLOG_USE_PROJECT_SETTINGS".equals(name) // $NON-NLS-1$
|| "IMPLICITCONTEXT_USE_PROJECT_SETTINGS".equals(name)) { // $NON-NLS-1$
Object value2 = param.getValue();
if (value2 != null) {
value = value2.toString();
}
} else {
value = pType.getValue();
}
if (param.getFieldType().equals(EParameterFieldType.CHECK)
|| param.getFieldType().equals(EParameterFieldType.RADIO)) {
if (Boolean.FALSE.toString().equalsIgnoreCase(value)
|| Boolean.TRUE.toString().equalsIgnoreCase(value)
|| !pType.isContextMode()) {
Boolean boolean1 = new Boolean(value);
elemParam.setPropertyValue(pTypeName, boolean1);
} else {
elemParam.setPropertyValue(pTypeName, value);
}
// if (EParameterName.ACTIVATE.getName().equals(param.getName())) {
// if ((elemParam instanceof Node) && !boolean1) {
// ((Node) elemParam).setDummy(!boolean1);
// }
// }
} else if (param.getFieldType().equals(EParameterFieldType.CLOSED_LIST)) {
boolean valueSet = false;
if (!ArrayUtils.contains(param.getListItemsValue(), value)) {
if (ArrayUtils.contains(param.getListItemsDisplayName(), value)) {
valueSet = true;
int index = ArrayUtils.indexOf(param.getListItemsDisplayName(), value);
if (index > -1) {
elemParam.setPropertyValue(pTypeName, param.getListItemsValue()[index]);
}
} else if (value.equals("")
&& name != null
&& (name.equals("LOAD_NEW_VARIABLE") || name.equals("NOT_LOAD_OLD_VARIABLE"))) {
valueSet = true;
elemParam.setPropertyValue(pTypeName, param.getListItemsValue()[1]);
}
}
if (!valueSet) {
elemParam.setPropertyValue(pTypeName, value);
}
} else if (param.getFieldType().equals(EParameterFieldType.TABLE)) {
List<Map<String, Object>> tableValues = new ArrayList<Map<String, Object>>();
String[] codeList = param.getListItemsDisplayCodeName();
Map<String, Object> lineValues = null;
for (ElementValueType elementValue :
(List<ElementValueType>) pType.getElementValue()) {
boolean found = false;
int length = codeList.length;
if (length > 0) {
for (int i = 0; i < length && !found; i++) {
if (codeList[i].equals(elementValue.getElementRef())) {
found = true;
}
}
}
IElementParameter tmpParam = null;
for (Object o : param.getListItemsValue()) {
if (o instanceof IElementParameter) {
IElementParameter tableParam = (IElementParameter) o;
if (tableParam.getName().equals(elementValue.getElementRef())) {
tmpParam = tableParam;
break;
}
}
}
if (found) {
if ((lineValues == null)
|| (lineValues.get(elementValue.getElementRef()) != null)) {
lineValues = new HashMap<String, Object>();
tableValues.add(lineValues);
}
String elemValue = elementValue.getValue();
if (tmpParam != null
&& EParameterFieldType.PASSWORD.equals(tmpParam.getFieldType())) {
elemValue = elementValue.getRawValue();
}
lineValues.put(elementValue.getElementRef(), elemValue);
if (elementValue.getType() != null) {
lineValues.put(
elementValue.getElementRef() + IEbcdicConstant.REF_TYPE,
elementValue.getType());
}
}
}
elemParam.setPropertyValue(pTypeName, tableValues);
} else if (param.getFieldType().equals(EParameterFieldType.PASSWORD)) {
param.setValue(pType.getRawValue());
} else if (param.getFieldType().equals(EParameterFieldType.ENCODING_TYPE)) {
// fix for bug 2193
boolean setToCustom = false;
if (EmfComponent.REPOSITORY.equals(
elemParam.getPropertyValue(EParameterName.PROPERTY_TYPE.getName()))
&& param.getRepositoryValue() != null
&& param.getRepositoryValue().equals("ENCODING")) { // $NON-NLS-1$
setToCustom = true;
}
String tempValue = null;
IElementParameter iElementParameter = null;
Map<String, IElementParameter> childParameters = param.getChildParameters();
if (childParameters != null) {
iElementParameter = childParameters.get(EParameterName.ENCODING_TYPE.getName());
if (iElementParameter != null) {
tempValue = (String) iElementParameter.getValue();
}
}
if (tempValue != null && !tempValue.equals(EmfComponent.ENCODING_TYPE_CUSTOM)) {
tempValue = tempValue.replaceAll("'", ""); // $NON-NLS-1$ //$NON-NLS-2$
tempValue = tempValue.replaceAll("\"", ""); // $NON-NLS-1$ //$NON-NLS-2$
tempValue = TalendTextUtils.addQuotes(tempValue);
if (!tempValue.equals(value)) {
setToCustom = true;
}
}
if (iElementParameter != null && setToCustom) {
iElementParameter.setValue(EmfComponent.ENCODING_TYPE_CUSTOM);
}
elemParam.setPropertyValue(pTypeName, value);
// end of fix for bug 2193
} else if (!param.getFieldType().equals(EParameterFieldType.SCHEMA_TYPE)) {
if (param.getRepositoryValue() != null
&& !param.getFieldType().equals(EParameterFieldType.PROPERTY_TYPE)) {
if (repositoryParam != null
&& EmfComponent.REPOSITORY.equals(repositoryParam.getValue())) {
param.setRepositoryValueUsed(true);
} else {
param.setRepositoryValueUsed(false);
}
}
elemParam.setPropertyValue(pTypeName, value);
}
} else if (UpdateTheJobsActionsOnTable.isClear
&& "CLEAR_TABLE".equals(pTypeName) // $NON-NLS-1$
&& "true".equals(pType.getValue()) // $NON-NLS-1$
&& "NONE"
.equals(
elemParam
.getElementParameter(Process.TABLE_ACTION)
.getValue())) { //$NON-NLS-1$
elemParam.setPropertyValue(Process.TABLE_ACTION, "CLEAR"); // $NON-NLS-1$
UpdateTheJobsActionsOnTable.isClear = false;
}
}
}
}
// update combo list for dbversion
if (statsDBType != null && statsDBVersion != null) {
JobSettingVersionUtil.setDbVersion(
statsDBVersion,
String.valueOf(statsDBType.getValue()),
String.valueOf(statsDBVersion.getValue()));
}
if (implicitDBType != null && implicitDBVersion != null) {
JobSettingVersionUtil.setDbVersion(
implicitDBVersion,
String.valueOf(implicitDBType.getValue()),
String.valueOf(implicitDBVersion.getValue()));
}
}
