Changer manuellement la tâche sur l'instance de processus en cours d'exécution

Question

Dans l'ordre de développer une application BPM personnalisée, une fonctionnalité que nous utilisait avec un autre fournisseur de moteurs BPM et que vous souhaitez l'utiliser avec Camunka. La fonctionnalité ciblée concerne les instances de processus de réglage / réinitialisation de la réinitialisation d'une tâche spécifiée autre que l'actif actuel. De notre point de vue nécessaire lorsque E.g.:

• Processus de création - instances dues à la migration de version de processus
• Résolution des incidents
• résoudre une utilisation accidentellement erronée par un utilisateur

Enfin, je n'ai pas vraiment trouvé une fonction simple de le faire, mais a élaboré un code personnalisé qui a travaillé avec certaines limitations. Il existe des faiblesses et des incertaines dans ce code afin que j'ai la question suivante :

Avez-vous manqué une autre façon d'y parvenir ou est l'approche suivante correcte ou est-ce même totalement non supportée pour le moment?

Les faiblesses actuelles IMHO:

• premier et le plus important: aucune instance de tâche historique n'est stockée . Cette causes que ce ne soit pas traçable qui ou même lorsque la tâche a été déclenchée / activer / démarrer. J'ai trouvé le message suivant sur Camunka Google Group ( Post ) qui dit que c'est correct à ce stade parce que c'est une tâche hors de la portée de la définition de processus, mais En utilisant une définition de tâche de la définition de processus sous-jacente, je devrais être "dans la portée"?!
• Le code est basé sur la mise en œuvre interne et non sur l'interface officielle
• à ce stade, beaucoup de "bootstrap" / initialisation doivent être effectués manuellement Mais en tant qu'utilisateur (non développeur de Camunka), je ne suis pas pleinement conscient de ce qui est requis et Qu'est-ce qui est facultatif
• Certaines parties comme des expressions d'analyse de la définition de tâche ont échoué (voir le code commenté) mais cela peut être causé par une mauvaise utilisation

Voici le code (extrait expérimental de notre façade de service Camunka):

@Inject
protected HistoryService histService;
@Inject
protected TaskService taskService;
@Inject
protected ManagementService managementService;
@Inject
protected RuntimeService runtimeService;
@Inject
protected IdentityService identityService;
@Inject
protected RepositoryService repositoryService;
@Inject
protected FormService formService;
@Inject
protected ProcessEngine processEngine;


public void startTask(String processInstanceId, String taskKey) {
    Collection<TaskDefinition> taskDefs = getAvailableTasks(
            processInstanceId);
    TaskEntity newTask = null;
    TaskDefinition taskDef = null;
    for (TaskDefinition taskDefinition : taskDefs) {
        if (taskDefinition.getKey().equals(taskKey)) {
            taskDef = taskDefinition;
            break;
        }
    }
    boolean taskDefExists = taskDef != null;
    List<Task> runningTasksByKey = getTasksByKey(taskKey, processInstanceId);
    boolean taskIsAlreadyRunning = runningTasksByKey != null
            && runningTasksByKey.size() > 0;
    if (taskDefExists && !taskIsAlreadyRunning) {
        newTask = (TaskEntity) taskService.newTask();
        ProcessInstance procInst = getProcessInstance(processInstanceId);
        ExecutionEntity procInstEntity = (ExecutionEntity) procInst;
        String taskName = (String) taskDef.getNameExpression().
                getExpressionText();
//            String taskAssigne = (String) taskDef.getAssigneeExpression().
//                    getValue(
//                            procInstEntity);
//            newTask.setAssignee(taskAssigne);
            newTask.setTaskDefinitionKey(taskDef.getKey());
            newTask.setProcessInstance(procInstEntity);
            newTask.setTaskDefinition(taskDef);
            newTask.setName(taskName);
            newTask.setProcessInstanceId(processInstanceId);
            newTask.setProcessDefinitionId(procInstEntity.
                    getProcessDefinitionId());
            taskService.saveTask(newTask);

        TaskServiceImpl taskServiceImpl = (TaskServiceImpl) BpmPlatform.
                getProcessEngineService().getDefaultProcessEngine().
                getTaskService();
        CommandExecutor commandExecutor = taskServiceImpl.
                getCommandExecutor();
        ExecutionEntity executionEntity = commandExecutor.execute(
                new SaveTaskActivityInstanceCmd(newTask,
                        procInstEntity));
//            commandExecutor.execute(new `SaveTaskHistoricActivityInstanceCmd(executionEntity, newTask));`
    }
}

