private void distributeResourceDelta(ObjectDelta<ShadowType> delta, PrismObject<ResourceType> resource) { if (delta == null) { return; } if (delta.isAdd()) { distributeResourceObject(delta.getObjectToAdd(), resource); } else if (delta.isModify()) { ReferenceDelta referenceDelta = delta.findReferenceModification(ShadowType.F_RESOURCE_REF); if (referenceDelta != null) { distributeResourceValues(referenceDelta.getValuesToAdd(), resource); distributeResourceValues(referenceDelta.getValuesToDelete(), resource); distributeResourceValues(referenceDelta.getValuesToReplace(), resource); } } // Nothing to do for DELETE delta }
public static <O extends Objectable> void fillInModificationAddReference(ObjectDelta<O> objectDelta, ItemPath refPath, PrismReferenceValue... refValues) { ReferenceDelta refDelta = objectDelta.createReferenceModification(refPath); if (refValues != null) { refDelta.addValuesToAdd(refValues); objectDelta.addModification(refDelta); } }
static <O extends Objectable> void fillInModificationDeleteReference(ObjectDelta<O> objectDelta, ItemPath refPath, PrismReferenceValue... refValues) { ReferenceDelta refDelta = objectDelta.createReferenceModification(refPath); if (refValues != null) { refDelta.addValuesToDelete(refValues); objectDelta.addModification(refDelta); } }
linkRefDelta.addValuesToAdd(PrismValueCollectionsUtil.cloneValues(linkRef.getValues())); } else if (focusPrimaryDelta.getChangeType() == ChangeType.MODIFY) { linkRefDelta = focusPrimaryDelta.findReferenceModification(FocusType.F_LINK_REF); if (linkRefDelta.isReplace()) { linkRefDelta = (ReferenceDelta) linkRefDelta.clone(); PrismReference linkRef = focus.findReference(FocusType.F_LINK_REF); linkRefDelta.distributeReplace(linkRef == null ? null : linkRef.getValues()); if (linkRefDelta.getValuesToAdd() != null) { for (PrismReferenceValue refVal : linkRefDelta.getValuesToAdd()) { String oid = refVal.getOid(); LensProjectionContext projectionContext = null; if (linkRefDelta.getValuesToDelete() != null) { for (PrismReferenceValue refVal : linkRefDelta.getValuesToDelete()) { String oid = refVal.getOid(); LensProjectionContext projectionContext = null;
@Test public void testSummarize06() throws Exception { final String TEST_NAME="testSummarize06"; displayTestTitle(TEST_NAME); // GIVEN PrismReferenceDefinition referenceDefinition = new PrismReferenceDefinitionImpl(UserType.F_PARENT_ORG_REF, OBJECT_REFERENCE_TYPE_QNAME, PrismTestUtil.getPrismContext()); ReferenceDelta delta1 = new ReferenceDeltaImpl(referenceDefinition, PrismTestUtil.getPrismContext()); delta1.addValueToAdd(new PrismReferenceValueImpl("oid1")); ObjectDelta<UserType> objectDelta1 = new ObjectDeltaImpl<>(UserType.class, ChangeType.MODIFY, PrismTestUtil.getPrismContext()); objectDelta1.addModification(delta1); ReferenceDelta delta2 = new ReferenceDeltaImpl(referenceDefinition, PrismTestUtil.getPrismContext()); delta2.addValueToAdd(new PrismReferenceValueImpl("oid1")); // here we add the same value ObjectDelta<UserType> objectDelta2 = new ObjectDeltaImpl<>(UserType.class, ChangeType.MODIFY, PrismTestUtil.getPrismContext()); objectDelta2.addModification(delta2); // WHEN ObjectDelta<UserType> sumDelta = ObjectDeltaCollectionsUtil.summarize(objectDelta1, objectDelta2); // THEN System.out.println("Summarized delta:"); System.out.println(sumDelta.debugDump()); PrismAsserts.assertModifications(sumDelta, 1); ReferenceDelta modification = (ReferenceDelta) sumDelta.getModifications().iterator().next(); PrismAsserts.assertNoReplace(modification); assertEquals("Invalid number of values to add", 1, modification.getValuesToAdd().size()); PrismAsserts.assertNoDelete(modification); }
public static void assertReferenceAdd(ObjectDelta<?> objectDelta, QName refName, String... expectedOids) { ReferenceDelta refDelta = objectDelta.findReferenceModification(ItemName.fromQName(refName)); assertNotNull("Reference delta for "+refName+" not found",refDelta); assertOidSet("delta "+refDelta+" for "+refName, "add", refDelta.getValuesToAdd(), expectedOids); }
newValue.setRelation(SchemaConstants.ORG_MANAGER); referenceDelta.addValueToDelete(oldValue); referenceDelta.addValueToAdd(newValue); modifications.add(referenceDelta);
public static void assertReferenceReplace(ObjectDelta<?> objectDelta, QName refName, String... expectedOids) { ReferenceDelta refDelta = objectDelta.findReferenceModification(ItemName.fromQName(refName)); assertNotNull("Reference delta for "+refName+" not found",refDelta); assertOidSet("delta "+refDelta+" for "+refName, "replace", refDelta.getValuesToReplace(), expectedOids); }
public static void assertReferenceDelete(ObjectDelta<?> objectDelta, QName refName, String... expectedOids) { ReferenceDelta refDelta = objectDelta.findReferenceModification(ItemName.fromQName(refName)); assertNotNull("Reference delta for "+refName+" not found",refDelta); assertOidSet("delta "+refDelta+" for "+refName, "delete", refDelta.getValuesToDelete(), expectedOids); }
public static <O extends Objectable> void fillInModificationReplaceReference(ObjectDelta<O> objectDelta, ItemPath refPath, PrismReferenceValue... refValues) { ReferenceDelta refDelta = objectDelta.createReferenceModification(refPath); if (refValues != null) { refDelta.setValuesToReplace(refValues); objectDelta.addModification(refDelta); } }
OBJECT_REFERENCE_TYPE_QNAME, PrismTestUtil.getPrismContext()); ReferenceDelta delta2 = new ReferenceDeltaImpl(referenceDefinition, PrismTestUtil.getPrismContext()); delta2.addValueToAdd(new PrismReferenceValueImpl("oid1")); assertPath(delta2, UserType.F_PARENT_ORG_REF);
@Test public void testRefWithObject() throws SchemaException, IOException, JAXBException { System.out.println("===[ testRefWithObject ]===="); ObjectModificationType objectChange = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, "user-modify-add-account.xml"), ObjectModificationType.COMPLEX_TYPE); ObjectDelta<UserType> objectDelta = DeltaConvertor.createObjectDelta(objectChange, UserType.class, getPrismContext()); System.out.println("delta: " + objectDelta.debugDump()); assertNotNull("No object delta", objectDelta); objectDelta.checkConsistence(); assertEquals("Wrong OID", "c0c010c0-d34d-b33f-f00d-111111111111", objectDelta.getOid()); ReferenceDelta accoutRefDelta = objectDelta.findReferenceModification(UserType.F_LINK_REF); assertNotNull("No accountRef delta", accoutRefDelta); Collection<PrismReferenceValue> valuesToAdd = accoutRefDelta.getValuesToAdd(); assertEquals("Wrong number of values to add", 1, valuesToAdd.size()); PrismReferenceValue accountRefVal = valuesToAdd.iterator().next(); assertNotNull("No object in accountRef value", accountRefVal.getObject()); objectDelta.assertDefinitions(); }
ObjectReferenceType objectRef = null; ReferenceDelta delta = prismContext.deltaFactory().reference().create(def); delta.addValueToAdd(itemFactory().createReferenceValue("1", ResourceType.COMPLEX_TYPE)); modifications.add(delta); repositoryService.modifyObject(TaskType.class, taskOid, modifications, getModifyOptions(), result); modifications.clear(); delta = prismContext.deltaFactory().reference().create(def); delta.addValueToDelete(itemFactory().createReferenceValue("1", ResourceType.COMPLEX_TYPE)); delta.addValueToAdd(itemFactory().createReferenceValue("2", ResourceType.COMPLEX_TYPE)); modifications.add(delta); repositoryService.modifyObject(TaskType.class, taskOid, modifications, getModifyOptions(), result); delta.addValueToDelete(itemFactory().createReferenceValue("2", ResourceType.COMPLEX_TYPE)); delta.addValueToAdd(itemFactory().createReferenceValue("1", ResourceType.COMPLEX_TYPE)); modifications.add(delta); repositoryService.modifyObject(TaskType.class, taskOid, modifications, getModifyOptions(), result);
/** * Convenience method for quick creation of object deltas that replace a single object property. This is used quite often * to justify a separate method. */ @Override public <O extends Objectable> ObjectDelta<O> createModificationAddReference(Class<O> type, String oid, QName propertyName, PrismObject<?>... referenceObjects) { ObjectDelta<O> objectDelta = create(type, ChangeType.MODIFY); objectDelta.setOid(oid); PrismObjectDefinition<O> objDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); PrismReferenceDefinition refDef = objDef.findReferenceDefinition(ItemName.fromQName(propertyName)); ReferenceDelta referenceDelta = objectDelta.createReferenceModification(ItemName.fromQName(propertyName), refDef); Collection<PrismReferenceValue> valuesToReplace = new ArrayList<>(referenceObjects.length); for (PrismObject<?> refObject: referenceObjects) { valuesToReplace.add(prismContext.itemFactory().createReferenceValue(refObject)); } referenceDelta.setValuesToReplace(valuesToReplace); return objectDelta; }
private void assertResolvedResourceRefs(ObjectDelta<ShadowType> delta, String desc) { if (delta == null) { return; } if (delta.isAdd()) { assertResolvedResourceRefs(delta.getObjectToAdd(), desc); } else if (delta.isModify()) { ReferenceDelta referenceDelta = delta.findReferenceModification(ShadowType.F_RESOURCE_REF); if (referenceDelta != null) { assertResolvedResourceRefs(referenceDelta.getValuesToAdd(), "valuesToAdd in "+desc); assertResolvedResourceRefs(referenceDelta.getValuesToDelete(), "valuesToDelete in "+desc); assertResolvedResourceRefs(referenceDelta.getValuesToReplace(), "valuesToReplace in "+desc); } } }
@Test public void testModifyInducement() throws Exception { System.out.println("===[ testModifyInducement ]===="); ObjectModificationType objectChange = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, "role-modify-inducement.xml"), ObjectModificationType.COMPLEX_TYPE); // WHEN ObjectDelta<RoleType> objectDelta = DeltaConvertor.createObjectDelta(objectChange, RoleType.class, getPrismContext()); System.out.println("Delta:"); System.out.println(objectDelta.debugDump()); // THEN assertNotNull("No object delta", objectDelta); objectDelta.checkConsistence(); assertEquals("Wrong OID", "00000000-8888-6666-0000-100000000005", objectDelta.getOid()); ReferenceDelta targetRefDelta = objectDelta.findReferenceModification(ItemPath.create(RoleType.F_INDUCEMENT, 5L, AssignmentType.F_TARGET_REF)); assertNotNull("No targetRef delta", targetRefDelta); Collection<PrismReferenceValue> valuesToAdd = targetRefDelta.getValuesToAdd(); assertEquals("Wrong number of values to add", 1, valuesToAdd.size()); PrismReferenceValue targetRefVal = valuesToAdd.iterator().next(); assertNotNull("Null value in targetRef delta", targetRefVal); assertEquals("wrong OID in targetRef", "12345678-d34d-b33f-f00d-987987987987", targetRefVal.getOid()); assertEquals("wrong target type in targetRef", RoleType.COMPLEX_TYPE, targetRefVal.getTargetType()); }
/** * Convenience method for quick creation of object deltas that replace a single object property. This is used quite often * to justify a separate method. */ @Override public <O extends Objectable> ObjectDelta<O> createModificationDeleteReference(Class<O> type, String oid, QName propertyName, PrismReferenceValue... referenceValues) { ObjectDelta<O> objectDelta = create(type, ChangeType.MODIFY); objectDelta.setOid(oid); PrismObjectDefinition<O> objDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); PrismReferenceDefinition refDef = objDef.findReferenceDefinition(ItemName.fromQName(propertyName)); ReferenceDelta referenceDelta = objectDelta.createReferenceModification(ItemName.fromQName(propertyName), refDef); Collection<PrismReferenceValue> valuesToDelete = new ArrayList<>(referenceValues.length); for (PrismReferenceValue refVal: referenceValues) { valuesToDelete.add(refVal); } referenceDelta.addValuesToDelete(valuesToDelete); return objectDelta; }
private <F extends ObjectType> void setReferences(LensFocusContext<F> focusContext, QName name, Collection<PrismReferenceValue> targetState) throws SchemaException { ItemName itemName = ItemName.fromQName(name); PrismObject<F> focusOld = focusContext.getObjectOld(); if (focusOld == null) { if (targetState.isEmpty()) { return; } } else { PrismReference existingState = focusOld.findReference(itemName); if (existingState == null || existingState.isEmpty()) { if (targetState.isEmpty()) { return; } } else { // we don't use QNameUtil.match here, because we want to ensure we store qualified values there // (and newValues are all qualified) Comparator<PrismReferenceValue> comparator = (a, b) -> 2*a.getOid().compareTo(b.getOid()) + (Objects.equals(a.getRelation(), b.getRelation()) ? 0 : 1); if (MiscUtil.unorderedCollectionCompare(targetState, existingState.getValues(), comparator)) { return; } } } PrismReferenceDefinition itemDef = focusContext.getObjectDefinition().findItemDefinition(itemName, PrismReferenceDefinition.class); ReferenceDelta itemDelta = prismContext.deltaFactory().reference().create(itemName, itemDef); itemDelta.setValuesToReplace(targetState); focusContext.swallowToSecondaryDelta(itemDelta); }
/** * Convenience method for quick creation of object deltas that replace a single object property. This is used quite often * to justify a separate method. */ @Override public <O extends Objectable> ObjectDelta<O> createModificationAddReference(Class<O> type, String oid, QName propertyName, PrismReferenceValue... referenceValues) { ObjectDelta<O> objectDelta = create(type, ChangeType.MODIFY); objectDelta.setOid(oid); PrismObjectDefinition<O> objDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); PrismReferenceDefinition refDef = objDef.findReferenceDefinition(ItemName.fromQName(propertyName)); ReferenceDelta referenceDelta = objectDelta.createReferenceModification(ItemName.fromQName(propertyName), refDef); Collection<PrismReferenceValue> valuesToAdd = new ArrayList<>(referenceValues.length); for (PrismReferenceValue refVal: referenceValues) { valuesToAdd.add(refVal); } referenceDelta.addValuesToAdd(valuesToAdd); return objectDelta; }
protected <F extends FocusType> void removeLinks(PrismObject<F> focus) throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException { PrismReference linkRef = focus.findReference(FocusType.F_LINK_REF); if (linkRef == null) { return; } OperationResult result = new OperationResult("removeLinks"); ReferenceDelta refDelta = linkRef.createDelta(); refDelta.addValuesToDelete(linkRef.getClonedValues()); repositoryService.modifyObject(focus.getCompileTimeClass(), focus.getOid(), MiscSchemaUtil.createCollection(refDelta), result); assertSuccess(result); }