package de.dwpbank.eclipse.usecase.wizards;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.InvocationTargetException;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.IWorkspaceRoot;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status;
import org.eclipse.jdt.core.IPackageFragment;
import org.eclipse.jdt.core.IPackageFragmentRoot;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.operation.IRunnableWithProgress;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.Wizard;
import org.eclipse.ui.INewWizard;
import org.eclipse.ui.IWorkbench;
import org.eclipse.ui.IWorkbenchWizard;
/**
* This is a sample new wizard. Its role is to create a new file
* resource in the provided container. If the container resource
* (a folder or a project) is selected in the workspace
* when the wizard is opened, it will accept it as the target
* container. The wizard creates one file with the extension
* "jar". If a sample multi-page editor (also available
* as a template) is registered for the same extension, it will
* be able to open it.
*/
public class NewUsecaseWizard extends Wizard implements INewWizard {
private NewUsecaseWizardPage page;
private ISelection selection;
/**
* Constructor for NewWizard.
*/
public NewUsecaseWizard() {
super();
setNeedsProgressMonitor(true);
}
/**
* Adding the page to the wizard.
*/
public void addPages() {
page = new NewUsecaseWizardPage(selection);
addPage(page);
page.createControl(null);
}
/**
* This method is called when 'Finish' button is pressed in
* the wizard. We will create an operation and run it
* using wizard as execution context.
*/
public boolean performFinish() {
final String sourceFolder = page.getSourceFolder();
final String usecaseName = page.getUsecaseName();
final String packageName = page.getPackageName();
final IPackageFragmentRoot proot = page.getPackageFragmentRoot();
IRunnableWithProgress op = new IRunnableWithProgress() {
public void run(IProgressMonitor monitor) throws InvocationTargetException {
try {
doFinish(sourceFolder, usecaseName, packageName, proot, monitor);
} catch (CoreException e) {
throw new InvocationTargetException(e);
} catch (Throwable t){
t.printStackTrace();
}
finally {
monitor.done();
}
}
};
try {
getContainer().run(true, false, op);
} catch (InterruptedException e) {
return false;
} catch (InvocationTargetException e) {
Throwable realException = e.getTargetException();
MessageDialog.openError(getShell(), "Error", realException.getMessage());
return false;
}
return true;
}
/**
* The worker method. It will find the container, create the
* file if missing or just replace its contents, and open
* the editor on the newly created file.
*/
private void doFinish(
String sourceFolder,
String usecaseName,
String packageName,
IPackageFragmentRoot proot,
IProgressMonitor monitor)
throws CoreException {
//variablen
IPackageFragment packageFragment = null;
// get Project information
IWorkspaceRoot root = ResourcesPlugin.getWorkspace().getRoot();
IResource res = root.findMember(new Path(sourceFolder));
if (!(proot.isOpen())){
proot.open(monitor);
}
// create UsecasePackage
System.out.println("------Creating Packages-------");
String packName= packageName + "." + usecaseName;
packageFragment = createPackage(proot, packName, monitor);
// create bom Package
packName= packageName + "." + usecaseName + ".bom";
createPackage(proot, packName, monitor);
// create Pages Package
packName = packageName + "." + usecaseName + ".pages";
createPackage(proot, packName, monitor);
// create Process Package
packName = packageName + "." + usecaseName + ".process";
createPackage(proot, packName, monitor);
// create dakarconf file
monitor.beginTask("Creating dakarconf", 2);
if (!res.exists() || !(res instanceof IContainer)) {
throwCoreException("Container \"" + sourceFolder + "\" does not exist.");
}
final IFile file = root.getFileForLocation(new Path(root.getLocation().toString() + packageFragment.getPath() + "/usecase.dakarconf"));
try {
InputStream stream = openContentStream(usecaseName);
if (file.exists()) {
file.setContents(stream, true, true, monitor);
} else {
file.create(stream, true, monitor);
}
stream.close();
} catch (IOException e) {
}
monitor.worked(1);
}
/**
* We will initialize file contents with a sample text.
*/
private InputStream openContentStream(String usecaseName) {
String contents =
//TODO Inhalt der DakarConf einfügen
"<?xml version=\"1.0\" encoding=\"UTF-8\"?> \n" +
"<Usecases xmlns:xsi=\"\" xsi:noNamespaceSchemaLocation=\"\"> \n" +
"\t <Usecase name=\"" + usecaseName + "\"> \n" +
"\t </Usecase> \n" +
"</Usecases>";
return new ByteArrayInputStream(contents.getBytes());
}
private void throwCoreException(String message) throws CoreException {
IStatus status =
new Status(IStatus.ERROR, "de.dwpbank.eclipse.usecase", IStatus.OK, message, null);
throw new CoreException(status);
}
/**
* We will accept the selection in the workbench to see if
* we can initialize from it.
* @see IWorkbenchWizard#init(IWorkbench, IStructuredSelection)
*/
public void init(IWorkbench workbench, IStructuredSelection selection) {
this.selection = selection;
}
private IPackageFragment createPackage(IPackageFragmentRoot parameterRoot, String parameterPackageName, IProgressMonitor m) throws CoreException{
IPackageFragment packageFragment = null;
try {
m.beginTask("Creating " + parameterPackageName + " Package", 1);
packageFragment = parameterRoot.createPackageFragment(parameterPackageName, true, m);
m.worked(1);
} catch (JavaModelException e){
throwCoreException(e);
}
return packageFragment;
}
private void throwCoreException(Exception e) throws CoreException {
IStatus status =
new Status(IStatus.ERROR, "de.dwpbank.eclipse.usecase", IStatus.OK, e.getMessage(), e);
throw new CoreException(status);
}
}
