//------------------------------------------------------------------------------
// 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.tests;
import java.io.File;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epf.common.utils.FileUtil;
import org.eclipse.epf.dataexchange.importing.LibraryService;
import org.eclipse.epf.dataexchange.importing.PluginService;
import org.eclipse.epf.library.LibraryServiceException;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Artifact;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.Checklist;
import org.eclipse.epf.uma.ContentDescription;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.Discipline;
import org.eclipse.epf.uma.Domain;
import org.eclipse.epf.uma.Guidance;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.Role;
import org.eclipse.epf.uma.RoleSet;
import org.eclipse.epf.uma.Section;
import org.eclipse.epf.uma.SupportingMaterial;
import org.eclipse.epf.uma.Task;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.VariabilityType;
import org.eclipse.epf.uma.WorkProductType;
import com.ibm.icu.util.Calendar;
/**
* Helper class to manipulate a test method library.
*
* @author Jinhua Xi
* @since 1.0
*/
public class LibraryTestHelper {
public static final String TEMP_TEST_DIR = System.getProperty("user.home") + File.separator //$NON-NLS-2$
+ "EPF" + File.separator + "test" + File.separator; //$NON-NLS-1$ //$NON-NLS-2$
private static final String LIBRARY_XMI = "library.xmi"; //$NON-NLS-1$
private static final String XMI_TYPE = "xmi"; //$NON-NLS-1$
/**
* Creates a new test method library.
*/
public static MethodLibrary createTestMethodLibrary()
throws LibraryServiceException {
String path = TEMP_TEST_DIR
+ Long.toHexString(Calendar.getInstance().getTimeInMillis())
+ File.separator;
org.eclipse.epf.library.LibraryService.getInstance()
.closeCurrentMethodLibrary();
Map params = new HashMap();
params.put("library.path", path); //$NON-NLS-1$
return org.eclipse.epf.library.LibraryService.getInstance()
.createMethodLibrary(LIBRARY_XMI, XMI_TYPE, params);
}
public static String generateTempLibraryPath() {
String path = TEMP_TEST_DIR
+ Long.toHexString(Calendar.getInstance().getTimeInMillis());
return path;
}
/**
* Creates a test method library on a given path.
*/
public static MethodLibrary createTestMethodLibrary(String path)
throws LibraryServiceException {
if (path == null) {
path = TEMP_TEST_DIR
+ Long
.toHexString(Calendar.getInstance()
.getTimeInMillis()) + File.separator;
}
// If the library path already exists, delete it.
File libraryPath = new File(path);
if (libraryPath.exists()) {
FileUtil.deleteAllFiles(libraryPath.getAbsolutePath());
libraryPath.delete();
}
org.eclipse.epf.library.LibraryService.getInstance()
.closeCurrentMethodLibrary();
Map params = new HashMap();
params.put("library.path", path); //$NON-NLS-1$
return org.eclipse.epf.library.LibraryService.getInstance()
.createMethodLibrary(LIBRARY_XMI, XMI_TYPE, params);
}
/**
* Closes the current method library and delete the library resource files.
*/
public static void closeLibrary(boolean removeLibFiles) {
try {
File path = new File(org.eclipse.epf.library.LibraryService
.getInstance().getCurrentMethodLibraryLocation());
org.eclipse.epf.library.LibraryService.getInstance()
.closeCurrentMethodLibrary();
// Delete the library folder and files.
if (removeLibFiles) {
FileUtil.deleteAllFiles(path.getAbsolutePath());
path.delete();
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void closeLibrary() {
closeLibrary(true);
}
public static void saveLibrary() {
try {
org.eclipse.epf.library.LibraryService.getInstance()
.saveCurrentMethodLibrary();
} catch (LibraryServiceException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static MethodConfiguration createConfiguration(String name) {
return LibraryService.INSTANCE.createConfiguration(name, EcoreUtil
.generateUUID());
}
public static MethodPlugin createMethodPlugin(String name) {
try {
return LibraryService.INSTANCE.createPlugin(name, EcoreUtil
.generateUUID());
} catch (Exception ex) {
ex.printStackTrace();
}
return null;
}
public static Discipline createDiscipline(MethodPlugin plugin, String name) {
Discipline element = LibraryService.INSTANCE
.createPluginService(plugin).createDiscipline();
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static RoleSet createRoleSet(MethodPlugin plugin, String name) {
RoleSet element = LibraryService.INSTANCE.createPluginService(plugin)
.createRoleSet();
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Domain createDomain(MethodPlugin plugin, String name) {
Domain element = LibraryService.INSTANCE.createPluginService(plugin)
.createDomain();
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static WorkProductType createWorkProductType(MethodPlugin plugin,
String name) {
WorkProductType element = LibraryService.INSTANCE.createPluginService(
plugin).createWorkProductType();
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static CustomCategory createCustomCategory(MethodPlugin plugin,
CustomCategory parent, String name) {
CustomCategory element = LibraryService.INSTANCE.createPluginService(
plugin).createCustomCategory(parent);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static ContentPackage createContentPackage(String name) {
return createContentPackage(null, name);
}
public static ContentPackage createContentPackage(MethodPlugin plugin,
String name) {
if (plugin == null) {
plugin = createMethodPlugin("test plugin");
}
ContentPackage element = LibraryService.INSTANCE.createPluginService(
plugin).createContentPackage(null);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Task createTask(ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
Task element = LibraryService.INSTANCE.createPluginService(plugin)
.createTask(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Role createRole(ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
Role element = LibraryService.INSTANCE.createPluginService(plugin)
.createRole(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Artifact createArtifact(ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
Artifact element = LibraryService.INSTANCE.createPluginService(plugin)
.createArtifact(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Guidance createGuidance(ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
Guidance element = LibraryService.INSTANCE.createPluginService(plugin)
.createGuidance(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Checklist createChecklist(ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
Checklist element = LibraryService.INSTANCE.createPluginService(plugin)
.createChecklist(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static SupportingMaterial createSupportingMaterial(
ContentPackage pkg, String name) {
MethodPlugin plugin = LibraryUtil.getMethodPlugin(pkg);
SupportingMaterial element = LibraryService.INSTANCE
.createPluginService(plugin).createSupportingMaterial(pkg);
element.setName(name);
element.setGuid(EcoreUtil.generateUUID());
return element;
}
public static Section createSection(ContentDescription desc, String name,
String content) {
Section e = UmaFactory.eINSTANCE.createSection();
e.setSectionName(name);
e.setSectionDescription(content);
e.setGuid(EcoreUtil.generateUUID());
desc.getSections().add(e);
return e;
}
public static CapabilityPattern createCapabilityPattern(
MethodPlugin plugin, String name, MethodConfiguration defaultConfig) {
CapabilityPattern cp = LibraryService.INSTANCE.createPluginService(
plugin).createCapabilityPattern(defaultConfig);
cp.setName(name);
((ProcessComponent) cp.eContainer()).setName(name);
saveLibrary();
return cp;
}
public static Activity createActivity(MethodPlugin plugin,
Activity superActivity, String name, Task[] tasks) {
PluginService svc = LibraryService.INSTANCE.createPluginService(plugin);
Activity act = svc.createActivity(superActivity);
act.setName(name);
saveLibrary();
if (tasks != null && tasks.length > 0) {
for (int i = 0; i < tasks.length; i++) {
svc.addTaskToActivity(act, tasks[i]);
}
saveLibrary();
}
return act;
}
public static void setExtends(VariabilityElement element,
VariabilityElement base) {
element.setVariabilityBasedOnElement(base);
element.setVariabilityType(VariabilityType.EXTENDS);
}
public static void setContributes(VariabilityElement element,
VariabilityElement base) {
element.setVariabilityBasedOnElement(base);
element.setVariabilityType(VariabilityType.CONTRIBUTES);
}
public static void setReplaces(VariabilityElement element,
VariabilityElement base) {
element.setVariabilityBasedOnElement(base);
element.setVariabilityType(VariabilityType.REPLACES);
}
}