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

Example 11 with Task

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

the class AttributesProcessorRegistryTest method applyTaskAttributesProcessor.

@Test
void applyTaskAttributesProcessor() {
    Task task = mock(Task.class);
    doReturn(TASK_ID).when(task).getId();
    Map<String, Object> attributes = new HashMap<>();
    registry.applyAttributesProcessor(task, new HashMap<>());
    InOrder inOrder = inOrder(taskProcessors.get(0), taskProcessors.get(1), taskProcessors.get(2), taskProcessors.get(3), taskProcessors.get(4), taskProcessors.get(5));
    inOrder.verify(taskProcessors.get(5)).process(taskInfoCaptor.capture(), eq(attributes));
    assertThat(taskInfoCaptor.getValue().getTaskId()).isEqualTo(TASK_ID);
    inOrder.verify(taskProcessors.get(4)).process(taskInfoCaptor.capture(), eq(attributes));
    assertThat(taskInfoCaptor.getValue().getTaskId()).isEqualTo(TASK_ID);
    inOrder.verifyNoMoreInteractions();
}

Example 12 with Task

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

the class TaskUtilTest method fromTaskData.

@Test
void fromTaskData() {
    Task task = TaskUtil.fromTaskData(new TaskData() {

        @Override
        public String getId() {
            return TASK_ID;
        }

        @Override
        public String getName() {
            return TASK_NAME;
        }

        @Override
        public String getState() {
            return STATE;
        }

        @Override
        public String getDescription() {
            return TASK_DESCRIPTION;
        }

        @Override
        public String getReferenceName() {
            return REFERENCE_NAME;
        }

        @Override
        public String getPriority() {
            return TASK_PRIORITY;
        }

        @Override
        public String getProcessInstanceId() {
            return PROCESS_INSTANCE_ID;
        }

        @Override
        public String getProcessId() {
            return PROCESS_ID;
        }

        @Override
        public String getRootProcessInstanceId() {
            return ROOT_PROCESS_INSTANCE_ID;
        }

        @Override
        public String getRootProcessId() {
            return ROOT_PROCESS_ID;
        }

        @Override
        public String getActualOwner() {
            return ACTUAL_OWNER;
        }

        @Override
        public Set<String> getPotentialUsers() {
            return new HashSet<>(POTENTIAL_USERS);
        }

        @Override
        public Set<String> getPotentialGroups() {
            return new HashSet<>(POTENTIAL_GROUPS);
        }

        @Override
        public Set<String> getAdminUsers() {
            return new HashSet<>(ADMIN_USERS);
        }

        @Override
        public Set<String> getAdminGroups() {
            return new HashSet<>(ADMIN_GROUPS);
        }

        @Override
        public Set<String> getExcludedUsers() {
            return new HashSet<>(EXCLUDED_USERS);
        }

        @Override
        public ZonedDateTime getStarted() {
            return START_DATE;
        }

        @Override
        public ZonedDateTime getCompleted() {
            return COMPLETED_DATE;
        }

        @Override
        public ZonedDateTime getLastUpdate() {
            return LAST_UPDATE;
        }

        @Override
        public JsonNode getInputs() {
            return TASK_INPUTS;
        }

        @Override
        public String getEndpoint() {
            return ENDPOINT;
        }
    });
    assertThat(task.getId()).isEqualTo(TASK_ID);
    assertThat(task.getDescription()).isEqualTo(TASK_DESCRIPTION);
    assertThat(task.getName()).isEqualTo(TASK_NAME);
    assertThat(task.getPriority()).isEqualTo(TASK_PRIORITY);
    assertThat(task.getProcessInstanceId()).isEqualTo(PROCESS_INSTANCE_ID);
    assertThat(task.getProcessId()).isEqualTo(PROCESS_ID);
    assertThat(task.getRootProcessId()).isEqualTo(ROOT_PROCESS_ID);
    assertThat(task.getRootProcessInstanceId()).isEqualTo(ROOT_PROCESS_INSTANCE_ID);
    assertThat(task.getState()).isEqualTo(STATE);
    assertThat(task.getAdminGroups()).containsExactlyInAnyOrder(ADMIN_GROUPS.toArray(new String[0]));
    assertThat(task.getAdminUsers()).containsExactlyInAnyOrder(ADMIN_USERS.toArray(new String[0]));
    assertThat(task.getCompleted()).isEqualTo(COMPLETED_DATE);
    assertThat(task.getStarted()).isEqualTo(START_DATE);
    assertThat(task.getExcludedUsers()).containsExactlyInAnyOrder(EXCLUDED_USERS.toArray(new String[0]));
    assertThat(task.getPotentialGroups()).containsExactlyInAnyOrder(POTENTIAL_GROUPS.toArray(new String[0]));
    assertThat(task.getPotentialUsers()).containsExactlyInAnyOrder(POTENTIAL_USERS.toArray(new String[0]));
    assertThat(task.getReferenceName()).isEqualTo(REFERENCE_NAME);
    assertThat(task.getLastUpdate()).isEqualTo(LAST_UPDATE);
    assertThat(task.getEndpoint()).isEqualTo(ENDPOINT);
    assertThat(task.getInputData()).containsExactlyInAnyOrderEntriesOf(buildExpectedInputs());
}