public Collection<TaskDefinition> getAvailableTasks(String processInstanceId) {
            Map<String, TaskDefinition> taskDefs = null;
            Collection<TaskDefinition> taskDefObjects = null;
            if (processInstanceId != null) {
                ProcessInstanceQuery procInstQuery = runtimeService.
                        createProcessInstanceQuery().processInstanceId(
                                processInstanceId);
                ProcessDefinitionEntity procDefEntity = getProcessDefinitionEager(
                        processInstanceId);
                taskDefs = procDefEntity.getTaskDefinitions();
            }
            taskDefObjects = (Collection<TaskDefinition>) (taskDefs != null ? taskDefs.
                    values() : new ArrayList<TaskDefinition>());
            return taskDefObjects;
}

public ProcessDefinitionEntity getProcessDefinitionEager(
        String processInstanceId) {
    ProcessInstanceQuery procInstQuery = runtimeService.
            createProcessInstanceQuery().processInstanceId(
                    processInstanceId);
    ProcessInstance procInst = procInstQuery.singleResult();
    String procDefId = procInst.getProcessDefinitionId();
    return (ProcessDefinitionEntity) repositoryService.getProcessDefinition(
            procDefId);
}

public List<Task> getTasksByKey(String taskKey, String processInstanceId) {
    List<Task> tasks = taskService.createTaskQuery().processInstanceId(
            processInstanceId).taskDefinitionKey(taskKey).list();
    return tasks;
}


public class SaveTaskActivityInstanceCmd implements Command<ExecutionEntity>,  
      Serializable {

    private TaskEntity newTask;
    private ExecutionEntity procInstEntity;

    public SaveTaskActivityInstanceCmd(TaskEntity newTaskInit,
            ExecutionEntity procInstEntityInit) {
        this.newTask = newTaskInit;
        this.procInstEntity = procInstEntityInit;
    }


    public ExecutionEntity execute(CommandContext commandContext) {
          ActivityImpl actImpl = new ActivityImpl(newTask.
                getTaskDefinitionKey(),
                procInstEntity.getProcessDefinition());
          actImpl.setActivityBehavior(new UserTaskActivityBehavior(
                new CdiExpressionManager(), newTask.getTaskDefinition()));
          ExecutionEntity execEntity = new ExecutionEntity();
          execEntity.setActivity(actImpl);
          execEntity.setActivityInstanceId(newTask.getTaskDefinitionKey()
                + ":" + newTask.getId());
          execEntity.setEventName(newTask.getEventName());
          execEntity.setProcessDefinitionId(newTask.getProcessDefinitionId());
          execEntity.setActive(true);
          execEntity.setProcessInstance(procInstEntity);
          commandContext.getExecutionManager().insert(execEntity);
          return execEntity;
     }
}

J'apprécie tout indice ou conseil: -)

Answer 1

Je ne voudrais pas gâcher l'instance de processus à ce niveau, comme vous l'avez déjà remarqué, vous ignorez les services Camundas.Face à un problème similaire, nous sommes allés avec ce qui suit:

1. Annuler l'instance de processus de l'ancienne version de processus
2. Démarrez une nouvelle instance du processus étendu et transmettez-la programmatiquement à l'état souhaité ...

Une autre option: Modèle un point d'entrée (événement de démarrage du message) à l'intérieur de la nouvelle version du processus.Ensuite, au lieu d'envoyer par programmation l'instance à l'état souhaité, démarrez simplement la nouvelle instance via l'événement et passez toutes les variables de processus de l'ancienne instance ...

Answer 2

Commencer avec Camunka 7.3, vous pouvez utiliser la modification d'instance de processus pour démarrer toute activité dans un processus et annuler toute instance d'activité active.

Exemple:

runtimeService.createProcessInstanceModification(processInstanceId)
  .startBeforeActivity("someActivityId")
  .cancelActivityInstance("someActivityInstanceId")
  .execute();

voir http:// docs.Camunda.org/7.3/Guides/user-Guide/#process-Engine-Process-Instance-Modification pour la documentation.