//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 IBM Corporation and others.
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// which accompanies this distribution, and is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// Contributors:
// IBM Corporation - initial implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.tester.impl.testcommands;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EDataType;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.epf.library.tester.TesterOutputUtil;
import org.eclipse.epf.library.tester.iface.TCExeReply;
import org.eclipse.epf.library.tester.iface.TestCommand;
import org.eclipse.epf.library.tester.impl.TestCommandImpl;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessElement;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.VariabilityType;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import com.ibm.icu.text.SimpleDateFormat;
/**
* A test command class
*
* @author Weiping Lu
* @since 1.0
*
*/
public abstract class TCEditMethodElementBase extends TestCommandImpl {
static class TagData {
public Map attMap = new LinkedHashMap();
public Map refMap = new LinkedHashMap();
}
private EClass eclass;
private TagData tagData;
private MethodElement methodElement;
private Map refValueMap = new HashMap();
private static Map eclassDataMap = new HashMap();
private List childCommands = new ArrayList();
private boolean isChildCommand = false;
protected TestCommand newChildCommand(Class type) {
try {
TCEditMethodElementBase command = (TCEditMethodElementBase) type.newInstance();
command.setOwner(getOwner());
command.setIsChildCommand(true);
if (localDebug) {
System.out.println("LD> newChildCommand: " + type);
}
return command;
} catch (Exception e){
e.printStackTrace();
}
return null;
}
public void parse(Element element) {
super.parse(element);
init(element);
parseAttributes();
parseValueChildren();
}
private void init(Element element) {
String type = element.getAttribute(AT_Type);
eclass = methodElement == null ? getEClass(type) : methodElement.eClass();
if (eclass == null) {
return;
}
tagData = (TagData) eclassDataMap.get(eclass);
if (tagData != null) {
return;
}
tagData = new TagData();
eclassDataMap.put(eclass, tagData);
if (localDebug) {
System.out.println("LD> eclass: " + eclass.getName());
TesterOutputUtil.show("eclass.getEAllAttributes()", eclass.getEAllAttributes());
TesterOutputUtil.show("eclass.getEAllReferences()", eclass.getEAllReferences());
}
addToEclassDataMap(eclass.getEAllAttributes(), tagData.attMap);
addToEclassDataMap(eclass.getEAllReferences(), tagData.refMap);
}
private void addToEclassDataMap(List features, Map feaMap) {
boolean verbose = getVerbose();
boolean isRef = false;
if (verbose) {
if (feaMap == tagData.attMap) {
log("\nAttribute featues for " + "\"" + eclass.getName() + "\": ");
} else if (feaMap == tagData.refMap) {
log("\nReference featues for " + "\"" + eclass.getName() + "\": ");
isRef = true;
}
}
for (int i=0; i<features.size(); i++) {
EStructuralFeature feature = (EStructuralFeature) features.get(i);
feaMap.put(feature.getName(), feature);
if (verbose) {
String line = "";
if (isRef) {
line += ((EReference) feature).isContainment() ?
"contained, " : "referred , ";
line += ((EReference) feature).isMany() ?
"many -> " : "single -> ";
}
line += feature.getName() + ": ";
line += isRef ? ((EReference) feature).getEReferenceType().getInstanceClassName()
: ((EAttribute) feature).getEAttributeType().getInstanceClassName();
log(line);
}
}
}
protected void parseAttributes() {
setAttribute(AT_Type, getElement().getAttribute(AT_Type));
setAttribute(AT_Path, getElement().getAttribute(AT_Path));
for (Iterator it = tagData.attMap.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String at_tag = (String) entry.getKey();
setAttribute(at_tag, getElement().getAttribute(at_tag));
}
}
protected void parseValueChildren() {
for (Iterator it = tagData.refMap.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String childTag = (String) entry.getKey();
setAttribute(childTag, getElement().getAttribute(childTag));
parseChildTagAsValue(childTag);
}
}
private void parseChildTagAsValue(String childTag) {
NodeList cnodes = getElement().getElementsByTagName(childTag);
if (cnodes == null || cnodes.getLength() == 0) {
return;
}
Element cElement = (Element) cnodes.item(0);
cnodes = cElement.getElementsByTagName(VT_Value);
if (cnodes == null || cnodes.getLength() == 0) {
return;
}
List valueList = new ArrayList();
for (int i=0; i<cnodes.getLength(); i++) {
Element vElem = (Element) cnodes.item(i);
String value = vElem.getFirstChild().getNodeValue();
valueList.add(value);
}
refValueMap.put(childTag, valueList);
}
private void setMethodElement(MethodElement e) {
methodElement = e;
}
protected MethodElement getMethodElement() {
return methodElement;
}
protected TagData getTagData() {
return tagData;
}
private boolean parseChildTagAsCommand(Element cElement, String childTag) {
EReference feature = (EReference) tagData.refMap.get(childTag);
if (! feature.isContainment()) {
return false;
}
TCEditMethodElementBase childCommand = (TCEditMethodElementBase) newChildCommand(TCEditMethodElement.class);
Object featureObj = methodElement.eGet(feature);
if (feature.isMany()) {
List ownerList = (List) featureObj;
featureObj = UmaFactory.eINSTANCE.create(feature.getEReferenceType());
ownerList.add(featureObj);
}
childCommand.setMethodElement((MethodElement) featureObj);
if (getVerbose()) {
cElement.setAttribute(AT_Verbose, "true");
}
childCommand.parse(cElement);
addToChildCommands(childCommand);
return true;
}
private void parseCommandChildren() {
for (Iterator it = tagData.refMap.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String childTag = (String) entry.getKey();
NodeList cnodes = getElement().getElementsByTagName(childTag);
if (cnodes == null || cnodes.getLength() == 0) {
continue;
}
for (int i=0; i<cnodes.getLength(); i++) {
Element cElement = (Element) cnodes.item(i);
parseChildTagAsCommand(cElement, childTag);
}
}
}
private TCExeReply executeChildCommands() {
for (int i=0; i<childCommands.size(); i++) {
TestCommand command = (TestCommand) childCommands.get(i);
TCExeReply result = command.execute();
if (result != null && !result.passing()) {
return result;
}
}
return null;
}
public TCExeReply execute() {
MethodLibrary currLib = getOwner().getCurrentBaseLib();
String path = getAttribute(AT_Path);
if (methodElement == null) {
if (UmaFactory.eINSTANCE.create(eclass) instanceof ProcessElement) {
methodElement = TesterOutputUtil.getProcessElement(currLib, path);
} else {
methodElement = TesterOutputUtil.getMethodElement(currLib, path);
}
}
if (methodElement == null) {
return null;
}
parseCommandChildren();
eSetByAttributes();
eSetByValueChildren();
executeChildCommands();
if (! getIsChildCommand()) {
save(methodElement);
//save((MethodElement) methodElement.eContainer());
}
return null;
}
private void eSetByAttributes() {
Map attMap = getTagData().attMap;
Map attributeMap = getAttributeMap();
for (Iterator it = attMap.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String at_tag = (String) entry.getKey();
EAttribute eatt = (EAttribute) entry.getValue();
EDataType dataType = eatt.getEAttributeType();
String at_val = (String) attributeMap.get(at_tag);
if (localDebug) {
System.out.println("LD> at_tag: " + at_tag);
System.out.println("LD> at_val: " + at_val);
System.out.println("LD> eatt: " + eatt);
System.out.println("LD> dataType: " + dataType);
System.out.println("");
}
if (at_val == null || at_val.length() == 0) {
continue;
}
Object newValue = getESetValue(dataType, at_val);
if (newValue != null) {
methodElement.eSet(eatt, newValue);
} else {
log("\nWarning: not handled dataType: " + dataType.getInstanceClassName());
}
}
EAttribute dateAtt = (EAttribute) attMap.get("changeDate");
if (dateAtt != null) {
methodElement.eSet(dateAtt, new Date());
}
}
private Object getESetValue(EDataType dataType, String strVal) {
Class cls = dataType.getInstanceClass();
if (cls.equals(String.class)) {
return strVal;
}
if (cls.equals(Boolean.class)) {
boolean b = strVal.equalsIgnoreCase("true");
if (!b && !strVal.equalsIgnoreCase("false")) {
throw new UnsupportedOperationException();
}
return new Boolean(b);
}
if (cls.equals(Date.class)) {
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
Date date = null;
try {
date = sdf.parse(strVal);
} catch (Exception e){
e.printStackTrace();
}
return date;
}
if (cls.equals(VariabilityType.class)) {
if (strVal.equals("contributes")) {
return VariabilityType.CONTRIBUTES;
}
if (strVal.equals("extends")) {
return VariabilityType.EXTENDS;
}
if (strVal.equals("replaces")) {
return VariabilityType.REPLACES;
}
}
return null;
}
private void eSetByValueChildren() {
MethodLibrary currLib = getOwner().getCurrentBaseLib();
Map refMap = getTagData().refMap;
for (Iterator it = refMap.entrySet().iterator(); it.hasNext();) {
Map.Entry entry = (Map.Entry) it.next();
String ref_tag = (String) entry.getKey();
EReference eref = (EReference) entry.getValue();
EClassifier eType = eref.getEType();
List valueList = (List) refValueMap.get(ref_tag);
if (localDebug) {
System.out.println("LD> ref_tag: " + ref_tag);
System.out.println("LD> valueList: " + valueList);
System.out.println("LD> eref: " + eref);
System.out.println("LD> eType: " + eType);
System.out.println("");
}
int sz = valueList == null ? 0 : valueList.size();
if (sz == 0) {
continue;
}
if (eref.isMany()) {
List ownerList = (List) methodElement.eGet(eref);
for (int i=0; i<sz; i++) {
String refPath = (String) valueList.get(i);
MethodElement refElement = TesterOutputUtil.getMethodElement(currLib, refPath);
if (refElement != null) {
ownerList.add(refElement);
}
}
} else if (sz == 1){
String refPath = (String) valueList.get(0);
MethodElement refElement = TesterOutputUtil.getMethodElement(currLib, refPath);
if (eref.getName().equals("variabilityBasedOnElement")
&& refElement instanceof ProcessComponent) {
refElement = ((ProcessComponent)refElement).getProcess();
}
methodElement.eSet(eref, refElement);
} else {
throw new UnsupportedOperationException();
}
}
}
protected void setIsChildCommand(boolean b) {
isChildCommand = b;
}
protected boolean getIsChildCommand() {
return isChildCommand;
}
protected void addToChildCommands(TestCommand command) {
childCommands.add(command);
}
}