264 lines
9.8 KiB
Plaintext
Executable File
264 lines
9.8 KiB
Plaintext
Executable File
package com.fp.bpmlib.flow;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Map.Entry;
|
|
|
|
import javax.naming.InitialContext;
|
|
import javax.persistence.EntityManager;
|
|
import javax.persistence.EntityManagerFactory;
|
|
import javax.persistence.NoResultException;
|
|
import javax.persistence.Query;
|
|
|
|
import org.drools.core.common.InternalKnowledgeRuntime;
|
|
import org.drools.core.impl.InternalKnowledgeBase;
|
|
import org.drools.core.impl.StatefulKnowledgeSessionImpl;
|
|
import org.jbpm.ruleflow.instance.RuleFlowProcessInstance;
|
|
import org.jbpm.services.task.audit.impl.model.AuditTaskImpl;
|
|
import org.jbpm.services.task.audit.impl.model.BAMTaskSummaryImpl;
|
|
import org.jbpm.workflow.instance.node.HumanTaskNodeInstance;
|
|
import org.jbpm.workflow.instance.node.SubProcessNodeInstance;
|
|
import org.kie.api.definition.process.Node;
|
|
import org.kie.api.runtime.KieSession;
|
|
import org.kie.api.runtime.manager.RuntimeEngine;
|
|
import org.kie.api.runtime.manager.RuntimeManager;
|
|
import org.kie.api.runtime.process.NodeInstance;
|
|
import org.kie.api.runtime.process.ProcessInstance;
|
|
import org.kie.api.task.TaskService;
|
|
import org.kie.api.task.model.Task;
|
|
import org.kie.internal.runtime.manager.context.ProcessInstanceIdContext;
|
|
|
|
import com.fp.bpmlib.ProcessUtil;
|
|
import com.fp.bpmlib.ejb.local.JbpmBeanLocal;
|
|
import com.fp.bpmlib.task.client.HumanTaskClient;
|
|
import com.fp.simple.dto.TaskInfo;
|
|
import com.fp.simple.dto.metadata.ProcessInstanceMeta;
|
|
|
|
public class Monitor {
|
|
|
|
private KieSession kiesession;
|
|
|
|
private ProcessInstance processInstance = null;
|
|
|
|
private TaskService taskService;
|
|
|
|
private RuntimeManager runtimeManager;
|
|
|
|
private RuntimeEngine runtimeEngine;
|
|
|
|
private EntityManagerFactory emf;
|
|
|
|
/**
|
|
* Crea una instancia de flujo.
|
|
*/
|
|
public Monitor(Long processid) throws Exception {
|
|
JbpmBeanLocal local = (JbpmBeanLocal) new InitialContext().lookup("java:global/maiaear-2.1/bpmlib/jbpmbean");
|
|
runtimeManager = local.getRuntimeManager();
|
|
emf = local.getEmf();
|
|
runtimeEngine = runtimeManager.getRuntimeEngine(ProcessInstanceIdContext.get(processid));
|
|
taskService = runtimeEngine.getTaskService();
|
|
kiesession = runtimeEngine.getKieSession();
|
|
processInstance = kiesession.getProcessInstance(processid);
|
|
}
|
|
|
|
/**
|
|
* Cierra la session de trabajo.
|
|
*/
|
|
public void close() {
|
|
// no cerrar la session, esta se cierra en el commit trabaja con JTA.
|
|
}
|
|
|
|
public KieSession getKiesession() {
|
|
return kiesession;
|
|
}
|
|
|
|
public TaskService getTaskService() {
|
|
return taskService;
|
|
}
|
|
|
|
public ProcessInstance getProcessInstance() {
|
|
return processInstance;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de variable.
|
|
*
|
|
* @param pName Nombre de la varibale a buscar en una instancia de proceso.
|
|
* @return Valor de variable
|
|
* @throws Exception la exception
|
|
*/
|
|
public Object getVariable(String pName) throws Exception {
|
|
RuleFlowProcessInstance rfpi = (RuleFlowProcessInstance) this.processInstance;
|
|
return rfpi.getVariable(pName);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de status.
|
|
*
|
|
* @param pVariables the variables
|
|
* @return Valor de status
|
|
* @throws Exception la exception
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public List<ProcessInstanceMeta> getStatus() throws Exception {
|
|
List<ProcessInstanceMeta> data = new ArrayList<ProcessInstanceMeta>();
|
|
if (this.processInstance == null) {
|
|
return data;
|
|
}
|
|
|
|
RuleFlowProcessInstance rfpi = (RuleFlowProcessInstance) this.processInstance;
|
|
InternalKnowledgeRuntime internal = rfpi.getKnowledgeRuntime();
|
|
if (internal == null) {
|
|
internal = new StatefulKnowledgeSessionImpl(1, (InternalKnowledgeBase) this.kiesession.getKieBase());
|
|
rfpi.setKnowledgeRuntime(internal);
|
|
}
|
|
Collection<NodeInstance> nl = rfpi.getNodeInstances();
|
|
|
|
for (NodeInstance ni : nl) {
|
|
ProcessInstanceMeta pim = new ProcessInstanceMeta(this.processInstance.getId());
|
|
data.add(pim);
|
|
Map<String, Object> m = ni.getNode().getMetaData();
|
|
pim.setH(Integer.valueOf("" + m.get("height")));
|
|
pim.setW(Integer.valueOf("" + m.get("width")));
|
|
pim.setX(Integer.valueOf("" + m.get("x")));
|
|
pim.setY(Integer.valueOf("" + m.get("y")));
|
|
pim.setName(processInstance.getProcessName());
|
|
pim.setVersion(processInstance.getProcess().getVersion());
|
|
pim.setActivity(ni.getNodeName());
|
|
pim.setPmetaid(ni.getNodeId());
|
|
Map<String, Object> var = pim.getVariables();
|
|
Object tasks = this.getVariable(ProcessUtil.TASKS_METADATA);
|
|
boolean req = true;
|
|
if (tasks != null) {
|
|
var.put(ProcessUtil.TASKS_METADATA, this.manageTasksMetaData((Map<String, Object>) tasks));
|
|
req = false;
|
|
}
|
|
if (req) {
|
|
tasks = this.getVariable(ProcessUtil.ACTUAL_TASK);
|
|
if (tasks != null) {
|
|
var.put(ProcessUtil.ACTUAL_TASK, tasks);
|
|
}
|
|
}
|
|
this.manageNode(pim, ni);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Manage node.
|
|
*
|
|
* @param pim the pim
|
|
* @param ni the ni
|
|
* @param pVariables the variables
|
|
* @throws Exception la exception
|
|
*/
|
|
private void manageNode(ProcessInstanceMeta pim, NodeInstance ni) throws Exception {
|
|
if (ni instanceof HumanTaskNodeInstance) {
|
|
HumanTaskNodeInstance sub = (HumanTaskNodeInstance) ni;
|
|
pim.setWorkItem(sub.getWorkItemId());
|
|
Task t = this.taskService.getTaskByWorkItemId(pim.getWorkItem());
|
|
// getDocumentContentId es el contenido de entrada de la tarea.
|
|
Map<String, Object> input = HumanTaskClient.getContenido(taskService.getContentById(t.getTaskData().getDocumentContentId()));
|
|
TaskInfo info = (TaskInfo) input.get("taskMetaData");
|
|
info.getAditionalData().put("workItem", sub.getWorkItemId());
|
|
pim.addAddtionalInfo("taskMetaData", info);
|
|
return;
|
|
}
|
|
if (ni instanceof SubProcessNodeInstance) {
|
|
SubProcessNodeInstance sub = (SubProcessNodeInstance) ni;
|
|
Monitor subflujo = new Monitor(sub.getProcessInstanceId());
|
|
for (ProcessInstanceMeta pi : subflujo.getStatus()) {
|
|
pim.addSubProcess(pi);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Manage tasks meta data.
|
|
*
|
|
* @param pTasksMetaData the tasks meta data
|
|
* @return map
|
|
* @throws Exception la exception
|
|
*/
|
|
private Map<String, Object> manageTasksMetaData(Map<String, Object> pTasksMetaData) throws Exception {
|
|
Map<String, Object> data = new HashMap<String, Object>();
|
|
RuleFlowProcessInstance instance = (RuleFlowProcessInstance) processInstance;
|
|
for (Entry<String, Object> element : pTasksMetaData.entrySet()) {
|
|
Map<String, Object> record = new HashMap<String, Object>();
|
|
Node[] ns = instance.getRuleFlowProcess().getNodes();
|
|
for (Node n : ns) {
|
|
if (n.getName().compareTo(element.getKey()) == 0) {
|
|
Map<String, Object> m = n.getMetaData();
|
|
record.put("h", Integer.valueOf("" + m.get("height")));
|
|
record.put("w", Integer.valueOf("" + m.get("width")));
|
|
record.put("x", Integer.valueOf("" + m.get("x")));
|
|
record.put("y", Integer.valueOf("" + m.get("y")));
|
|
record.put("name", n.getName());
|
|
break;
|
|
}
|
|
}
|
|
// record.put(ProcessUtil.TASK_METADATA, element.getValue());
|
|
data.put(element.getKey(), record);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* JPQL TAREA_SUMMARY
|
|
*/
|
|
private static final String TAREA_SUMMARY = "select t from BAMTaskSummaryImpl t where t.taskId = :idtarea";
|
|
|
|
/**
|
|
* Obtiene el valor de unfinished tasks por Grupo.
|
|
*
|
|
* @param pGroupId the user id
|
|
* @param pCri the cri
|
|
* @return Valor de unfinished tasks
|
|
* @throws Exception la exception
|
|
*/
|
|
public BAMTaskSummaryImpl getBAMTaskSummaryImpl(long idtarea) throws Exception {
|
|
EntityManager em = null;
|
|
BAMTaskSummaryImpl dato = null;
|
|
try {
|
|
em = emf.createEntityManager();
|
|
Query qry = em.createQuery(Monitor.TAREA_SUMMARY);
|
|
qry.setParameter("idtarea", idtarea);
|
|
dato = (BAMTaskSummaryImpl) qry.getSingleResult();
|
|
} catch (NoResultException e) {
|
|
// retorna el objeto en null.
|
|
} finally {
|
|
if (em.isOpen()) {
|
|
em.close();
|
|
}
|
|
}
|
|
return dato;
|
|
}
|
|
|
|
/**
|
|
* JPQL TAREA_SUMMARY
|
|
*/
|
|
private static final String TAREA_AUDIT_IMP = "select t from AuditTaskImpl t where t.taskId = :idtarea";
|
|
|
|
public AuditTaskImpl getAuditTaskImpl(long idtarea) throws Exception {
|
|
EntityManager em = null;
|
|
AuditTaskImpl dato = null;
|
|
try {
|
|
em = emf.createEntityManager();
|
|
Query qry = em.createQuery(Monitor.TAREA_AUDIT_IMP);
|
|
qry.setParameter("idtarea", idtarea);
|
|
dato = (AuditTaskImpl) qry.getSingleResult();
|
|
} catch (NoResultException e) {
|
|
// retorna el objeto en null.
|
|
} finally {
|
|
if (em.isOpen()) {
|
|
em.close();
|
|
}
|
|
}
|
|
return dato;
|
|
}
|
|
}
|