How to use

getAssigneeRef

method

in

com.evolveum.midpoint.xml.ns._public.common.common_3.WorkItemType

public WorkItemType assigneeRef(ObjectReferenceType value) {
  getAssigneeRef().add(value);
  return this;
}

public List<ObjectReferenceType> getAssigneesAndDeputies(WorkItemType workItem, Task task, OperationResult result)
    throws SchemaException {
  List<ObjectReferenceType> rv = new ArrayList<>();
  rv.addAll(workItem.getAssigneeRef());
  rv.addAll(modelInteractionService.getDeputyAssignees(workItem, task, result));
  return rv;
}
//endregion

private void appendAssigneeInformation(StringBuilder sb, WorkItemEvent event, OperationResult result) {
  WorkItemType workItem = event.getWorkItem();
  ObjectReferenceType originalAssignee = workItem.getOriginalAssigneeRef();
  List<ObjectReferenceType> currentAssignees = workItem.getAssigneeRef();
  boolean atLeastOne = false;
  if (currentAssignees.size() != 1 || !java.util.Objects.equals(originalAssignee.getOid(), currentAssignees.get(0).getOid())) {
    UserType originalAssigneeObject = (UserType) functions.getObjectType(originalAssignee, true, result);
    sb.append("Originally allocated to: ").append(
        textFormatter.formatUserName(originalAssigneeObject, originalAssignee.getOid())).append("\n");
    atLeastOne = true;
  }
  if (!workItem.getAssigneeRef().isEmpty()) {
    sb.append("Allocated to");
    if (event.getOperationKind() == WorkItemOperationKindType.DELEGATE) {
      sb.append(event.isAdd() ? " (after delegation)" : " (before delegation)");
    } else if (event.getOperationKind() == WorkItemOperationKindType.ESCALATE) {
      sb.append(event.isAdd() ? " (after escalation)" : " (before escalation)");
    }
    sb.append(": ");
    sb.append(workItem.getAssigneeRef().stream()
        .map(ref -> textFormatter.formatUserName(ref, result))
        .collect(Collectors.joining(", ")));
    sb.append("\n");
    atLeastOne = true;
  }
  if (atLeastOne) {
    sb.append("\n");
  }
}

@Test
public void test110DelegateToUser2Unauthorized() throws Exception {
  final String TEST_NAME = "test110DelegateToUser2Unauthorized";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userLead3);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  try {
    workflowService.delegateWorkItem(workItemId, Collections.singletonList(ort(userLead2Oid)), ADD_ASSIGNEES, result);
    fail("delegate succeeded even if it shouldn't");
  } catch (SecurityViolationException e) {
    // ok
  }
  WorkItemType workItem = getWorkItem(task, result);
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid);
}

public boolean isAuthorized(WorkItemType workItem, RequestedOperation operation, Task task, OperationResult result) throws ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException {
  MidPointPrincipal principal;
  try {
    principal = securityContextManager.getPrincipal();
  } catch (SecurityViolationException e) {
    return false;
  }
  if (principal.getOid() == null) {
    return false;
  }
  try {
    if (securityEnforcer.isAuthorized(operation.actionAll.getUrl(), null, AuthorizationParameters.EMPTY, null, task, result)) {
      return true;
    }
    if (operation.actionOwn != null && !securityEnforcer.isAuthorized(operation.actionOwn.getUrl(), null, AuthorizationParameters.EMPTY, null, task, result)) {
      return false;
    }
  } catch (SchemaException e) {
    throw new SystemException(e.getMessage(), e);
  }
  for (ObjectReferenceType assignee : workItem.getAssigneeRef()) {
    if (isEqualOrDeputyOf(principal, assignee.getOid(), relationRegistry)) {
      return true;
    }
  }
  return isAmongCandidates(principal, workItem.getExternalId());
}

wi.getAssigneeRef().addAll(getMidpointAssignees(task));
String originalAssigneeString = ActivitiUtil.getVariable(variables,
    CommonProcessVariableNames.VARIABLE_ORIGINAL_ASSIGNEE, String.class, prismContext);
  miscDataUtil.resolveAndStoreObjectReferences(wi.getAssigneeRef(), result);
  miscDataUtil.resolveAndStoreObjectReference(wi.getOriginalAssigneeRef(), result);

