List<ItemDelta<?, ?>> createTriggerReplaceDelta(Collection<TriggerType> triggers) throws SchemaException { return prismContext.deltaFor(AccessCertificationCampaignType.class) .item(AccessCertificationCampaignType.F_TRIGGER).replaceRealValues(triggers) .asItemDeltas(); }
protected void resetTriggerTask(String taskOid, File taskFile, OperationResult result) throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException, FileNotFoundException { taskManager.suspendAndDeleteTasks(Collections.singletonList(taskOid), 60000L, true, result); importObjectFromFile(taskFile, result); taskManager.suspendTasks(Collections.singletonList(taskOid), 60000L, result); modifySystemObjectInRepo(TaskType.class, taskOid, prismContext.deltaFor(TaskType.class) .item(TaskType.F_SCHEDULE).replace() .asItemDeltas(), result); taskManager.resumeTasks(singleton(taskOid), result); }
private Collection<ItemDelta<?, ?>> bucketDeleteDeltas(WorkBucketType bucket) throws SchemaException { return prismContext.deltaFor(TaskType.class) .item(TaskType.F_WORK_STATE, TaskWorkStateType.F_BUCKET) .delete(bucket.clone()).asItemDeltas(); }
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<?, ?>> bucketStateChangeDeltas(WorkBucketType bucket, WorkBucketStateType newState) throws SchemaException { return prismContext.deltaFor(TaskType.class) .item(TaskType.F_WORK_STATE, TaskWorkStateType.F_BUCKET, bucket.getId(), WorkBucketType.F_STATE) .replace(newState).asItemDeltas(); }
public static void deleteSchema(PrismObject<ResourceType> resource, ModelService modelService, PrismContext prismContext, Task task, OperationResult parentResult) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { PrismProperty<SchemaDefinitionType> definition = resource.findProperty(SCHEMA_PATH); if (definition != null && !definition.isEmpty()) { ObjectDelta<ResourceType> delta = prismContext.deltaFor(ResourceType.class) .item(SCHEMA_PATH).replace() .asObjectDelta(resource.getOid()); modelService.executeChanges(singleton(delta), null, task, parentResult); } } }
public void setProcessInstanceStageInformation(Integer stageNumber, Integer stageCount, String stageName, String stageDisplayName) throws SchemaException { task.addModifications(getPrismContext().deltaFor(TaskType.class) .item(F_WORKFLOW_CONTEXT, F_STAGE_NUMBER).replace(stageNumber) .asItemDeltas()); } }
@SuppressWarnings("unchecked") private ObjectDelta<? extends FocusType> assignmentToDelta(Class<? extends Objectable> focusClass, AssignmentType assignmentType, boolean assignmentRemoved, String objectOid) throws SchemaException { PrismContainerValue value = assignmentType.clone().asPrismContainerValue(); S_ValuesEntry item = prismContext.deltaFor(focusClass) .item(FocusType.F_ASSIGNMENT); S_ItemEntry op = assignmentRemoved ? item.delete(value) : item.add(value); return op.asObjectDelta(objectOid); }
private static void removeSelectedTriggers(Task wfTask, List<PrismContainerValue<TriggerType>> toDelete, OperationResult result) { try { LOGGER.trace("About to delete {} triggers from {}: {}", toDelete.size(), wfTask, toDelete); List<ItemDelta<?, ?>> itemDeltas = getPrismContext().deltaFor(TaskType.class) .item(TaskType.F_TRIGGER).delete(toDelete) .asItemDeltas(); getCacheRepositoryService().modifyObject(TaskType.class, wfTask.getOid(), itemDeltas, result); } catch (SchemaException|ObjectNotFoundException|ObjectAlreadyExistsException|RuntimeException e) { LoggingUtils.logUnexpectedException(LOGGER, "Couldn't remove triggers from task {}", e, wfTask); } }
private void setOrUpdateEstimatedNumberOfBuckets(Task task, WorkSegmentationStrategy workStateStrategy, OperationResult result) throws SchemaException, ObjectAlreadyExistsException, ObjectNotFoundException { Integer number = workStateStrategy.estimateNumberOfBuckets(task.getWorkState()); if (number != null && (task.getWorkState() == null || !number.equals(task.getWorkState().getNumberOfBuckets()))) { List<ItemDelta<?, ?>> itemDeltas = prismContext.deltaFor(TaskType.class) .item(TaskType.F_WORK_STATE, TaskWorkStateType.F_NUMBER_OF_BUCKETS).replace(number) .asItemDeltas(); repositoryService.modifyObject(TaskType.class, task.getOid(), itemDeltas, result); } }
protected void clearUserPassword(String userOid) throws SchemaException, ObjectAlreadyExistsException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { Task task = createTask("clearUserPassword"); OperationResult result = task.getResult(); List<ItemDelta<?,?>> itemDeltas = prismContext.deltaFor(UserType.class) .item(SchemaConstants.PATH_PASSWORD).replace() .asItemDeltas(); repositoryService.modifyObject(UserType.class, userOid, itemDeltas, result); assertSuccess(result); }
private ItemDelta createStageEndTimeDelta(AccessCertificationCampaignType campaign, XMLGregorianCalendar now) throws SchemaException { AccessCertificationStageType stage = CertCampaignTypeUtil.findStage(campaign, campaign.getStageNumber()); Long stageId = stage.asPrismContainerValue().getId(); assert stageId != null; return prismContext.deltaFor(AccessCertificationCampaignType.class) .item(F_STAGE, stageId, F_END_TIMESTAMP).replace(now) .asItemDelta(); }
protected void modifyUserSetPassword(String userOid, String newPassword, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, ObjectAlreadyExistsException, PolicyViolationException, SecurityViolationException { ProtectedStringType userPasswordPs = new ProtectedStringType(); userPasswordPs.setClearValue(newPassword); PasswordType passwordType = new PasswordType(); passwordType.setValue(userPasswordPs); ObjectDelta<UserType> delta = prismContext.deltaFor(UserType.class) .item(SchemaConstants.PATH_PASSWORD).add(passwordType) .asObjectDelta(userOid); executeChanges(delta, null, task, result); }
@Test public void test120ObjectModifyName() throws Exception { System.out.println("===[ test120ObjectModifyName ]===="); ObjectDelta<?> delta = getPrismContext().deltaFor(UserType.class) .item(UserType.F_NAME).replace(PolyString.fromOrig("jack")) .asObjectDelta("123456"); roundTrip(delta); }
@Test public void test220AddRemoveValues() throws Exception { OperationResult result = new OperationResult("test220AddRemoveValues"); List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class) .item(F_ROW, 1, F_VALUE).delete("first value") .item(F_ROW, 2, F_VALUE).add("value 2") .asItemDeltas(); executeAndCheckModification(modifications, result, 0, Arrays.asList("key 1", "2 key")); }
private void moveWorker(Task worker, WorkerKey shouldBe, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException { List<ItemDelta<?, ?>> itemDeltas = prismContext.deltaFor(TaskType.class) .item(TaskType.F_EXECUTION_CONSTRAINTS, TaskExecutionConstraintsType.F_GROUP).replace(shouldBe.group) .item(TaskType.F_NAME).replace(PolyString.fromOrig(shouldBe.name)) .asItemDeltas(); LOGGER.info("Moving worker task {} to {} as {}", worker, shouldBe.group, shouldBe.name); taskManager.modifyTask(worker.getOid(), itemDeltas, result); }
private void changeEmployeeIdRaw(String id, Task initTask, OperationResult initResult) throws CommonException { executeChanges( (ObjectDelta) prismContext.deltaFor(UserType.class) .item(UserType.F_EMPLOYEE_NUMBER).replace(id) .asObjectDelta(USER_ELAINE_OID), ModelExecuteOptions.createRaw(), initTask, initResult); }
@Override Collection<ItemDelta<?, ?>> getItemDeltas() throws Exception { return prismContext.deltaFor(UserType.class) .item(UserType.F_OPERATION_EXECUTION).add( new OperationExecutionType(prismContext) .channel(threadIndex + ":" + counter) .timestamp(XmlTypeConverter.createXMLGregorianCalendar(new Date()))) .asItemDeltas(); } };
@Test public void test252DeleteNonexistingRow() throws Exception { OperationResult result = new OperationResult("test252DeleteNonexistingRow"); LookupTableRowType rowNoId = new LookupTableRowType(prismContext); rowNoId.setKey("non-existing-key"); List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class) .item(F_ROW).delete(rowNoId) .asItemDeltas(); executeAndCheckModification(modifications, result, 0, null); }
@Test public void test265ReplaceRowsNewId() throws Exception { OperationResult result = new OperationResult("test265ReplaceRowsNewId"); LookupTableRowType rowNoId = new LookupTableRowType(prismContext); rowNoId.setKey("key new plus"); rowNoId.setValue("value now plus"); List<ItemDelta<?,?>> modifications = prismContext.deltaFor(LookupTableType.class) .item(F_ROW).replace(rowNoId) .asItemDeltas(); executeAndCheckModification(modifications, result, 0, keysOf(rowNoId)); }