/*
* Copyright 2012 Cisco Systems
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.provisionr.activiti.karaf.commands.handlers;
import java.io.PrintWriter;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.activiti.engine.ActivitiException;
import org.activiti.engine.ProcessEngine;
import org.activiti.engine.history.HistoricActivityInstance;
import org.activiti.engine.history.HistoricDetail;
import org.activiti.engine.history.HistoricProcessInstance;
import org.activiti.engine.history.HistoricVariableUpdate;
import org.apache.provisionr.activiti.karaf.commands.util.Commands;
/**
* Abstract class that provides most of the implementation required to print process variable using
* print handler.
*
* @author Srinivasan Chikkala
* @see DefaultActivitiPrintHandler
*/
public abstract class AbstractActivitiPrintHandler implements ActivitiPrintHandler {
public static final String PROCESS_DEFINITION_PROP = "bpm.process.definition";
public static final String PROCESS_VARS_PROP = "bpm.process.variables";
private static final Logger LOG = Logger.getLogger(AbstractActivitiPrintHandler.class.getName());
private boolean verbose;
private boolean quiet;
private ProcessEngine processEngine;
public boolean isQuiet() {
return quiet;
}
public void setQuiet(boolean quiet) {
this.quiet = quiet;
}
public boolean isVerbose() {
return verbose;
}
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
public ProcessEngine getProcessEngine() {
return processEngine;
}
public void setProcessEngine(ProcessEngine processEngine) {
this.processEngine = processEngine;
}
/**
* Extended class can implement this method to print the variable specific information.
*/
protected abstract void printVariable(PrintWriter out, String varName, Object varValue);
protected void printVariable(PrintWriter out, HistoricVariableUpdate var) {
LinkedHashMap<String, String> nvMap = new LinkedHashMap<String, String>();
if (this.isVerbose()) {
nvMap.put("Variable ID", var.getId());
nvMap.put("Revision", "" + var.getRevision());
nvMap.put("Updated Time", Commands.UTIL.formatDate(var.getTime()));
}
nvMap.put("Variable Name", var.getVariableName());
Object value = var.getValue();
String simpleValue = Commands.UTIL.valueOf(value);
if (simpleValue != null) {
nvMap.put("Value", simpleValue);
} else {
nvMap.put("Value", "");
}
Commands.UTIL.printNameValues(out, nvMap);
if (simpleValue == null) {
// print the value in a json serialization format.
printVariable(out, var.getVariableName(), value);
}
out.println();
}
protected void printVariables(PrintWriter out, Map<String, HistoricVariableUpdate> vars) {
for (HistoricVariableUpdate var : vars.values()) {
printVariable(out, var);
}
}
protected void printVariables(PrintWriter out, List<HistoricDetail> varList) {
Map<String, HistoricVariableUpdate> varMap = new TreeMap<String, HistoricVariableUpdate>();
// filter revisions
for (HistoricDetail detail : varList) {
HistoricVariableUpdate varDetail = (HistoricVariableUpdate) detail;
String varName = varDetail.getVariableName();
// expects the varList is sorted in a descending order of time.
if (!varMap.containsKey(varName)) {
varMap.put(varName, varDetail);
} else {
LOG.info("#### " + varName + " has multiple updates!!! "
+ Commands.UTIL.formatDate(varDetail.getTime()) + " Revision= "
+ varDetail.getRevision());
}
}
printVariables(out, varMap);
}
@Override
public void printInstanceData(PrintWriter out, boolean verbose, boolean quite, HistoricProcessInstance hpi) {
this.setVerbose(verbose);
this.setQuiet(quite);
List<HistoricDetail> varList = null;
try {
varList = this.processEngine.getHistoryService().createHistoricDetailQuery()
.variableUpdates().processInstanceId(hpi.getId()).orderByTime().desc().list();
} catch (ActivitiException ex) {
// silent about the error. and log it.
LOG.log(Level.INFO, "Error in getting process variables. " + ex.getMessage(), ex);
}
if (varList != null && varList.size() > 0) {
out.println("-------- Instance Variables ");
printVariables(out, varList);
} else {
LOG.info("------ No Instance Variables! for " + hpi.getId());
}
}
@Override
public void printActivityData(PrintWriter out, boolean verbose, boolean quite,
HistoricActivityInstance actInst) {
this.setVerbose(verbose);
this.setQuiet(quite);
if (quite) {
// don't print activity variable update per activity
return;
}
List<HistoricDetail> varList = null;
try {
varList = this.processEngine.getHistoryService().createHistoricDetailQuery()
.variableUpdates().activityInstanceId(actInst.getId()).orderByTime().desc().list();
} catch (ActivitiException ex) {
//silent about the error. and log it.
LOG.log(Level.INFO, "Error in getting process variables. " + ex.getMessage(), ex);
}
if (varList != null && varList.size() > 0) {
out.println("-------- Task Variables");
printVariables(out, varList);
} else {
LOG.info("------ No Task Variables! for " + actInst.getActivityId());
}
}
}