@Test
public void test120DelegateToUser2() throws Exception {
  final String TEST_NAME = "test120DelegateToUser2";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userLead1);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  workflowService.delegateWorkItem(workItemId, Collections.singletonList(ort(userLead2Oid)), ADD_ASSIGNEES, result);
  result.computeStatus();
  assertSuccess(result);
  WorkItemType workItem = getWorkItem(task, result);
  display("work item", workItem);
  PrismObject<TaskType> wfTask = getObjectViaRepo(TaskType.class, taskOid);
  display("task", wfTask);
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid, userLead2Oid);
  assertRefEquals("Wrong originalAssigneeRef", ort(userLead1Oid), workItem.getOriginalAssigneeRef());
  org.activiti.engine.task.Task activitiTask = activitiEngine.getTaskService().createTaskQuery()
      .taskId(workItem.getExternalId())
      .singleResult();
  System.out.println("Activiti task: " + activitiTask);
  assertEquals("Wrong activiti assignee", "UserType:"+userLead1Oid, activitiTask.getAssignee());
  List<String> assignees = getAssignees(activitiTask);
  assertEquals("Wrong midpoint-assignee values", new HashSet<>(Arrays.asList("UserType:" + userLead1Oid, "UserType:" + userLead2Oid)),
      new HashSet<>(assignees));
  List<WorkItemDelegationEventType> events = WfContextUtil.getWorkItemEvents(wfTask.asObjectable().getWorkflowContext(), workItemId, WorkItemDelegationEventType.class);
  assertEquals("Wrong # of delegation events", 1, events.size());
  // TODO check content
}

display("task", wfTask);
assertEquals("Wrong assigneeRef count", 0, workItem.getAssigneeRef().size());
assertRefEquals("Wrong originalAssigneeRef", ort(userLead1Oid), workItem.getOriginalAssigneeRef());

@Test
public void test130DelegateToUser3ByReplace() throws Exception {
  final String TEST_NAME = "test130DelegateToUser3ByReplace";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userLead1);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  workflowService.delegateWorkItem(workItemId, Collections.singletonList(ort(userLead3Oid)), REPLACE_ASSIGNEES, result);
  result.computeStatus();
  assertSuccess(result);
  WorkItemType workItem = getWorkItem(task, result);
  display("work item", workItem);
  PrismObject<TaskType> wfTask = getObjectViaRepo(TaskType.class, taskOid);
  display("task", wfTask);
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead3Oid);
  assertRefEquals("Wrong originalAssigneeRef", ort(userLead1Oid), workItem.getOriginalAssigneeRef());
  org.activiti.engine.task.Task activitiTask = activitiEngine.getTaskService().createTaskQuery()
      .taskId(workItem.getExternalId())
      .singleResult();
  System.out.println("Activiti task: " + activitiTask);
  assertEquals("Wrong activiti assignee", "UserType:"+userLead3Oid, activitiTask.getAssignee());
  List<String> assignees = getAssignees(activitiTask);
  assertEquals("Wrong midpoint-assignee values", Collections.singleton("UserType:" + userLead3Oid),
      new HashSet<>(assignees));
  List<WorkItemDelegationEventType> events = WfContextUtil.getWorkItemEvents(wfTask.asObjectable().getWorkflowContext(), workItemId, WorkItemDelegationEventType.class);
  assertEquals("Wrong # of delegation events", 2, events.size());
  // TODO check content
}

@Test
public void test110Notify() throws Exception {
  final String TEST_NAME = "test110Notify";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userAdministrator);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  clock.overrideDuration("P6D");			// at P5D there's a notify action
  waitForTaskNextRun(TASK_TRIGGER_SCANNER_OID, true, 20000, true);
  // TODO assert notifications
  WorkItemType workItem = getWorkItem(task, result);
  display("work item", workItem);
  String wfTaskOid = WfContextUtil.getTask(workItem).getOid();
  PrismObject<TaskType> wfTask = getTask(wfTaskOid);
  display("task", wfTask);
  assertEquals("Wrong # of triggers", 2, wfTask.asObjectable().getTrigger().size());
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid);
  PrismAsserts.assertReferenceValue(ref(workItem.getOriginalAssigneeRef()), userLead1Oid);
}

@Test
public void test120Escalate() throws Exception {
  final String TEST_NAME = "test120Escalate";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userAdministrator);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  clock.resetOverride();
  clock.overrideDuration("P13D");		// at -P2D (i.e. P12D) there is a delegate action
  waitForTaskNextRun(TASK_TRIGGER_SCANNER_OID, true, 20000, true);
  WorkItemType workItem = getWorkItem(task, result);
  display("work item", workItem);
  PrismObject<TaskType> wfTask = getTask(WfContextUtil.getTask(workItem).getOid());
  display("task", wfTask);
  assertEquals("Wrong # of triggers", 1, wfTask.asObjectable().getTrigger().size());
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid, userLead2Oid);
  PrismAsserts.assertReferenceValue(ref(workItem.getOriginalAssigneeRef()), userLead1Oid);
  assertEquals("Wrong escalation level number", 1, WfContextUtil.getEscalationLevelNumber(workItem));
}