Example 13 with Task

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

the class TaskInfoChangeProblemFactChange method doChange.

@Override
public void doChange(ScoreDirector<TaskAssigningSolution> scoreDirector) {
    TaskAssignment workingTaskAssignment = scoreDirector.lookUpWorkingObjectOrReturnNull(taskAssignment);
    if (workingTaskAssignment == null) {
        throw new TaskAssigningRuntimeException(String.format("Expected task assignment: %s was not found in current working solution", taskAssignment));
    }
    scoreDirector.beforeProblemPropertyChanged(workingTaskAssignment);
    Task currentTask = workingTaskAssignment.getTask();
    Task clonedTask = cloneByUnmodifiableFields(currentTask);
    setModifiableFields(clonedTask, taskInfo);
    workingTaskAssignment.setTask(clonedTask);
    scoreDirector.afterProblemPropertyChanged(workingTaskAssignment);
    scoreDirector.triggerVariableListeners();
}

Example 14 with Task

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

the class TaskAssigningGenerator method createTaskAssignmentList.

private List<TaskAssignment> createTaskAssignmentList(int size, List<User> userList, List<Group> groupList) {
    List<TaskAssignment> taskAssignmentList = new ArrayList<>(size);
    for (long i = 0; i < size; i++) {
        Task task = Task.newBuilder().id(Long.toString(i)).name("Task_" + i).priority(Integer.toString(random.nextInt(TASK_MAX_PRIORITY + 1))).build();
        TaskAssignment taskAssignment = new TaskAssignment(task);
        int groupListIndex = random.nextInt(groupList.size());
        int groupPotentialOwnersSize = TASK_POTENTIAL_OWNERS_GROUP_SIZE_MINIMUM + random.nextInt(TASK_POTENTIAL_OWNERS_GROUP_SIZE_MAXIMUM - TASK_POTENTIAL_OWNERS_GROUP_SIZE_MINIMUM);
        if (groupPotentialOwnersSize > groupList.size()) {
            groupPotentialOwnersSize = groupList.size();
        }
        for (int j = 0; j < groupPotentialOwnersSize; j++) {
            task.getPotentialGroups().add(groupList.get(groupListIndex).getId());
            groupListIndex = (groupListIndex + 1) % groupList.size();
        }
        int userListIndex = random.nextInt(userList.size());
        int userPotentialOwnersSize = TASK_POTENTIAL_OWNERS_USER_SIZE_MINIMUM + random.nextInt(TASK_POTENTIAL_OWNERS_USER_SIZE_MAXIMUM - TASK_POTENTIAL_OWNERS_USER_SIZE_MINIMUM);
        if (userPotentialOwnersSize > userList.size()) {
            userPotentialOwnersSize = userList.size();
        }
        for (int j = 0; j < userPotentialOwnersSize; j++) {
            task.getPotentialUsers().add(userList.get(userListIndex).getId());
            userListIndex = (userListIndex + 1) % userList.size();
        }
        taskAssignmentList.add(taskAssignment);
    }
    return taskAssignmentList;
}

Example 15 with Task

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

the class SolutionBuilder method build.

public TaskAssigningSolution build() {
    final List<TaskAssignment> taskAssignments = new ArrayList<>();
    final Map<String, List<IndexedElement<TaskAssignment>>> assignmentsByUserId = new HashMap<>();
    final Map<String, User> usersById = filterDuplicates(externalUsers).filter(externalUser -> !IS_PLANNING_USER.test(externalUser.getId())).map(externalUser -> fromExternalUser(externalUser, processorRegistry)).collect(Collectors.toMap(User::getId, Function.identity()));
    usersById.put(PLANNING_USER.getId(), PLANNING_USER);
    taskDataList.forEach(taskData -> {
        Task task = fromTaskData(taskData);
        processorRegistry.applyAttributesProcessor(task, task.getAttributes());
        TaskAssignment taskAssignment = new TaskAssignment(task);
        String state = task.getState();
        taskAssignments.add(taskAssignment);
        if (RESERVED.value().equals(state)) {
            addTaskAssignmentToUser(assignmentsByUserId, taskAssignment, taskData.getActualOwner(), -1, true);
        }
    });
    assignmentsByUserId.forEach((key, assignedTasks) -> {
        User user = usersById.get(key);
        if (user == null) {
            // create the user by convention.
            user = new User(key);
            usersById.put(key, user);
        }
        final List<TaskAssignment> userTasks = assignedTasks.stream().map(IndexedElement::getElement).collect(Collectors.toList());
        addAssignmentsToUser(user, userTasks);
    });
    // Add the DUMMY_TASKs to avoid running into scenarios where the solution remains with no tasks or only one task
    // for selection. (https://issues.redhat.com/browse/PLANNER-1738)
    taskAssignments.add(DUMMY_TASK_ASSIGNMENT);
    taskAssignments.add(DUMMY_TASK_ASSIGNMENT_PLANNER_1738);
    final List<User> users = new ArrayList<>(usersById.values());
    return new TaskAssigningSolution("-1", users, taskAssignments);
}