public Collection<ObjectReferenceType> getApprovedByFromTaskTree(Task task, OperationResult result) throws SchemaException { // we use a OID-keyed map to (1) keep not only the OID, but whole reference, but (2) eliminate uncertainty in comparing references Map<String,ObjectReferenceType> approvers = new HashMap<>(); List<Task> tasks = task.listSubtasksDeeply(result); tasks.add(task); for (Task aTask : tasks) { List<ObjectReferenceType> approvedBy = getApprovedBy(WfContextUtil.getWorkflowContext(aTask.getTaskPrismObject())); approvedBy.forEach(ort -> approvers.put(ort.getOid(), ort)); } return CloneUtil.cloneCollectionMembers(approvers.values()); // to ensure these are parent-less }
public static void normalizeStages(ApprovalSchemaType schema) { // Sorting uses set(..) method which is not available on prism structures. So we do sort on a copy (ArrayList). List<ApprovalStageDefinitionType> stages = getSortedStages(schema); for (int i = 0; i < stages.size(); i++) { stages.get(i).setOrder(null); stages.get(i).setNumber(i+1); } schema.getLevel().clear(); schema.getStage().clear(); schema.getStage().addAll(CloneUtil.cloneCollectionMembers(stages)); }
private void addAssignmentCreationApprovalMetadata(AssignmentType assignment, Collection<ObjectReferenceType> approvedBy, Collection<String> comments) { MetadataType metadata = assignment.getMetadata(); if (metadata == null) { assignment.setMetadata(metadata = new MetadataType(prismContext)); } metadata.getCreateApproverRef().clear(); metadata.getCreateApproverRef().addAll(CloneUtil.cloneCollectionMembers(approvedBy)); metadata.getCreateApprovalComment().clear(); metadata.getCreateApprovalComment().addAll(comments); }
private List<ApprovalStageDefinitionType> cloneAndMergeStages(List<Fragment> fragments) throws SchemaException { if (fragments.size() == 1) { return CloneUtil.cloneCollectionMembers(getStages(fragments.get(0).schema)); } PrismContext prismContext = primaryChangeAspect.getChangeProcessor().getPrismContext(); ApprovalStageDefinitionType resultingStageDef = new ApprovalStageDefinitionType(prismContext); fragments.sort((f1, f2) -> Comparator.nullsLast(Comparator.<Integer>naturalOrder()) .compare(f1.compositionStrategy.getMergePriority(), f2.compositionStrategy.getMergePriority())); for (Fragment fragment : fragments) { mergeStageDefFromFragment(resultingStageDef, fragment); } return Collections.singletonList(resultingStageDef); }
private ApprovalStageExecutionRecordType createStageExecutionRecord(WfContextType wfc, Integer stageNumberObject, int currentStageNumber) { int stageNumber = stageNumberObject; ApprovalStageExecutionRecordType rv = new ApprovalStageExecutionRecordType(prismContext); wfc.getEvent().stream() .filter(e -> e.getStageNumber() != null && e.getStageNumber() == stageNumber) .forEach(e -> rv.getEvent().add(e)); if (stageNumber == currentStageNumber) { rv.getWorkItem().addAll(CloneUtil.cloneCollectionMembers(wfc.getWorkItem())); } return rv; } }
private ApprovalSchemaType getSchema(ApprovalSchemaType schema, List<ObjectReferenceType> approverRef, List<ExpressionType> approverExpression, ExpressionType automaticallyApproved, @NotNull PrismContext prismContext) { if (schema != null) { return schema; } else { schema = new ApprovalSchemaType(prismContext); ApprovalStageDefinitionType stageDef = new ApprovalStageDefinitionType(prismContext); stageDef.getApproverRef().addAll(CloneUtil.cloneCollectionMembers(approverRef)); stageDef.getApproverExpression().addAll(approverExpression); stageDef.setAutomaticallyApproved(automaticallyApproved); schema.getStage().add(stageDef); return schema; } }
private Collection<SelectorOptions<GetOperationOptions>> updateSearchOptionsWithIterationMethod( Collection<SelectorOptions<GetOperationOptions>> searchOptions, Task localCoordinatorTask) { Collection<SelectorOptions<GetOperationOptions>> rv; IterationMethodType iterationMethod = getIterationMethodFromTask(localCoordinatorTask); if (iterationMethod != null) { rv = CloneUtil.cloneCollectionMembers(searchOptions); return SelectorOptions.updateRootOptions(rv, o -> o.setIterationMethod(iterationMethod), GetOperationOptions::new); } else { return searchOptions; } }
private List<ObjectReferenceType> computeDelegateTo(DelegateWorkItemActionType delegateAction, WorkItemType workItem, Task wfTask, Task triggerScannerTask, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { List<ObjectReferenceType> rv = new ArrayList<>(); rv.addAll(CloneUtil.cloneCollectionMembers(delegateAction.getApproverRef())); if (!delegateAction.getApproverExpression().isEmpty()) { ExpressionVariables variables = stageComputeHelper.getDefaultVariables(null, wfTask, result); variables.addVariableDefinition(SchemaConstants.C_WORK_ITEM, workItem); rv.addAll(evaluationHelper.evaluateRefExpressions(delegateAction.getApproverExpression(), variables, "computing delegates", triggerScannerTask, result)); } // if (!delegateAction.getApproverRelation().isEmpty()) { // throw new UnsupportedOperationException("Approver relation in delegate/escalate action is not supported yet."); // } return rv; }
private Collection<ItemDelta<?, ?>> bucketsAddDeltas(List<WorkBucketType> buckets) throws SchemaException { return prismContext.deltaFor(TaskType.class) .item(TaskType.F_WORK_STATE, TaskWorkStateType.F_BUCKET) .addRealValues(CloneUtil.cloneCollectionMembers(buckets)).asItemDeltas(); }
private Collection<ItemDelta<?, ?>> bucketsReplaceDeltas(List<WorkBucketType> buckets) throws SchemaException { return prismContext.deltaFor(TaskType.class) .item(TaskType.F_WORK_STATE, TaskWorkStateType.F_BUCKET) .replaceRealValues(CloneUtil.cloneCollectionMembers(buckets)).asItemDeltas(); }
private Collection<SelectorOptions<GetOperationOptions>> preProcessOptionsSecurity(Collection<SelectorOptions<GetOperationOptions>> options, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { GetOperationOptions rootOptions = SelectorOptions.findRootOptions(options); if (GetOperationOptions.isAttachDiagData(rootOptions) && !securityEnforcer.isAuthorized(AuthorizationConstants.AUTZ_ALL_URL, null, AuthorizationParameters.EMPTY, null, task, result)) { Collection<SelectorOptions<GetOperationOptions>> reducedOptions = CloneUtil.cloneCollectionMembers(options); SelectorOptions.findRootOptions(reducedOptions).setAttachDiagData(false); return reducedOptions; } else { return options; } }
public void applyDeltasImmediate(Collection<ItemDelta<?, ?>> itemDeltas, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException { if (isPersistent()) { repositoryService.modifyObject(TaskType.class, getOid(), CloneUtil.cloneCollectionMembers(itemDeltas), result); } ItemDeltaCollectionsUtil.applyTo(itemDeltas, taskPrism); synchronizeWithQuartzIfNeeded(pendingModifications, result); }
private List<ObjectReferenceType> computeDelegateTo(DelegateWorkItemActionType delegateAction, AccessCertificationWorkItemType workItem, AccessCertificationCaseType aCase, AccessCertificationCampaignType campaign, Task task, OperationResult result) { List<ObjectReferenceType> rv = CloneUtil.cloneCollectionMembers(delegateAction.getApproverRef()); if (!delegateAction.getApproverExpression().isEmpty()) { ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinition(ExpressionConstants.VAR_WORK_ITEM, workItem); variables.addVariableDefinition(ExpressionConstants.VAR_CERTIFICATION_CASE, aCase); variables.addVariableDefinition(ExpressionConstants.VAR_CAMPAIGN, campaign); for (ExpressionType expression : delegateAction.getApproverExpression()) { rv.addAll(expressionHelper.evaluateRefExpressionChecked(expression, variables, "computing delegates", task, result)); } } return rv; }
ApprovalSchemaType getSchemaFromAction(@NotNull ApprovalPolicyActionType approvalAction) { // TODO approval process if (approvalAction.getApprovalSchema() != null) { return approvalAction.getApprovalSchema().clone(); } else { ApprovalSchemaType rv = new ApprovalSchemaType(prismContext); ApprovalStageDefinitionType stageDef = new ApprovalStageDefinitionType(prismContext); stageDef.getApproverRef().addAll(CloneUtil.cloneCollectionMembers(approvalAction.getApproverRef())); stageDef.getApproverRelation().addAll(approvalAction.getApproverRelation()); stageDef.getApproverExpression().addAll(approvalAction.getApproverExpression()); stageDef.setAutomaticallyApproved(approvalAction.getAutomaticallyApproved()); // TODO maybe use name + description as well rv.getStage().add(stageDef); return rv; } }
private Collection<ItemDelta<?, ?>> createAssignmentModificationApprovalMetadata(Class<? extends Objectable> objectTypeClass, long assignmentId, Collection<ObjectReferenceType> approvedBy, Collection<String> comments) throws SchemaException { return prismContext.deltaFor(objectTypeClass) .item(FocusType.F_ASSIGNMENT, assignmentId, AssignmentType.F_METADATA, MetadataType.F_MODIFY_APPROVER_REF) .replaceRealValues(CloneUtil.cloneCollectionMembers(approvedBy)) .item(FocusType.F_ASSIGNMENT, assignmentId, AssignmentType.F_METADATA, MetadataType.F_MODIFY_APPROVAL_COMMENT) .replaceRealValues(comments) .asItemDeltas(); } }
@Override protected void updateSystemConfiguration(SystemConfigurationType systemConfiguration) throws SchemaException, IOException { super.updateSystemConfiguration(systemConfiguration); PrismObject<SystemConfigurationType> rulesContainer = prismContext.parserFor(GLOBAL_POLICY_RULES_FILE).parse(); systemConfiguration.getGlobalPolicyRule().clear(); systemConfiguration.getGlobalPolicyRule().addAll(cloneCollectionMembers(rulesContainer.asObjectable().getGlobalPolicyRule())); }
private ApprovalStageExecutionPreviewType createStageExecutionPreview(WfContextType wfc, String requestChannel, ApprovalStageDefinitionType stageDef, Task opTask, OperationResult result) { ApprovalStageExecutionPreviewType rv = new ApprovalStageExecutionPreviewType(prismContext); try { WfStageComputeHelper.ComputationResult computationResult = computeHelper .computeStageApprovers(stageDef, () -> computeHelper.getDefaultVariables(wfc, requestChannel, result), opTask, result); rv.getExpectedApproverRef().addAll(computationResult.getApproverRefs()); rv.setExpectedAutomatedOutcome(computationResult.getPredeterminedOutcome()); rv.setExpectedAutomatedCompletionReason(computationResult.getAutomatedCompletionReason()); } catch (Throwable t) { LoggingUtils.logUnexpectedException(LOGGER, "Couldn't compute stage execution preview", t); rv.setErrorMessage(MiscUtil.formatExceptionMessageWithCause(t)); rv.getExpectedApproverRef().addAll(CloneUtil.cloneCollectionMembers(stageDef.getApproverRef())); // at least something here } return rv; }
protected void executeAndCheckModification(List<ItemDelta<?, ?>> modifications, OperationResult result, int versionDelta) throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException, IOException { RepoModifyOptions modifyOptions = getModifyOptions(); if (RepoModifyOptions.isExecuteIfNoChanges(modifyOptions) && versionDelta == 0) { versionDelta = 1; } PrismObject<AccessCertificationCampaignType> before = getFullCampaign(campaign1Oid, result); int expectedVersion = Integer.parseInt(before.getVersion()) + versionDelta; List<ItemDelta> savedModifications = (List) CloneUtil.cloneCollectionMembers(modifications); repositoryService.modifyObject(AccessCertificationCampaignType.class, campaign1Oid, modifications, modifyOptions, result); checkCampaign(campaign1Oid, result, before, savedModifications, expectedVersion); }
private SceneDeltaItemImpl createSceneDeltaItem(ReferenceDelta delta, SceneImpl owningScene, VisualizationContext context, Task task, OperationResult result) throws SchemaException { SceneDeltaItemImpl di = createSceneDeltaItemCommon(delta, owningScene); di.setOldValues(toSceneItemValuesRef(delta.getEstimatedOldValues(), context, task, result)); PrismReference reference = prismContext.itemFactory().createReference(delta.getElementName()); try { if (delta.getEstimatedOldValues() != null) { reference.addAll(CloneUtil.cloneCollectionMembers(delta.getEstimatedOldValues())); } delta.applyToMatchingPath(reference, ParameterizedEquivalenceStrategy.DEFAULT_FOR_DELTA_APPLICATION); } catch (SchemaException e) { throw new SystemException("Couldn't visualize reference delta: " + delta + ": " + e.getMessage(), e); } computeAddedDeletedUnchangedRef(di, delta.getEstimatedOldValues(), reference.getValues(), context, task, result); di.setNewValues(toSceneItemValuesRef(reference.getValues(), context, task, result)); return di; }
@SuppressWarnings({ "unused", "unchecked" }) private SceneDeltaItemImpl createSceneDeltaItem(PropertyDelta<?> delta, SceneImpl owningScene, VisualizationContext context, Task task, OperationResult result) throws SchemaException { SceneDeltaItemImpl si = createSceneDeltaItemCommon(delta, owningScene); si.setOldValues(toSceneItemValues(delta.getEstimatedOldValues())); PrismProperty property = prismContext.itemFactory().createProperty(delta.getElementName()); if (delta.getEstimatedOldValues() != null) { property.addValues(CloneUtil.cloneCollectionMembers(delta.getEstimatedOldValues())); } try { delta.applyToMatchingPath(property, ParameterizedEquivalenceStrategy.DEFAULT_FOR_DELTA_APPLICATION); } catch (SchemaException e) { throw new SystemException("Couldn't visualize property delta: " + delta + ": " + e.getMessage(), e); } computeAddedDeletedUnchanged(si, delta.getEstimatedOldValues(), property.getValues()); si.setNewValues(toSceneItemValues(property.getValues())); return si; }