@Test
public void test100CreateTask() throws Exception {
  final String TEST_NAME = "test100CreateTask";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userAdministrator);
  userLead1 = getUser(userLead1Oid);
  userLead3 = getUser(userLead3Oid);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  assignRole(userJackOid, roleRole1aOid, task, result);                // should start approval process
  assertNotAssignedRole(userJackOid, roleRole1aOid, task, result);
  WorkItemType workItem = getWorkItem(task, result);
  workItemId = workItem.getExternalId();
  taskOid = WfContextUtil.getTask(workItem).getOid();
  display("work item", workItem);
  display("task", getObjectViaRepo(TaskType.class, taskOid));
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid);
}

@Test
public void test100CreateTask() throws Exception {
  final String TEST_NAME = "test100CreateTask";
  TestUtil.displayTestTitle(this, TEST_NAME);
  login(userAdministrator);
  Task task = createTask(TEST_NAME);
  OperationResult result = task.getResult();
  assignRole(userJackOid, roleE1Oid, task, result);                // should start approval process
  assertNotAssignedRole(userJackOid, roleE1Oid, task, result);
  WorkItemType workItem = getWorkItem(task, result);
  workItemId = workItem.getExternalId();
  approvalTaskOid = WfContextUtil.getTask(workItem).getOid();
  PrismObject<TaskType> wfTask = getTask(approvalTaskOid);
  display("work item", workItem);
  display("workflow task", wfTask);
  // 5 days: notification
  // D-2 days: escalate
  // D-0 days: approve
  assertEquals("Wrong # of triggers", 3, wfTask.asObjectable().getTrigger().size());
  PrismAsserts.assertReferenceValues(ref(workItem.getAssigneeRef()), userLead1Oid);
  PrismAsserts.assertReferenceValue(ref(workItem.getOriginalAssigneeRef()), userLead1Oid);
}

List<ObjectReferenceType> assigneesBefore = CloneUtil.cloneCollectionMembers(workItem.getAssigneeRef());
List<ObjectReferenceType> assigneesAndDeputiesBefore = wfTaskController.getAssigneesAndDeputies(workItem, opTask, result);

public AuditEventRecord prepareWorkItemAuditReportCommon(WorkItemType workItem, WfTask wfTask, AuditEventStage stage,
    OperationResult result) throws WorkflowException {
  AuditEventRecord record = new AuditEventRecord();
  record.setEventType(AuditEventType.WORK_ITEM);
  record.setEventStage(stage);
  ObjectReferenceType objectRef = resolveIfNeeded(WfContextUtil.getObjectRef(workItem), result);
  record.setTarget(objectRef.asReferenceValue());
  record.setOutcome(OperationResultStatus.SUCCESS);
  record.setParameter(wfTask.getCompleteStageInfo());
  record.addReferenceValueIgnoreNull(WorkflowConstants.AUDIT_OBJECT, objectRef);
  record.addReferenceValueIgnoreNull(WorkflowConstants.AUDIT_TARGET, resolveIfNeeded(WfContextUtil.getTargetRef(workItem), result));
  record.addReferenceValueIgnoreNull(WorkflowConstants.AUDIT_ORIGINAL_ASSIGNEE, resolveIfNeeded(workItem.getOriginalAssigneeRef(), result));
  record.addReferenceValues(WorkflowConstants.AUDIT_CURRENT_ASSIGNEE, resolveIfNeeded(workItem.getAssigneeRef(), result));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_STAGE_NUMBER, workItem.getStageNumber());
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_STAGE_COUNT, WfContextUtil.getStageCount(workItem));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_STAGE_NAME, WfContextUtil.getStageName(workItem));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_STAGE_DISPLAY_NAME, WfContextUtil.getStageDisplayName(workItem));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_ESCALATION_LEVEL_NUMBER, WfContextUtil.getEscalationLevelNumber(workItem));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_ESCALATION_LEVEL_NAME, WfContextUtil.getEscalationLevelName(workItem));
  record.addPropertyValueIgnoreNull(WorkflowConstants.AUDIT_ESCALATION_LEVEL_DISPLAY_NAME, WfContextUtil.getEscalationLevelDisplayName(workItem));
  record.addPropertyValue(WorkflowConstants.AUDIT_WORK_ITEM_ID, workItem.getExternalId());
  record.addPropertyValue(WorkflowConstants.AUDIT_PROCESS_INSTANCE_ID, WfContextUtil.getProcessInstanceId(workItem));
  return record;
}

    new WorkItemAllocationChangeOperationInfo(operationKind, assigneesAndDeputies, null);
WorkItemOperationSourceInfo sourceInfo = new WorkItemOperationSourceInfo(userRef, cause, null);
if (workItem.getAssigneeRef().isEmpty()) {
  notifyWorkItemDeleted(null, workItem, operationInfo, sourceInfo, wfTask, result);
} else {