580 lines
20 KiB
Plaintext
Executable File
580 lines
20 KiB
Plaintext
Executable File
/*
|
|
*
|
|
*/
|
|
package com.fp.bpmlib.task.client;
|
|
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.ObjectInputStream;
|
|
import java.io.ObjectOutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import javax.naming.InitialContext;
|
|
import javax.persistence.EntityManager;
|
|
import javax.persistence.Query;
|
|
|
|
import org.jbpm.process.instance.event.listeners.TriggerRulesEventListener;
|
|
import org.jbpm.services.task.impl.model.CommentImpl;
|
|
import org.jbpm.services.task.impl.model.UserImpl;
|
|
import org.jbpm.services.task.lifecycle.listeners.BAMTaskEventListener;
|
|
import org.jbpm.services.task.lifecycle.listeners.TaskLifeCycleEventListener;
|
|
import org.jbpm.services.task.utils.ContentMarshallerHelper;
|
|
import org.kie.api.runtime.KieSession;
|
|
import org.kie.api.runtime.manager.RuntimeEngine;
|
|
import org.kie.api.runtime.manager.RuntimeManager;
|
|
import org.kie.api.task.TaskService;
|
|
import org.kie.api.task.model.Content;
|
|
import org.kie.api.task.model.Status;
|
|
import org.kie.api.task.model.Task;
|
|
import org.kie.api.task.model.TaskData;
|
|
import org.kie.api.task.model.TaskSummary;
|
|
import org.kie.internal.task.api.EventService;
|
|
import org.kie.internal.task.api.InternalTaskService;
|
|
|
|
import com.fp.bpmlib.Common;
|
|
import com.fp.bpmlib.ProcessUtil;
|
|
import com.fp.bpmlib.ejb.local.JbpmBeanLocal;
|
|
import com.fp.bpmlib.query.monitor.FlowActivitySave;
|
|
import com.fp.bpmlib.task.MaiaWorkItemHandler;
|
|
import com.fp.common.helper.Constant;
|
|
import com.fp.common.logger.APPLogger;
|
|
import com.fp.persistence.commondb.PersistenceHelper;
|
|
import com.fp.persistence.commondb.PersistenceManager;
|
|
import com.fp.persistence.pbpm.gene.TbpmGroupsUsers;
|
|
import com.fp.simple.dto.TaskInfo;
|
|
|
|
//
|
|
/**
|
|
* Class HumanTaskClient encargada de acceder al Servidor de Tareas.
|
|
*
|
|
* @author Jvaca
|
|
* @version 2.1
|
|
*/
|
|
public class HumanTaskClient {
|
|
|
|
/** El valor de language. */
|
|
private String language = "en-UK";
|
|
|
|
private final TaskService taskService;
|
|
|
|
private final KieSession kiesession;
|
|
|
|
/**
|
|
* Crea una nueva instancia de human task client.
|
|
*
|
|
* @throws Exception la exception
|
|
*/
|
|
public HumanTaskClient() throws Exception {
|
|
JbpmBeanLocal local = (JbpmBeanLocal) new InitialContext().lookup("java:global/maiaear-2.1/bpmlib/jbpmbean");
|
|
RuntimeManager manager = local.getRuntimeManager();
|
|
RuntimeEngine runtime = manager.getRuntimeEngine(null);
|
|
kiesession = runtime.getKieSession();
|
|
taskService = runtime.getTaskService();
|
|
kiesession.addEventListener(new TriggerRulesEventListener(kiesession));
|
|
kiesession.getWorkItemManager().registerWorkItemHandler("Human Task", new MaiaWorkItemHandler());
|
|
this.addListeners(runtime);
|
|
}
|
|
|
|
/**
|
|
* Adiciona listener, para el manejo del bam de tareas.
|
|
*
|
|
* @param engine
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
private void addListeners(RuntimeEngine engine) {
|
|
EventService<TaskLifeCycleEventListener> eventService = (EventService<TaskLifeCycleEventListener>) engine.getTaskService();
|
|
boolean hasBamEventListener = false;
|
|
for (TaskLifeCycleEventListener listener : eventService.getTaskEventListeners()) {
|
|
if (listener instanceof BAMTaskEventListener) {
|
|
hasBamEventListener = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!hasBamEventListener) {
|
|
BAMTaskEventListener bamTaskEventListener = new BAMTaskEventListener();
|
|
eventService.registerTaskEventListener(bamTaskEventListener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Activate task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void activateTask(long pTask, String pUserId) throws Exception {
|
|
taskService.activate(pTask, pUserId);
|
|
|
|
}
|
|
|
|
/**
|
|
* Claim task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void claimTask(long pTask, String pUserId) throws Exception {
|
|
taskService.claim(pTask, pUserId);
|
|
FlowActivitySave.actualizarActividadClaim(pTask, pUserId);
|
|
}
|
|
|
|
/**
|
|
* Entrega lsita de grupos bpm al que pertenece el usuario.
|
|
*
|
|
* @param pUser Codigo de usuario a buscar los grupos a los que pertenece.
|
|
* @return List<String>
|
|
* @throws Exception la exception
|
|
*/
|
|
public static List<String> groupsByUser(String pUser) throws Exception {
|
|
List<TbpmGroupsUsers> groups = TbpmGroupsUsers.findGroupsByUser(PersistenceHelper.getEntityManager(), pUser);
|
|
List<String> data = new ArrayList<String>();
|
|
for (TbpmGroupsUsers tbpmGroupsUsers : groups) {
|
|
data.add(tbpmGroupsUsers.getPk().getGroupcode());
|
|
}
|
|
return data;
|
|
}
|
|
|
|
/**
|
|
* Close.
|
|
*
|
|
* @throws Exception la exception
|
|
*/
|
|
public void close() throws Exception {
|
|
// No hacer nada con JTA la session se cierra automaticamente.
|
|
}
|
|
|
|
/**
|
|
* Complete task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pJournalId the journal id
|
|
* @param data the data
|
|
* @param pResultado the resultado
|
|
* @param pObs the obs
|
|
* @throws Exception la exception
|
|
*/
|
|
public String completeTask(long pTask, String pJournalId, Map<String, Object> data, String pResultado, String pObs) throws Exception {
|
|
Task t = this.getTaskById(pTask);
|
|
TaskData td = t.getTaskData();
|
|
this.addComment(pTask, td.getActualOwner().getId(), pObs);
|
|
Map<String, Object> input = this.getInputData(t);
|
|
TaskInfo ti = (TaskInfo) input.get(ProcessUtil.TASK_METADATA);
|
|
ti.setResponse(pResultado);
|
|
ti.setTaskId(pTask);
|
|
ti.setJournalId(pJournalId);
|
|
System.out.println(pObs);
|
|
if (ti.getUserId() == null && t.getTaskData().getActualOwner() != null) {
|
|
ti.setUserId(t.getTaskData().getActualOwner().getId());
|
|
}
|
|
|
|
// Las fechas para el monitor se toman de BamTaskSummary
|
|
// ti.setCreated(new Timestamp( td.getCreatedOn().getTime()));
|
|
// ti.setCompleted(FormatDates.getInstance().getDataBaseTimestamp());
|
|
ti.getAditionalData().putAll(data);
|
|
taskService.complete(pTask, td.getActualOwner().getId(), input);
|
|
FlowActivitySave.actualizarActividadComplete(pTask, ti);
|
|
return ti.getTname();
|
|
}
|
|
|
|
/**
|
|
* Adiciona un comment.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @param pComment the comment
|
|
* @throws Exception la exception
|
|
*/
|
|
public void addComment(long pTask, String pUserId, String pComment) throws Exception {
|
|
InternalTaskService its = (InternalTaskService) taskService;
|
|
CommentImpl comentario = new CommentImpl();
|
|
comentario.setText(pComment);
|
|
comentario.setAddedAt(Common.getInstance().getCurrentDate());
|
|
comentario.setAddedBy(new UserImpl(pUserId));
|
|
its.addComment(pTask, comentario);
|
|
|
|
}
|
|
|
|
/**
|
|
* Delegate task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @param pTargetUserId the target user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void delegateTask(long pTask, String pUserId, String pTargetUserId) throws Exception {
|
|
taskService.delegate(pTask, pUserId, pTargetUserId);
|
|
FlowActivitySave.actualizarActividadDelegate(pTask, pTargetUserId);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de assigned tasks.
|
|
*
|
|
* @return Valor de assigned tasks
|
|
* @throws Exception la exception
|
|
*/
|
|
public List<TaskSummary> getAssignedTasks() throws Exception {
|
|
return taskService.getTasksAssignedAsPotentialOwner(null, language);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de assigned tasks.
|
|
*
|
|
* @param pUserId the user id
|
|
* @return Valor de assigned tasks
|
|
* @throws Exception la exception
|
|
*/
|
|
public List<TaskSummary> getAssignedTasks(String pUserId) throws Exception {
|
|
// this.client.getTasksAssignedAsPotentialOwner(pUserId, this.language, taskSummaryHandler);
|
|
return taskService.getTasksOwned(pUserId, language);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de content by id.
|
|
*
|
|
* @param pId the id
|
|
* @return Valor de content by id
|
|
* @throws Exception la exception
|
|
*/
|
|
public Content getContentById(long pId) throws Exception {
|
|
return taskService.getContentById(pId);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de input data.
|
|
*
|
|
* @param pTask the task
|
|
* @return Valor de input data
|
|
* @throws Exception la exception
|
|
*/
|
|
public Map<String, Object> getInputData(Task pTask) throws Exception {
|
|
Content c = this.getContentById(pTask.getTaskData().getDocumentContentId());
|
|
return HumanTaskClient.getContenido(c);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de output data.
|
|
*
|
|
* @param pTask the task
|
|
* @return Valor de output data
|
|
* @throws Exception la exception
|
|
*/
|
|
public Map<String, Object> getOutputData(Task pTask) throws Exception {
|
|
Content c = this.getContentById(pTask.getTaskData().getOutputContentId());
|
|
return HumanTaskClient.getContenido(c);
|
|
}
|
|
|
|
/**
|
|
* Entrega el contenido asociado al workitem.
|
|
*
|
|
* @param task Datos de la tarea
|
|
* @return Map<String, Object>
|
|
* @throws Exception
|
|
*/
|
|
@SuppressWarnings("unchecked")
|
|
public static Map<String, Object> getContenido(Content content) throws Exception {
|
|
Map<String, Object> maia = new HashMap<String, Object>();
|
|
Object obj = ContentMarshallerHelper.unmarshall(content.getContent(), null);
|
|
if (obj instanceof Map) {
|
|
maia = (Map<String, Object>) obj;
|
|
}
|
|
return maia;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de input data.
|
|
*
|
|
* @param pTask the task
|
|
* @return Valor de input data
|
|
* @throws Exception la exception
|
|
*/
|
|
@SuppressWarnings(Constant.WARN_UNCHECKED)
|
|
@Deprecated
|
|
public Map<String, Object> getDatos(Content c) throws Exception {
|
|
if (c != null) {
|
|
// Esto funciona con jbm 5.4
|
|
Object obj = ContentMarshallerHelper.unmarshall(c.getContent(), null);
|
|
if (obj != null) {
|
|
ByteArrayOutputStream bos = null;
|
|
ObjectOutputStream out = null;
|
|
try {
|
|
// return (Map<String, Object>) obj;
|
|
bos = new ByteArrayOutputStream();
|
|
out = new ObjectOutputStream(bos);
|
|
out.writeObject(obj);
|
|
ObjectInputStream bin = new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
|
|
return (Map<String, Object>) bin.readObject();
|
|
} finally {
|
|
bos.close();
|
|
out.close();
|
|
}
|
|
}
|
|
}
|
|
|
|
ObjectInputStream bin = new ObjectInputStream(new ByteArrayInputStream(c.getContent()));
|
|
try {
|
|
return (Map<String, Object>) bin.readObject();
|
|
} finally {
|
|
bin.close();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de task by id.
|
|
*
|
|
* @param pId the id
|
|
* @return Valor de task by id
|
|
* @throws Exception la exception
|
|
*/
|
|
public Task getTaskById(long pId) throws Exception {
|
|
return taskService.getTaskById(pId);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de task by work item id.
|
|
*
|
|
* @param pWorkId the work id
|
|
* @return Valor de task by work item id
|
|
* @throws Exception la exception
|
|
*/
|
|
public Task getTaskByWorkItemId(long pWorkId) throws Exception {
|
|
return taskService.getTaskByWorkItemId(pWorkId);
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de task content input.
|
|
*
|
|
* @param taskSum the task sum
|
|
* @return Valor de task content input
|
|
*/
|
|
public Object getTaskContentInput(TaskSummary taskSum) {
|
|
ByteArrayInputStream bais = null;
|
|
ObjectInputStream is = null;
|
|
|
|
Task task2 = taskService.getTaskById(taskSum.getId());
|
|
TaskData taskData = task2.getTaskData();
|
|
Content content = taskService.getContentById(taskData.getDocumentContentId());
|
|
|
|
try {
|
|
bais = new ByteArrayInputStream(content.getContent());
|
|
is = new ObjectInputStream(bais);
|
|
Object obj = null;
|
|
|
|
do {
|
|
obj = is.readObject();
|
|
if (obj == null) {
|
|
break;
|
|
}
|
|
APPLogger.getLogger().debug("OBJECT: " + obj);
|
|
return obj;
|
|
} while (obj != null);
|
|
} catch (Exception e) {
|
|
APPLogger.getLogger().warn(e, e);
|
|
return null;
|
|
} finally {
|
|
try {
|
|
if (bais != null) {
|
|
bais.close();
|
|
}
|
|
} catch (Exception e2) {
|
|
}
|
|
try {
|
|
if (is != null) {
|
|
is.close();
|
|
}
|
|
} catch (Exception e2) {
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de task data.
|
|
*
|
|
* @param pTask the task
|
|
* @return Valor de task data
|
|
* @throws Exception la exception
|
|
*/
|
|
public TaskData getTaskData(long pTask) throws Exception {
|
|
Task task = this.getTaskById(pTask);
|
|
return task.getTaskData();
|
|
}
|
|
|
|
/**
|
|
* Obtiene el listado de tareas Asignadas.
|
|
*
|
|
* @param pUserCri the user cri
|
|
* @param pCriteria the criteria
|
|
* @param pPage the page
|
|
* @param pRecords the records
|
|
* @return Listado de tareas asignadas
|
|
* @throws Exception la exception
|
|
*/
|
|
public List<Object[]> getAsignedTasks(String pUserCri) throws Exception {
|
|
List<Status> lestatus = new ArrayList<>();
|
|
List<Object[]> lresp = new ArrayList<>();
|
|
lestatus.add(Status.Reserved);
|
|
lestatus.add(Status.InProgress);
|
|
List<TaskSummary> list;
|
|
try {
|
|
list = taskService.getTasksOwnedByStatus(pUserCri, lestatus, "en-UK");
|
|
for (TaskSummary obj : list) {
|
|
Object o[] = new Object[2];
|
|
Task task = this.getTaskById(obj.getId());
|
|
Content c = this.getContentById(task.getTaskData().getDocumentContentId());
|
|
o[0] = task;
|
|
o[1] = c;
|
|
lresp.add(o);
|
|
}
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
return lresp;
|
|
}
|
|
|
|
/**
|
|
* Obtiene el valor de unfinished tasks.
|
|
*
|
|
* @param pUserId the user id
|
|
* @param pCri the cri
|
|
* @return Valor de unfinished tasks
|
|
* @throws Exception la exception
|
|
*/
|
|
public List<Object[]> getUnfinishedTasksByUser(String pUserId) throws Exception {
|
|
List<Status> lestatus = new ArrayList<>();
|
|
List<Object[]> lresp = new ArrayList<>();
|
|
lestatus.add(Status.Reserved);
|
|
lestatus.add(Status.InProgress);
|
|
List<TaskSummary> list = taskService.getTasksOwnedByStatus(pUserId, lestatus, "en-UK");
|
|
try {
|
|
list = taskService.getTasksOwnedByStatus(pUserId, lestatus, "en-UK");
|
|
for (TaskSummary obj : list) {
|
|
Object o[] = new Object[2];
|
|
Task task = this.getTaskById(obj.getId());
|
|
Content c = this.getContentById(task.getTaskData().getDocumentContentId());
|
|
o[0] = task;
|
|
o[1] = c;
|
|
lresp.add(o);
|
|
}
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
}
|
|
return lresp;
|
|
|
|
}
|
|
|
|
/**
|
|
* JPQL JPQL_TASK_NOT_COMPLETEBYGROUP
|
|
*/
|
|
private static final String TAREAS_GRUPO = "select t, potentialOwners.id from TaskImpl t, OrganizationalEntityImpl potentialOwners "
|
|
+ "where potentialOwners.id in (:groupIds) and potentialOwners in elements ( t.peopleAssignments.potentialOwners ) and t.archived = 0 "
|
|
+ "and t.taskData.actualOwner = null and t.taskData.status in ('Created', 'Ready', 'Reserved', 'InProgress', 'Suspended')";
|
|
|
|
/**
|
|
* 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
|
|
*/
|
|
@SuppressWarnings(Constant.WARN_UNCHECKED)
|
|
public List<Object[]> getTasksByGroup(String pGroupId, String pCri) throws Exception {
|
|
List<Object[]> ldatos = new ArrayList<Object[]>();
|
|
EntityManager em = null;
|
|
try {
|
|
em = PersistenceManager.getInstance().getEntityManagerFactoryAuxiliar("org.jbpm.domain").createEntityManager();
|
|
Query qry = em.createQuery(HumanTaskClient.TAREAS_GRUPO);
|
|
qry.setParameter("groupIds", pGroupId);
|
|
ldatos = qry.getResultList();
|
|
} catch (Exception e) {
|
|
throw new RuntimeException(e);
|
|
} finally {
|
|
if (em.isOpen()) {
|
|
em.close();
|
|
}
|
|
}
|
|
return ldatos;
|
|
}
|
|
|
|
/**
|
|
* Release task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void releaseTask(long pTask, String pUserId) throws Exception {
|
|
taskService.release(pTask, pUserId);
|
|
}
|
|
|
|
/**
|
|
* Resume task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void resumeTask(long pTask, String pUserId) throws Exception {
|
|
taskService.resume(pTask, pUserId);
|
|
}
|
|
|
|
/**
|
|
* Start task.
|
|
*
|
|
* @param pTask the task
|
|
* @throws Exception la exception
|
|
*/
|
|
public void startTask(long pTask) throws Exception {
|
|
Task task = this.getTaskById(pTask);
|
|
APPLogger.getLogger().debug("Starting task " + pTask);
|
|
Map<String, Object> input = this.getInputData(task);
|
|
// com.fp.bpmlib.Process p = this.findProcess(task.getTaskData(), snapshot);
|
|
// TaskInfo ti = (TaskInfo) input.get(ProcessUtil.TASK_METADATA);
|
|
// ti.setTaskId(pTask);
|
|
// ti.setStarted(FormatDates.getInstance().getDataBaseTimestamp());
|
|
// ti.setCreated(new Timestamp(task.getTaskData().getCreatedOn().getTime()));
|
|
|
|
// ProcessInstance processInstance = kiesession.getProcessInstance(task.getTaskData().getProcessInstanceId());
|
|
// RuleFlowProcessInstance rfpi = (RuleFlowProcessInstance) processInstance;
|
|
// rfpi.setVariable(ProcessUtil.TASK_METADATA, ti); //actualiza datos en el contexto.
|
|
// InternalTaskService its = ((InternalTaskService) taskService);
|
|
// Elimina el content anterior y remplaza por un nuevo content.
|
|
// its.deleteContent(pTask, task.getTaskData().getDocumentContentId());
|
|
// its.addContent(pTask, input);
|
|
|
|
// ***** LA FECHA DE CREACION E INICIO SE TOMA DE LA BAMTASKSUMMARY PARA PRESENTAR EN EL MONITOR.
|
|
|
|
taskService.start(pTask, task.getTaskData().getActualOwner().getId());
|
|
FlowActivitySave.actualizarActividadStart(pTask);
|
|
APPLogger.getLogger().debug("Started task " + pTask);
|
|
}
|
|
|
|
/**
|
|
* Stop task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void stopTask(long pTask, String pUserId) throws Exception {
|
|
taskService.stop(pTask, pUserId);
|
|
}
|
|
|
|
/**
|
|
* Suspend task.
|
|
*
|
|
* @param pTask the task
|
|
* @param pUserId the user id
|
|
* @throws Exception la exception
|
|
*/
|
|
public void suspendTask(long pTask, String pUserId) throws Exception {
|
|
taskService.suspend(pTask, pUserId);
|
|
}
|
|
|
|
} |