Examples with Task org.kie.kogito.taskassigning.core.model.Task used on opensource projects

Example 6 with Task

use of org.kie.kogito.taskassigning.core.model.Task in project kogito-apps by kiegroup.

the class TaskHelperTest method hasAllLabels.

@ParameterizedTest
@MethodSource("testParams")
void hasAllLabels(String taskLabelName, Set<Object> taskLabelValues, String userLabelName, Set<Object> userLabelValues, LabelsCheckResult checkResult) {
    Task task = mockTask(taskLabelName, taskLabelValues);
    User user = mockUser(userLabelName, userLabelValues);
    assertThat(TaskHelper.hasAllLabels(task, user, taskLabelName)).isEqualTo(checkResult.hasAllLabels);
}

Example 7 with Task

use of org.kie.kogito.taskassigning.core.model.Task in project kogito-apps by kiegroup.

the class TaskHelperTest method matchingLabels.

@ParameterizedTest
@MethodSource("testParams")
void matchingLabels(String taskLabelName, Set<Object> taskLabelValues, String userLabelName, Set<Object> userLabelValues, LabelsCheckResult checkResult) {
    Task task = mockTask(taskLabelName, taskLabelValues);
    User user = mockUser(userLabelName, userLabelValues);
    assertThat(TaskHelper.countMatchingLabels(task, user, taskLabelName)).isEqualTo(checkResult.matchingLabels);
}

Example 8 with Task

use of org.kie.kogito.taskassigning.core.model.Task in project kogito-apps by kiegroup.

the class TaskInfoChangeProblemFactChangeTest method doChange.

@Test
void doChange() {
    change.doChange(scoreDirector);
    assertThat(task).isNotSameAs(workingTaskAssignment.getTask());
    verify(scoreDirector, times(1)).beforeProblemPropertyChanged(workingTaskAssignment);
    verify(scoreDirector, times(1)).afterProblemPropertyChanged(workingTaskAssignment);
    verify(scoreDirector).triggerVariableListeners();
    Task clonedTask = workingTaskAssignment.getTask();
    assertThat(clonedTask.getId()).isEqualTo(TASK_ID);
    assertThat(clonedTask.getName()).isEqualTo(TASK_NAME);
    assertThat(clonedTask.getReferenceName()).isEqualTo(REFERENCE_NAME);
    assertThat(clonedTask.getProcessInstanceId()).isEqualTo(PROCESS_INSTANCE_ID);
    assertThat(clonedTask.getProcessId()).isEqualTo(PROCESS_ID);
    assertThat(clonedTask.getRootProcessInstanceId()).isEqualTo(ROOT_PROCESS_INSTANCE_ID);
    assertThat(clonedTask.getRootProcessId()).isEqualTo(ROOT_PROCESS_ID);
    assertThat(clonedTask.getStarted()).isEqualTo(STARTED);
    assertThat(clonedTask.getEndpoint()).isEqualTo(ENDPOINT);
    assertThat(clonedTask.getState()).isEqualTo(TASK_INFO_STATE);
    assertThat(clonedTask.getDescription()).isEqualTo(TASK_INFO_DESCRIPTION);
    assertThat(clonedTask.getPriority()).isEqualTo(TASK_INFO_PRIORITY);
    assertThat(clonedTask.getPotentialUsers()).isSameAs(TASK_INFO_POTENTIAL_USERS);
    assertThat(clonedTask.getPotentialGroups()).isSameAs(TASK_INFO_POTENTIAL_GROUPS);
    assertThat(clonedTask.getAdminUsers()).isSameAs(TASK_INFO_ADMIN_USERS);
    assertThat(clonedTask.getAdminGroups()).isSameAs(TASK_INFO_ADMIN_GROUPS);
    assertThat(clonedTask.getExcludedUsers()).isSameAs(TASK_INFO_EXCLUDED_USERS);
    assertThat(clonedTask.getCompleted()).isEqualTo(TASK_INFO_COMPLETED);
    assertThat(clonedTask.getLastUpdate()).isEqualTo(TASK_INFO_LAST_UPDATE);
    assertThat(clonedTask.getInputData()).isSameAs(TASK_INFO_INPUTS);
    assertThat(clonedTask.getAttributes()).isSameAs(TASK_INFO_ATTRIBUTES);
}

Example 9 with Task

use of org.kie.kogito.taskassigning.core.model.Task in project kogito-apps by kiegroup.

