//------------------------------------------------------------------------------
// 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.importing.xml.services;
import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.epf.common.service.versioning.VersionUtil;
import org.eclipse.epf.common.ui.util.MsgBox;
import org.eclipse.epf.common.ui.util.MsgDialog;
import org.eclipse.epf.common.utils.ExtensionHelper;
import org.eclipse.epf.dataexchange.util.ContentProcessor;
import org.eclipse.epf.dataexchange.util.IResourceHandler;
import org.eclipse.epf.export.services.DiagramHandler;
import org.eclipse.epf.export.xml.ExportXMLResources;
import org.eclipse.epf.export.xml.services.FeatureManager;
import org.eclipse.epf.export.xml.services.XMLLibrary;
import org.eclipse.epf.importing.ImportPlugin;
import org.eclipse.epf.importing.ImportResources;
import org.eclipse.epf.importing.services.ConfigurationImportService;
import org.eclipse.epf.importing.services.FileModifyChecker;
import org.eclipse.epf.importing.services.LibraryImportManager;
import org.eclipse.epf.importing.wizards.PluginModifyInfo;
import org.eclipse.epf.importing.wizards.SelectImportConfigurationSource;
import org.eclipse.epf.importing.xml.ImportXMLPlugin;
import org.eclipse.epf.importing.xml.ImportXMLResources;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.edit.util.DescriptorPropUtil;
import org.eclipse.epf.library.edit.util.MethodLibraryPropUtil;
import org.eclipse.epf.library.edit.util.MethodPluginPropUtil;
import org.eclipse.epf.library.services.SafeUpdateController;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.persistence.MultiFileResourceSetImpl;
import org.eclipse.epf.persistence.migration.IMigrator;
import org.eclipse.epf.persistence.migration.MappingUtil;
import org.eclipse.epf.persistence.refresh.RefreshJob;
import org.eclipse.epf.services.IFileBasedLibraryPersister;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.ecore.IModelObject;
import org.eclipse.epf.xml.uma.Activity;
import org.eclipse.epf.xml.uma.BreakdownElement;
import org.eclipse.epf.xml.uma.CapabilityPattern;
import org.eclipse.epf.xml.uma.ContentCategory;
import org.eclipse.epf.xml.uma.ContentCategoryPackage;
import org.eclipse.epf.xml.uma.ContentPackage;
import org.eclipse.epf.xml.uma.DeliveryProcess;
import org.eclipse.epf.xml.uma.Discipline;
import org.eclipse.epf.xml.uma.Domain;
import org.eclipse.epf.xml.uma.Guidance;
import org.eclipse.epf.xml.uma.MethodElement;
import org.eclipse.epf.xml.uma.MethodElementProperty;
import org.eclipse.epf.xml.uma.MethodLibrary;
import org.eclipse.epf.xml.uma.MethodPackage;
import org.eclipse.epf.xml.uma.MethodPlugin;
import org.eclipse.epf.xml.uma.ProcessComponent;
import org.eclipse.epf.xml.uma.ProcessPackage;
import org.eclipse.epf.xml.uma.TaskDescriptor;
import org.eclipse.epf.xml.uma.UmaPackage;
import org.eclipse.epf.xml.uma.WorkOrder;
import org.eclipse.epf.xml.uma.WorkOrderType;
import org.eclipse.osgi.util.NLS;
/**
* Xml import service class to process the importing task
*
* @author Jinhua Xi
* @since 1.0
*/
public class ImportXMLService {
private List unlockedPlugins;
private boolean error = false;
private Map renameElementMap = new HashMap();
private boolean overwrite = false;
private int mergeLevel = 0;
private IStatus fileCheckedOutStatus = null;
private String xmlPath;
protected XMLLibrary xmlLib;
private UmaLibrary umaLib;
private ImportXMLogger logger = new ImportXMLogger();
private List discardedElements = new ArrayList();
private DiagramHandler diagramHandler;
//tds with steps
private Map<String, TaskDescriptor> tdMap;
// map xml WorkOrder to uma WorkOrder
Map workOrderMap = new HashMap();
private IMigrator migrator;
private boolean checkBasePlugins = true;
private boolean isBaseLibSynFree = false;
/**
* The constructor
*/
public ImportXMLService() {
}
public static ImportXMLService newInstance() {
Object obj = ExtensionHelper.create(ImportXMLService.class, null);
if (obj instanceof ImportXMLService) {
return (ImportXMLService) obj;
}
return new ImportXMLService();
}
/**
* Loads the xml file.
* @param xmlPath
* @return true if succeeds.
*/
public boolean loadXml(final String xmlPath) {
String versionError = versionCheck(xmlPath, ImportXMLResources.importXMLWizard_title);
if (versionError != null) {
return false;
}
this.xmlPath = xmlPath;
logger.logMessage("Loading xml library ..."); //$NON-NLS-1$
boolean ret = false;
try {
this.xmlLib = new XMLLibrary(null, logger, xmlPath);
this.xmlLib.load();
ret = checkOldPlugins();
} catch (Exception e) {
logger.logError(NLS.bind(
ExportXMLResources.xmlLibrary_error_load_xml, xmlPath), e);
final String errStr = e.toString();
SafeUpdateController.syncExec(new Runnable() {
public void run() {
ImportXMLPlugin.getDefault().getMsgDialog().displayError(
NLS.bind(ExportXMLResources.xmlLibrary_error_load_xml, xmlPath), errStr);
}
});
}
return ret;
}
private boolean checkOldPlugins() {
unlockedPlugins = new ArrayList();
List fileNameToCheck = new ArrayList();
Map map = new HashMap();
Map guidMap = new HashMap();
List basePlugins = LibraryService.getInstance().getCurrentMethodLibrary()
.getMethodPlugins();
for (int i = 0; i < basePlugins.size(); i++) {
org.eclipse.epf.uma.MethodPlugin plugin = (org.eclipse.epf.uma.MethodPlugin) basePlugins.get(i);
map.put(plugin.getName(), plugin);
guidMap.put(plugin.getGuid(), plugin);
}
List plugins = ((MethodLibrary) xmlLib.getRoot()).getMethodPlugin();
List guids = new ArrayList();
for (int i=0; i<plugins.size(); i++) {
MethodElement elem = (MethodElement) plugins.get(i);
guids.add(elem.getId());
org.eclipse.epf.uma.MethodPlugin basePlugin =
(org.eclipse.epf.uma.MethodPlugin) map.get(elem.getName());
boolean toAdd = false;
if (basePlugin != null && ! basePlugin.getGuid().equals(elem.getId())
&& ! basePlugin.getUserChangeable()) {
toAdd = true;
} else {
basePlugin =
(org.eclipse.epf.uma.MethodPlugin) guidMap.get(elem.getId());
if (basePlugin != null /*&& ! basePlugin.getName().equals(elem.getName())*/
&& ! basePlugin.getUserChangeable()) {
toAdd = true;
}
}
if (toAdd) {
unlockedPlugins.add(basePlugin.getGuid());
basePlugin.setUserChangeable(new Boolean(true));
Resource res = basePlugin.eResource();
if (res != null && res.getURI() != null) {
String fileName = res.getURI().toFileString();
fileNameToCheck.add(fileName);
}
}
}
if (fileNameToCheck.size() > 0) {
final List modifiedFiles = fileNameToCheck;
SafeUpdateController.syncExec(new Runnable() {
public void run() {
fileCheckedOutStatus = FileModifyChecker.checkModify(modifiedFiles);
}
});
}
if (! unlockedPlugins.isEmpty() && (fileCheckedOutStatus != null)
&& !fileCheckedOutStatus.isOK()) {
// log error
SafeUpdateController.syncExec(new Runnable() {
public void run() {
String title = ImportXMLResources.importXMLWizard_title;
String msg = ImportXMLResources.importXMLService_import_failed;
new MsgDialog(ImportPlugin.getDefault())
.displayError(title, msg, fileCheckedOutStatus);
}
});
return false;
}
final PluginModifyInfo modifyInfo = SelectImportConfigurationSource
.checkModify(guids, MsgBox.getDefaultShell(), false);
// allow user to proceed with locked plugins
if ( modifyInfo.lockedPlugins.size() > 0 ) {
final boolean ret[] = new boolean[1];
SafeUpdateController.syncExec(new Runnable() {
public void run() {
String WIZARD_TITLE = ImportXMLResources.importXMLWizard_title;
String message = modifyInfo.getLockedMessage().toString() +
ImportResources.ImportPluginWizard_confirm_continue;
ret[0] = ImportXMLPlugin
.getDefault().getMsgDialog().displayConfirmation(WIZARD_TITLE, message);
}
});
return ret[0];
}
return true;
}
/**
* @return the log file.
*/
public File getLogPath() {
return logger.getLogPath();
}
/**
* Dispose
*/
public void dispose() {
discardedElements.clear();
workOrderMap.clear();
logger.dispose();
}
/**
* Does XML export.
* @param monitor
* @throws Exception
*/
public void doImport(IProgressMonitor monitor) throws Exception {
isBaseLibSynFree = MethodLibraryPropUtil.getMethodLibraryPropUtil()
.isSynFree(
LibraryService.getInstance().getCurrentMethodLibrary());
boolean refresh = RefreshJob.getInstance().isEnabled();
try {
if (refresh) {
// disable resource refreshing during import
//
RefreshJob.getInstance().setEnabled(false);
}
handleTypeChanges();
IResourceHandler handler = new ImportResourceHandler(new File(
xmlPath).getParentFile(), new File(LibraryService
.getInstance().getCurrentMethodLibraryLocation()));
ContentProcessor contentProc = new ContentProcessor(handler,
this.logger);
diagramHandler = new DiagramHandler(new File(
xmlPath).getParentFile(), new File(LibraryService
.getInstance().getCurrentMethodLibraryLocation())) {
//[0]: sourceFile
//[1]: targetFile
protected File[] getFiles(org.eclipse.epf.uma.MethodElement elem) {
File[] files = super.getFiles(elem, false);
IModelObject xmlObj = xmlLib.getElement(elem.getGuid());
if (xmlObj instanceof org.eclipse.epf.xml.uma.Process) {
org.eclipse.epf.xml.uma.Process proc =
(org.eclipse.epf.xml.uma.Process) xmlObj;
String uri = proc.getDiagramURI();
if (uri != null && uri.length() > 0) {
File file = new File(getSourceLibRoot(), uri);
//System.out.println("LD: file: " + file);
if (file.exists()) {
files[0] = file;
files[1] = new File(getTargetLibRoot(), uri);
} else {
//System.out.println("LD: files[0]: " + files[0]);
}
}
}
return files;
}
};
this.xmlLib.fixLibraryForImport();
// make sure all the dependent plugins are there
List referencedPlugins = xmlLib.getReferencedPlugins();
if (referencedPlugins.size() > 0) {
org.eclipse.epf.uma.MethodLibrary library = org.eclipse.epf.library.LibraryService
.getInstance().getCurrentMethodLibrary();
if (library != null) {
List plugins = library.getMethodPlugins();
for (Iterator it = plugins.iterator(); it.hasNext();) {
String id = ((org.eclipse.epf.uma.MethodPlugin) it
.next()).getGuid();
referencedPlugins.remove(id);
}
}
}
if (isCheckBasePlugins() && referencedPlugins.size() > 0) {
Map<String, String> map = xmlLib.getGuidToPlugNameMap();
for (Iterator it = referencedPlugins.iterator(); it.hasNext();) {
String nameAndId = ""; //$NON-NLS-1$
String id = (String) it.next();
if (map != null) {
String name = map.get(id);
if (name != null) {
nameAndId += name + ", ";//$NON-NLS-1$
}
}
nameAndId += id;
logger.logError(NLS.bind(ImportXMLResources.importXMLService_missing_plugin, nameAndId),
null);
}
throw new Exception(
ImportXMLResources.importXMLService_error_missing_plugins);
}
this.umaLib = new UmaLibrary(renameElementMap, contentProc, logger, overwrite);
this.umaLib.setMergeLevel(mergeLevel);
IModelObject xmlRoot = this.xmlLib.getRoot();
IModelObject umaRoot = this.umaLib.getRoot();
logger.logMessage("create target library elements ..."); //$NON-NLS-1$
creatEDataObjectTree(xmlRoot, umaRoot);
logger
.logMessage("copying all feature values for target library elements ..."); //$NON-NLS-1$
iteratEDataObject((MethodElement) xmlRoot);
logger.logMessage("fix the target library ..."); //$NON-NLS-1$
umaLib.fixLibrary();
umaLib.fixTaskDescriptors(tdMap);
LibraryImportManager.handleNameReplace(renameElementMap);
diagramHandler.postRegisterElements();
// delete the un-needed elements
logger.logMessage("delete unneeded elements ..."); //$NON-NLS-1$
umaLib.deleteElements();
final List modifiedFiles = FileModifyChecker.getModifiedFiles(LibraryService.getInstance().
getCurrentMethodLibrary().eResource().getResourceSet());
modifiedFiles.addAll(diagramHandler.getModifiedFiles());
final IStatus fileCheckedOutStatus = FileModifyChecker.syncExecCheckModify(modifiedFiles);
if (fileCheckedOutStatus.isOK()) {
logger.logMessage("saving target library ..."); //$NON-NLS-1$
List configs = LibraryService.getInstance()
.getCurrentMethodLibrary().getPredefinedConfigurations();
int configSz = configs == null ? 0 : configs.size();
for (int i=0; i<configSz; i++) {
org.eclipse.epf.uma.MethodConfiguration config =
(org.eclipse.epf.uma.MethodConfiguration ) configs.get(i);
LibraryUtil.validateMethodConfiguration(null, config);
}
if (configSz != 0) {
org.eclipse.epf.uma.MethodLibrary currLib = LibraryService.getInstance().getCurrentMethodLibrary();
ILibraryPersister persister = ((MultiFileResourceSetImpl) currLib.eResource().getResourceSet()).getPersister();
if (persister instanceof IFileBasedLibraryPersister) {
IFileBasedLibraryPersister ip = (IFileBasedLibraryPersister) persister;
File configFolder = ip.getDefaultMethodConfigurationFolder(currLib);
if (configFolder != null) {
ip.setDefaultMethodConfigurationFolder(currLib, configFolder);
} else {
throw new Exception(
ImportXMLResources.importXMLService_import_failed);
}
}
}
// don't refresh the workspace
if (unlockedPlugins != null && ! unlockedPlugins.isEmpty()) {
LibraryImportManager.lockUnlockedPlugins(unlockedPlugins);
}
if (isBaseLibSynFree && !isSynFreeLib()) {
MethodLibraryPropUtil libPropUtil = MethodLibraryPropUtil
.getMethodLibraryPropUtil();
org.eclipse.epf.uma.MethodLibrary lib = LibraryService
.getInstance().getCurrentMethodLibrary();
if (!libPropUtil.isSynFree(lib)) {
libPropUtil.setSynFree(lib, true);
}
MethodPluginPropUtil pluginPropUtil = MethodPluginPropUtil
.getMethodPluginPropUtil();
for (org.eclipse.epf.uma.MethodPlugin p : lib
.getMethodPlugins()) {
if (!pluginPropUtil.isSynFree(p)) {
pluginPropUtil.setSynFree(p, true);
}
}
}
LibraryUtil.saveLibrary(LibraryService.getInstance()
.getCurrentMethodLibrary(), false, false);
diagramHandler.execute();
logger.logMessage("re-open target library ..."); //$NON-NLS-1$
// LibraryService.getInstance().reopenCurrentMethodLibrary();
postImportOperation(monitor);
if (migrator != null) {
org.eclipse.epf.uma.MethodLibrary lib = LibraryService.getInstance().getCurrentMethodLibrary();
migrator.migrateXmlImportedLib(lib, monitor);
LibraryService.getInstance().reopenCurrentMethodLibrary();
}
logger.logMessage("import completed successfully ..."); //$NON-NLS-1$
} else {
SafeUpdateController.syncExec(new Runnable() {
public void run() {
String title = ImportXMLResources.importXMLWizard_title;
String msg = ImportXMLResources.importXMLService_import_failed;
new MsgDialog(ImportXMLPlugin.getDefault())
.displayError(title, msg, fileCheckedOutStatus);
}
});
}
//ResourceUtil.refreshResources(LibraryService.getInstance()
// .getCurrentMethodLibrary(), monitor);
} catch (Exception e) {
logger.logError(NLS.bind(ImportXMLResources.importXMLService_import_failed, e.getMessage()), e);
throw e;
} finally {
if (refresh) {
// re-enable resource refreshing
//
RefreshJob.getInstance().setEnabled(true);
}
}
}
protected void postImportOperation(IProgressMonitor monitor) throws Exception {
// Reopen the library.
LibraryService.getInstance().reopenCurrentMethodLibrary();
}
private void creatEDataObjectTree(IModelObject xmlObj, IModelObject umaObj) {
for (Iterator it = xmlObj.eContents().iterator(); it.hasNext();) {
IModelObject child = (IModelObject) it.next();
createRmcObject(child, umaObj);
}
}
private void createRmcObject(IModelObject xmlElement,
IModelObject targetContainer) {
if (xmlElement instanceof MethodElementProperty) {
return;
}
// get the targetContainer's containing feature
EStructuralFeature feature = xmlElement.eContainmentFeature();
createRmcObject(xmlElement, targetContainer, feature.getName());
}
private void createRmcObject(IModelObject xmlElement,
IModelObject targetContainer, String containmentXmlFeature) {
try {
if (xmlElement == null) {
return;
}
IModelObject umaElement = null;
// don't create content category package since in uma, it's
// seperated based on type
if (xmlElement instanceof MethodPlugin) {
MethodPlugin plugin = (MethodPlugin) xmlElement;
umaElement = umaLib.createMethodPlugin(plugin.getId(), plugin
.getName());
} else if (xmlElement instanceof ContentCategoryPackage) {
// don't create, do nothing
// mark as discarded so we don't need to copy it's attributes
setDiscarded(((ContentCategoryPackage) xmlElement).getId());
} else if ((xmlElement instanceof ContentCategory)
&& !(xmlElement.eContainer() instanceof Domain
|| xmlElement.eContainer() instanceof Discipline)
|| (xmlElement.eContainer() instanceof ContentCategoryPackage)) {
// create the content categories for root content categories,
// not for sub-domain and sub-discipline
// 154143 - import xml did not reserve the sub-discipline structure
String pluginId = getPlugin(xmlElement).getId();
umaElement = umaLib.createContentCategory(pluginId, xmlElement
.eClass().getName(), xmlElement.getType().getName(),
xmlLib.getElementId(xmlElement));
} else {
// if this is root level package, find the corresponding
// container for the UMA object
if (xmlElement instanceof MethodPackage
&& xmlElement.eContainer() instanceof MethodPlugin) {
if (xmlElement instanceof ContentPackage) {
targetContainer = umaLib
.getContentRootPackage(targetContainer);
} else if (xmlElement instanceof ProcessComponent) {
Object proc = ((ProcessComponent) xmlElement)
.getProcess();
if (proc instanceof CapabilityPattern) {
targetContainer = umaLib
.getCapabilityPatternRootPackage(targetContainer);
} else if (proc instanceof DeliveryProcess) {
targetContainer = umaLib
.getDeliveryProcessRootPackage(targetContainer);
}
} else if (xmlElement instanceof ProcessPackage) {
List procs = xmlLib
.getAllProcesses((MethodPackage) xmlElement);
if (procs != null && procs.size() > 0) {
Object proc = procs.get(0);
if (proc instanceof CapabilityPattern) {
targetContainer = umaLib
.getCapabilityPatternRootPackage(targetContainer);
} else if (proc instanceof DeliveryProcess) {
targetContainer = umaLib
.getDeliveryProcessRootPackage(targetContainer);
}
}
}
}
if (targetContainer instanceof org.eclipse.epf.uma.TaskDescriptor &&
containmentXmlFeature.equals("step")) { //$NON-NLS-1$
return;
}
// get the containment feature so we can create the object of
// the same type
umaElement = umaLib.createElement(targetContainer,
containmentXmlFeature, xmlElement.eClass().getName(),
xmlElement.getType().getName(), xmlLib
.getElementId(xmlElement));
if (xmlElement instanceof TaskDescriptor) {
TaskDescriptor td = (TaskDescriptor) xmlElement;
if (td.getTask() != null) {
List steps = td.getStep();
if (steps != null && !steps.isEmpty()) {
if (tdMap == null) {
tdMap = new HashMap<String, TaskDescriptor>();
}
tdMap.put(td.getId(), td);
}
}
}
// xml WorkOrder does not have an id, need to map the uma Object
if (xmlElement instanceof WorkOrder) {
workOrderMap.put(xmlElement, umaElement);
}
}
// recursive,
// note, uma element might be null since we can't determine the
// owner of the element yet
creatEDataObjectTree(xmlElement, umaElement);
} catch (Exception e) {
// log the error and continue???
e.printStackTrace();
}
}
private MethodPlugin getPlugin(EObject element) {
while ((element != null) && !(element instanceof MethodPlugin)) {
element = element.eContainer();
}
return (MethodPlugin) element;
}
private IModelObject getRmcObject(MethodElement xmlObj) {
if (xmlObj instanceof MethodLibrary) {
return umaLib.getRoot();
} else {
String id = xmlObj.getId();
return this.umaLib.getElement(id);
}
}
private void iteratEDataObject(MethodElement srcObj) {
iteratEDataObject_(srcObj);
IModelObject targetObj = getRmcObject(srcObj);
if (targetObj instanceof org.eclipse.epf.uma.MethodElement) {
diagramHandler.registerElement((org.eclipse.epf.uma.MethodElement) targetObj);
}
}
private void iteratEDataObject_(MethodElement srcObj) {
logger
.logMessage(" === processing element " + srcObj.getType().getName() + ": " + srcObj.getName()); //$NON-NLS-1$ //$NON-NLS-2$
if (isProcessed(srcObj.getId())) {
return;
}
setProcessed(srcObj.getId());
// if object is not created, it's xml wrapper package
if (srcObj instanceof ContentCategoryPackage) {
// iterate the child packages
for (Iterator it = ((ContentCategoryPackage) srcObj)
.getContentCategory().iterator(); it.hasNext();) {
iteratEDataObject((MethodElement) it.next());
}
return;
}
IModelObject targetObj = getRmcObject(srcObj);
EClass eClass = srcObj.eClass();
handleDescriptorExtraReferences(srcObj, targetObj);
EList features = eClass.getEAllStructuralFeatures();
boolean isNewElement = umaLib.isNewElement(srcObj.getId()) || srcObj instanceof MethodLibrary;
boolean isOldPlugin = !isNewElement && (srcObj instanceof MethodPlugin);
Set<EStructuralFeature> seenRmcFeatures = new HashSet<EStructuralFeature>();
for (Iterator it = features.iterator(); it.hasNext();) {
EStructuralFeature feature = (EStructuralFeature) it.next();
if (FeatureManager.INSTANCE.isUnneededXmlFeature(feature.getName())) {
continue;
}
if (isOldPlugin && UmaPackage.eINSTANCE.getMethodPlugin_UserChangeable() == feature) {
continue;
}
Object value = srcObj.eGet(feature);
try {
if (value == null) {
umaLib.handleNullXmlValue(srcObj, targetObj, feature.getName());
continue;
}
boolean isMep = feature.getName().equals("methodElementProperty"); //$NON-NLS-1$
if (value instanceof List && ! isMep) {
umaLib.initListValueMerge(srcObj, targetObj, feature.getName(),
(List) value, seenRmcFeatures);
for (Iterator itv = ((List) value).iterator(); itv
.hasNext();) {
Object src_value = itv.next();
if (src_value instanceof String) {
// it's an id reference
umaLib.setReferenceValue(targetObj, feature
.getName(), (String) src_value);
} else if (src_value instanceof MethodElement) {
// set the reference
MethodElement e = (MethodElement) src_value;
String guid = e.getId();
// don't set the containment feature value since
// it's already handled
// when creating the library structure
if (!isDiscarded(guid) && e.eContainer() != srcObj) {
umaLib.setReferenceValue(targetObj, feature
.getName(), guid);
}
iteratEDataObject((MethodElement) src_value);
} else if (src_value instanceof WorkOrder) {
// WorkOrder is not method element and does not have
// an id, need special handling
// set the prede
WorkOrder wr = (WorkOrder) src_value;
Object umaWr = workOrderMap.get(wr);
//umaLib.setWorkOrder(umaWr, wr.getValue());
if (umaWr instanceof org.eclipse.epf.uma.WorkOrder) {
umaLib.handleWorkOrder(wr, (org.eclipse.epf.uma.WorkOrder) umaWr);
}
} else {
logger
.logMessage(NLS.bind(ImportXMLResources.importXMLService_element_not_handled, src_value));
}
}
} else if (feature instanceof EReference && ! isMep) {
// get the xml object and iterate again
Object src_value = value;
if (src_value instanceof WorkOrder) {
logger.logMessage("workorder value"); //$NON-NLS-1$
} else if (src_value instanceof String
&& !isDiscarded((String) src_value)) {
// it's an id reference
umaLib.setReferenceValue(targetObj, feature.getName(),
(String) src_value);
} else if (src_value instanceof MethodElement) {
// set the reference
String guid = ((MethodElement) src_value).getId();
if (guid == null) {
logger
.logWarning(NLS.bind(ImportXMLResources.importXMLService_element_without_id, ((MethodElement) src_value)
.getName()));
}
if (!isDiscarded(guid)) {
umaLib.setReferenceValue(targetObj, feature
.getName(), guid);
}
iteratEDataObject((MethodElement) src_value);
} else {
logger
.logWarning(NLS.bind(ImportXMLResources.importXMLService_element_not_handled, src_value));
}
} else {
if (targetObj instanceof ContentCategoryPackage) {
logger.logMessage("hrre"); //$NON-NLS-1$
}
if (value instanceof WorkOrderType) {
value = ((WorkOrderType) value).getName();
}
boolean rename = false;
if (!isNewElement && feature == org.eclipse.epf.xml.uma.UmaPackage.eINSTANCE.getNamedElement_Name()) {
String oldName = (String)targetObj.eGet(org.eclipse.epf.uma.UmaPackage.eINSTANCE.getNamedElement_Name());
String newName = (String)srcObj.eGet(feature);
if (!newName.equals(oldName)) {
LibraryImportManager.ensureUniqueNameForExistingElement
((org.eclipse.epf.uma.MethodElement) targetObj, oldName, newName, renameElementMap);
rename = true;
}
}
if (!rename) {
umaLib.setAtributeFeatureValue(targetObj,
feature.getName(), value);
}
if (isNewElement && feature == org.eclipse.epf.xml.uma.UmaPackage.eINSTANCE.getNamedElement_Name()) {
org.eclipse.epf.uma.MethodElement elem = (org.eclipse.epf.uma.MethodElement) targetObj;
EObject ceobj = elem.eContainer();
if (ceobj instanceof org.eclipse.epf.uma.MethodElement &&
! umaLib.isNewElement(((org.eclipse.epf.uma.MethodElement) ceobj).getGuid())) {
LibraryImportManager.ensureUniqueName(ceobj, elem, renameElementMap);
}
}
}
} catch (Exception e) {
// log the error and continue???
e.printStackTrace();
}
}
}
// goid of processed element
private List processedElements = new ArrayList();
private boolean isProcessed(String guid) {
return processedElements.contains(guid);
}
private void setProcessed(String guid) {
if (!processedElements.contains(guid)) {
processedElements.add(guid);
}
}
private boolean isDiscarded(String id) {
return discardedElements.contains(id);
}
private void setDiscarded(String id) {
discardedElements.add(id);
}
/**
* Sets overwrite attribute.
* @param b
*/
public void setOverwrite(boolean b) {
overwrite = b;
}
private String versionCheck(final String xmlPath, final String title) {
final String[] ret = new String[1];
ret[0] = null;
SafeUpdateController.syncExec(new Runnable() {
public void run() {
VersionUtil.VersionCheckInfo info = VersionUtil.checkXMLVersion(new File(xmlPath));
if (info == null) {
ret[0] = NLS.bind(ImportXMLResources.versionMismatch_oldData_unknown, new Object[] {
Platform.getProduct().getName()});
} else {
if (info.result < 0) {
try {
migrator = MappingUtil.getMigratorByLibPath(xmlPath);
} catch (Exception e) {
ret[0] = e.toString();
}
if (migrator == null && ret[0] == null) {
if (info.toolID.equals(VersionUtil.getPrimaryToolID())) {
ret[0] = NLS.bind(ImportXMLResources.versionMismatch_oldData, new Object[] {
info.toolVersion, Platform.getProduct().getName()});
} else {
ret[0] = NLS.bind(ImportXMLResources.versionMismatch_oldData_unknown, new Object[] {
Platform.getProduct().getName()});
}
}
} else if (info.result > 0) {
if (info.toolID.equals(VersionUtil.getPrimaryToolID())) {
ret[0] = NLS.bind(ImportXMLResources.versionMismatch_oldTool, new Object[] {
info.toolVersion, Platform.getProduct().getName()});
} else {
ret[0] = NLS.bind(ImportXMLResources.versionMismatch_oldTool_unknown, new Object[] {
Platform.getProduct().getName()});
}
}
}
if (ret[0] != null) {
ImportXMLPlugin.getDefault().getMsgDialog().displayError(title, ret[0]);
}
}
});
return ret[0];
}
public void handleTypeChanges() {
org.eclipse.epf.uma.MethodLibrary baseLib = LibraryService.getInstance()
.getCurrentMethodLibrary();
HashMap baseMap = new HashMap();
ConfigurationImportService.collectPotentialTypeChanged(baseLib, baseMap);
HashMap eClassObjMap = new HashMap();
HashMap importMap = new HashMap();
for (Iterator it = xmlLib.getRoot().eAllContents(); it.hasNext();) {
Object obj = it.next();
if (obj instanceof Guidance ||
obj instanceof Activity) {
MethodElement xmlElement = (MethodElement) obj;
String eClassName = xmlElement.eClass().getName();
Object eClassObj = eClassObjMap.get(eClassName);
if (eClassObj == null) {
EClass objEClass = FeatureManager.INSTANCE.getRmcEClass(eClassName);
if (objEClass != null) {
eClassObj = UmaFactory.eINSTANCE.create(objEClass);
eClassObjMap.put(eClassName, eClassObj);
}
}
if (eClassObj != null) {
importMap.put(xmlElement.getId(), eClassObj);
}
}
}
ConfigurationImportService.handleTypeChanges(baseMap, importMap);
}
private boolean isCheckBasePlugins() {
return checkBasePlugins;
}
public void setCheckBasePlugins(boolean checkBasePlugins) {
this.checkBasePlugins = checkBasePlugins;
}
public void setMergeLevel(int mergeLevel) {
this.mergeLevel = mergeLevel;
}
public boolean isSynFreeLib() {
return xmlLib == null ? false : xmlLib.isSynFreeLib();
}
private void handleDescriptorExtraReferences(MethodElement srcObj,
IModelObject targetObj) {
try {
handleDescriptorExtraReferences_(srcObj, targetObj);
} catch (Exception e) {
logger.logError(e.getMessage(), e);
}
}
private void handleDescriptorExtraReferences_(MethodElement srcObj,
IModelObject targetObj) {
if (!(targetObj instanceof org.eclipse.epf.uma.Descriptor)) {
return;
}
boolean ok = srcObj instanceof org.eclipse.epf.xml.uma.RoleDescriptor
|| srcObj instanceof org.eclipse.epf.xml.uma.WorkProductDescriptor
|| srcObj instanceof org.eclipse.epf.xml.uma.TaskDescriptor;
if (!ok) {
return;
}
org.eclipse.epf.uma.Descriptor tgtDes = (org.eclipse.epf.uma.Descriptor) targetObj;
BreakdownElement srcDes = (BreakdownElement) srcObj;
EList<MethodElementProperty> mepPropList = srcDes.getMethodElementProperty();
if (mepPropList == null || mepPropList.isEmpty()) {
return;
}
for (int i = mepPropList.size() - 1; i >=0; i--) {
MethodElementProperty mep = mepPropList.get(i);
if (mep.getName().startsWith("XML_")) { //$NON-NLS-1$
handleExtraRef(srcDes, tgtDes, mep);
mepPropList.remove(i);
}
}
}
private void handleExtraRef(BreakdownElement srcDes,
org.eclipse.epf.uma.Descriptor tgtDes, MethodElementProperty mep) {
String refName = mep.getName().substring(4);
EStructuralFeature feature = tgtDes.eClass().getEStructuralFeature(
refName);
if (feature instanceof EReference) {
EReference ref = (EReference) feature;
if (ref.isMany()) {
List<org.eclipse.epf.uma.MethodElement> list = (List<org.eclipse.epf.uma.MethodElement>) tgtDes
.eGet(ref);
list.clear();
String[] guidStrList = mep.getValue().split(
DescriptorPropUtil.infoSeperator);
if (guidStrList == null || guidStrList.length == 0) {
return;
}
for (String guid : guidStrList) {
org.eclipse.epf.uma.MethodElement element = (org.eclipse.epf.uma.MethodElement) umaLib
.getElement(guid);
if (element != null) {
list.add(element);
}
}
}
}
}
}