/*
* (c) Copyright 2010-2011 AgileBirds
*
* This file is part of OpenFlexo.
*
* OpenFlexo is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* OpenFlexo is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with OpenFlexo. If not, see <http://www.gnu.org/licenses/>.
*
*/
package org.openflexo.foundation.imported.action;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.openflexo.foundation.FlexoEditor;
import org.openflexo.foundation.FlexoException;
import org.openflexo.foundation.FlexoModelObject;
import org.openflexo.foundation.action.FlexoAction;
import org.openflexo.foundation.action.FlexoActionType;
import org.openflexo.foundation.imported.dm.ProcessAlreadyImportedException;
import org.openflexo.foundation.wkf.FlexoImportedProcessLibrary;
import org.openflexo.foundation.wkf.FlexoProcess;
import org.openflexo.foundation.wkf.FlexoWorkflow;
import org.openflexo.foundation.wkf.InvalidParentProcessException;
import org.openflexo.foundation.wkf.InvalidProcessReferencesException;
import org.openflexo.localization.FlexoLocalization;
import org.openflexo.logging.FlexoLogger;
import org.openflexo.ws.client.PPMWebService.PPMProcess;
public class ImportProcessesAction extends FlexoAction<ImportProcessesAction, FlexoModelObject, FlexoModelObject> {
private static final Logger logger = FlexoLogger.getLogger(ImportProcessesAction.class.getPackage().getName());
public static final FlexoActionType<ImportProcessesAction, FlexoModelObject, FlexoModelObject> actionType = new FlexoActionType<ImportProcessesAction, FlexoModelObject, FlexoModelObject>(
"import_processes", FlexoActionType.defaultGroup, FlexoActionType.importMenu, FlexoActionType.ADD_ACTION_TYPE) {
@Override
public ImportProcessesAction makeNewAction(FlexoModelObject focusedObject, Vector<FlexoModelObject> globalSelection,
FlexoEditor editor) {
return new ImportProcessesAction(focusedObject, globalSelection, editor);
}
@Override
public boolean isVisibleForSelection(FlexoModelObject object, Vector<FlexoModelObject> globalSelection) {
return false;
}
@Override
public boolean isEnabledForSelection(FlexoModelObject object, Vector<FlexoModelObject> globalSelection) {
return false;
}
};
static {
FlexoModelObject.addActionForClass(actionType, FlexoWorkflow.class);
FlexoModelObject.addActionForClass(actionType, FlexoProcess.class);
FlexoModelObject.addActionForClass(actionType, FlexoImportedProcessLibrary.class);
}
private Vector<PPMProcess> processesToImport;
private ProcessImportReport importReport;
public Vector<PPMProcess> getProcessesToImport() {
return processesToImport;
}
public void setProcessesToImport(Vector<PPMProcess> processesToImport) {
this.processesToImport = processesToImport;
}
protected ImportProcessesAction(FlexoModelObject focusedObject, Vector<FlexoModelObject> globalSelection, FlexoEditor editor) {
super(actionType, focusedObject, globalSelection, editor);
}
@Override
protected void doAction(Object context) throws FlexoException {
FlexoWorkflow lib = getEditor().getProject().getFlexoWorkflow();
importReport = new ProcessImportReport();
for (PPMProcess p : getProcessesToImport()) {
if (!isValid(p) || p.getParentProcess() != null) {
importReport.addToInvalidProcesses(p);
} else {
try {
FlexoProcess fip = lib.importProcess(p);
importReport.addToProperlyImportedProcesses(p, fip);
} catch (ProcessAlreadyImportedException e) {
importReport.addToAlreadyImportedProcesses(p);
if (logger.isLoggable(Level.FINE)) {
logger.log(Level.FINE, "Process " + p.getName() + " was already imported", e);
}
} catch (InvalidParentProcessException e) {
if (logger.isLoggable(Level.WARNING)) {
logger.warning("This should not happen for imported processes!");
}
} catch (InvalidProcessReferencesException e) {
if (logger.isLoggable(Level.WARNING)) {
logger.warning("This case is not handled yet for imported processes!");
}
}
}
}
}
private boolean isValid(PPMProcess p) {
return p.getUri() != null && p.getVersionUri() != null;
}
public ProcessImportReport getImportReport() {
return importReport;
}
public static class ProcessImportReport {
private LinkedHashMap<PPMProcess, FlexoProcess> properlyImported;
private Vector<PPMProcess> invalidProcesses;
private Vector<PPMProcess> alreadyImportedProcesses;
public ProcessImportReport() {
properlyImported = new LinkedHashMap<PPMProcess, FlexoProcess>();
invalidProcesses = new Vector<PPMProcess>();
alreadyImportedProcesses = new Vector<PPMProcess>();
}
public LinkedHashMap<PPMProcess, FlexoProcess> getProperlyImported() {
return properlyImported;
}
public void setProperlyImported(LinkedHashMap<PPMProcess, FlexoProcess> properlyImported) {
this.properlyImported = properlyImported;
}
public void addToProperlyImportedProcesses(PPMProcess processToImport, FlexoProcess matchingImportedProcess) {
properlyImported.put(processToImport, matchingImportedProcess);
}
public Vector<PPMProcess> getInvalidProcesses() {
return invalidProcesses;
}
public void setInvalidProcesses(Vector<PPMProcess> invalidProcess) {
this.invalidProcesses = invalidProcess;
}
public void addToInvalidProcesses(PPMProcess process) {
invalidProcesses.add(process);
}
public Vector<PPMProcess> getAlreadyImportedProcesses() {
return alreadyImportedProcesses;
}
public void setAlreadyImportedProcesses(Vector<PPMProcess> invalidProcess) {
this.alreadyImportedProcesses = invalidProcess;
}
public void addToAlreadyImportedProcesses(PPMProcess process) {
alreadyImportedProcesses.add(process);
}
@Override
public String toString() {
StringBuilder sb = new StringBuilder();
// 1. Properly imported
Iterator<PPMProcess> i = getProperlyImported().keySet().iterator();
append(sb, i, FlexoLocalization.localizedForKey("the_following_processes_have_been_properly_imported"));
// 2. Invalid roles
i = getInvalidProcesses().iterator();
append(sb, i, FlexoLocalization.localizedForKey("the_following_processes_were_not_valid"));
// 3. Already imported
i = getAlreadyImportedProcesses().iterator();
append(sb, i, FlexoLocalization.localizedForKey("the_following_processes_were_already_imported"));
if (sb.length() == 0) {
return FlexoLocalization.localizedForKey("nothing_has_been_imported");
} else {
sb.append("</html>");
}
return sb.toString();
}
private void append(StringBuilder sb, Iterator<PPMProcess> i, String title) {
if (sb.length() == 0) {
sb.append("<html>");
}
boolean needsClosingUl = false;
if (i.hasNext()) {
sb.append(title).append(':').append("<ul>");
needsClosingUl = true;
}
while (i.hasNext()) {
PPMProcess p = i.next();
sb.append("<li>").append(p.getName()).append("</li>");
}
if (needsClosingUl) {
sb.append("</ul>");
needsClosingUl = false;
}
}
}
}