the class TaskAssigningService method onPlanningExecuted.

/**
 * Invoked when the PlanningExecutor finalized the execution of a plan.
 * Three main scenarios might happen:
 * a) There are successful invocations and thus tasks were assigned, the corresponding "pinning changes" must be produced.
 * Create and add them to the Solver.
 *
 * b) No "pinning changes" to execute there and no available events, retry with the planning items that failed.
 *
 * c) No "pinning changes" but there are available events, execute them.
 *
 * @param result a PlanningExecutionResult with results of the planning execution.
 */
synchronized void onPlanningExecuted(PlanningExecutionResult result) {
    if (isNotOperative()) {
        LOGGER.warn(SERVICE_INOPERATIVE_MESSAGE, context.getStatus());
        return;
    }
    try {
        LOGGER.debug("Planning was executed");
        applyingPlanningExecutionResult.set(false);
        TaskAssigningSolution solution = currentSolution.get();
        Map<String, User> usersById = solution.getUserList().stream().collect(Collectors.toMap(User::getId, Function.identity()));
        List<ProblemFactChange<TaskAssigningSolution>> pinningChanges = new ArrayList<>();
        Task task;
        User user;
        boolean published;
        for (PlanningExecutionResultItem resultItem : result.getItems()) {
            task = resultItem.getItem().getTask();
            published = !resultItem.hasError();
            if (published) {
                user = usersById.get(resultItem.getItem().getTargetUser());
                pinningChanges.add(new AssignTaskProblemFactChange(new TaskAssignment(task), user));
            }
            context.setTaskPublished(task.getId(), published);
        }
        if (!pinningChanges.isEmpty()) {
            LOGGER.debug("Pinning changes must be executed for the successful invocations: {}", pinningChanges.size());
            pinningChanges.add(0, scoreDirector -> context.setCurrentChangeSetId(context.nextChangeSetId()));
            applyingPlanningExecutionResult.set(true);
            cancelScheduledImproveSolutionOnBackgroundTimer();
            solverExecutor.addProblemFactChanges(pinningChanges);
        } else if (!hasQueuedEvents()) {
            List<PlanningItem> failingItems = result.getItems().stream().filter(PlanningExecutionResultItem::hasError).map(PlanningExecutionResultItem::getItem).collect(Collectors.toList());
            LOGGER.debug("No new events to process, but some items failed: {}, we must retry", failingItems.size());
            cancelScheduledImproveSolutionOnBackgroundTimer();
            planningExecutor.start(failingItems, this::onPlanningExecuted);
        } else {
            LOGGER.debug("Some items failed but there are events to process, try to adjust the solution accordingly.");
            resumeEvents();
        }
    } catch (Exception e) {
        failFast(e);
    }
}

Example 10 with Task

use of org.kie.kogito.taskassigning.core.model.Task in project kogito-apps by kiegroup.

the class SolutionChangesBuilder method addTaskChanges.

private void addTaskChanges(TaskAssignment taskAssignment, TaskData taskData) {
    String taskState = taskData.getState();
    if (READY.value().equals(taskState)) {
        context.setTaskPublished(taskData.getId(), false);
        releasedTasksChanges.add(new ReleaseTaskProblemFactChange(taskAssignment));
    } else if (RESERVED.value().equals(taskState)) {
        context.setTaskPublished(taskData.getId(), true);
        if (!taskData.getActualOwner().equals(taskAssignment.getUser().getId()) || !taskAssignment.isPinned()) {
            final User user = getUser(usersById.get(taskData.getActualOwner()), taskData.getActualOwner());
            AssignTaskProblemFactChange change = new AssignTaskProblemFactChange(taskAssignment, user, true);
            addChangeToUser(assignToUserChangesByUserId, change, user, -1, true);
        }
    } else if (TaskState.isTerminal(taskState)) {
        removedTasksSet.add(taskAssignment);
    }
    if (!removedTasksSet.contains(taskAssignment)) {
        Task updatedTask = fromTaskData(taskData);
        if (!equalsByTaskInfoProperties(taskAssignment.getTask(), updatedTask)) {
            processorRegistry.applyAttributesProcessor(updatedTask, updatedTask.getAttributes());
        } else {
            updatedTask.setAttributes(taskAssignment.getTask().getAttributes());
        }
        taskPropertyChanges.add(new TaskInfoChangeProblemFactChange(taskAssignment, updatedTask));
    }
}