package org.jbpm.ui.util;
import java.io.ByteArrayInputStream;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.core.resources.IContainer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.jface.dialogs.IDialogConstants;
import org.eclipse.jface.dialogs.MessageDialog;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.wizard.WizardDialog;
import org.eclipse.swt.widgets.Display;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.ide.IDE;
import org.eclipse.ui.part.FileEditorInput;
import org.jbpm.ui.DesignerLogger;
import org.jbpm.ui.ParContentProvider;
import org.jbpm.ui.PluginConstants;
import org.jbpm.ui.ProcessCache;
import org.jbpm.ui.common.model.ProcessDefinition;
import org.jbpm.ui.dialog.RenameProcessDefinitionDialog;
import org.jbpm.ui.resource.Messages;
import org.jbpm.ui.wizard.CopyProcessDefinitionWizard;
import org.jbpm.ui.wizard.ExportParWizard;
import org.jbpm.ui.wizard.ImportParWizard;
import org.jbpm.ui.wizard.NewProcessDefinitionWizard;
import org.jbpm.ui.wizard.NewProcessProjectWizard;
import org.w3c.dom.Document;
public class WorkspaceOperations {
public static void deleteResources(List<IResource> resources) {
List<IFile> deletedDefinitions = new ArrayList<IFile>();
for (IResource resource : resources) {
try {
resource.refreshLocal(IResource.DEPTH_INFINITE, null);
boolean processFolder = (resource instanceof IProject);
String message = Messages.getString(processFolder ? "Delete.project.message" : "Delete.process.message");
if (MessageDialog.openConfirm(
Display.getCurrent().getActiveShell(),
Messages.getString("message.confirm.operation"),
MessageFormat.format(message, resource.getName()))) {
List<IFile> tmpFiles = new ArrayList<IFile>();
if (processFolder) {
for (IFile definitionFile : ProjectFinder.getProcessDefinitionFiles((IProject) resource)) {
tmpFiles.add(definitionFile);
}
} else {
tmpFiles.add(ProjectFinder.getProcessDefinitionFile((IFolder) resource));
}
resource.delete(true, null);
deletedDefinitions.addAll(tmpFiles);
}
} catch (CoreException e) {
DesignerLogger.logError("Error deleting", e);
}
}
for (IFile definitionFile : deletedDefinitions) {
ProcessCache.processDefinitionWasDeleted(definitionFile);
}
}
public static void refreshResources(List<IResource> resources) {
for (IResource resource : resources) {
try {
resource.refreshLocal(IResource.DEPTH_INFINITE, null);
setUtfCharsetRecursively(resource);
} catch (CoreException e) {
DesignerLogger.logError("Unable to refresh resource", e);
}
}
}
private static void setUtfCharsetRecursively(IResource resource) throws CoreException {
if (resource instanceof IFile) {
IFile file = (IFile) resource;
if (!PluginConstants.UTF_ENCODING.equalsIgnoreCase(file.getCharset())) {
file.setCharset(PluginConstants.UTF_ENCODING, null);
}
}
if (resource instanceof IContainer) {
for (IResource member : ((IContainer) resource).members()) {
setUtfCharsetRecursively(member);
}
}
}
public static void createNewProject() {
NewProcessProjectWizard wizard = new NewProcessProjectWizard();
wizard.init(PlatformUI.getWorkbench(), null);
WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard);
dialog.open();
}
public static void createNewProcessDefinition(IStructuredSelection selection) {
NewProcessDefinitionWizard wizard = new NewProcessDefinitionWizard();
wizard.init(PlatformUI.getWorkbench(), (IStructuredSelection) selection);
WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard);
dialog.open();
}
public static void copyProcessDefinition(IStructuredSelection selection) {
IFolder processDefinitionFolder = (IFolder) selection.getFirstElement();
IDE.saveAllEditors(new IResource[]{ processDefinitionFolder }, true);
CopyProcessDefinitionWizard wizard = new CopyProcessDefinitionWizard();
wizard.init(PlatformUI.getWorkbench(), (IStructuredSelection) selection);
WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard);
dialog.open();
}
public static void renameProcessDefinition(IStructuredSelection selection) {
IFolder definitionFolder = (IFolder) selection.getFirstElement();
IFile definitionFile = ProjectFinder.getProcessDefinitionFile(definitionFolder);
RenameProcessDefinitionDialog dialog = new RenameProcessDefinitionDialog(definitionFolder);
ProcessDefinition definition = ProcessCache.getProcessDefinition(definitionFile);
dialog.setName(definition.getName());
if(dialog.open() == IDialogConstants.OK_ID) {
String newName = dialog.getName();
try {
IWorkbenchPage page = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();
IEditorPart editor = page.findEditor(new FileEditorInput(definitionFile));
if (editor != null) {
page.closeEditor(editor, false);
}
IPath oldPath = definitionFolder.getFullPath();
IPath newPath = definitionFolder.getParent().getFolder(new Path(newName)).getFullPath();
definitionFolder.copy(newPath, true, null);
ProcessCache.processDefinitionWasDeleted(definitionFile);
definitionFolder = ResourcesPlugin.getWorkspace().getRoot().getFolder(newPath);
IFile newDefinitionFile = ProjectFinder.getProcessDefinitionFile(definitionFolder);
definition.setName(newName);
saveProcessDefinition(newDefinitionFile, definition);
ProcessCache.newProcessDefinitionWasCreated(newDefinitionFile);
ResourcesPlugin.getWorkspace().getRoot().getFolder(oldPath).delete(true, null);
} catch (Exception e) {
DesignerLogger.logError(e);
}
}
}
// TODO Unify save and create definition operation
public static void saveProcessDefinition(IFile definitionFile, ProcessDefinition definition) throws Exception {
Document document = XmlUtil.parseDocument(definitionFile.getContents());
definition.getContentProvider().saveToXML(definition, document);
byte[] bytes = XmlUtil.writeXml(document);
ParContentProvider.saveAuxInfo(definitionFile, definition);
definitionFile.setContents(new ByteArrayInputStream(bytes), true, true, null);
}
public static void openProcessDefinition(IFolder definitionFolder) {
try {
IFile definitionFile = ProjectFinder.getProcessDefinitionFile(definitionFolder);
IDE.openEditor(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage(), definitionFile, true);
} catch (PartInitException e) {
DesignerLogger.logError("Unable open diagram", e);
}
}
public static void exportProcessDefinition(IStructuredSelection selection) {
ExportParWizard wizard = new ExportParWizard();
wizard.init(PlatformUI.getWorkbench(), selection);
WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard);
dialog.open();
}
public static void importProcessDefinition(IStructuredSelection selection) {
ImportParWizard wizard = new ImportParWizard();
wizard.init(PlatformUI.getWorkbench(), selection);
WizardDialog dialog = new WizardDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(), wizard);
dialog.open();
}
}