public static void asserHasDelta(String message, Collection<? extends ObjectDelta<? extends Objectable>> deltas, ChangeType expectedChangeType, Class<?> expectedClass) { for (ObjectDelta<?> delta: deltas) { if (delta.getObjectTypeClass() == expectedClass && delta.getChangeType() == expectedChangeType) { return; } } assert false : message+": Delta for "+expectedClass+" of type "+expectedChangeType+" was not found in collection "+deltas; }
public static void assertIsModify(ObjectDelta<?> objectDelta) { assert objectDelta.isModify() : "Expected that object delta "+objectDelta+" is MODIFY, but it is "+objectDelta.getChangeType(); }
public static void assertIsDelete(ObjectDelta<?> objectDelta) { assert objectDelta.isDelete() : "Expected that object delta "+objectDelta+" is DELETE, but it is "+objectDelta.getChangeType(); }
private String formatDeltaSummary(Collection<ObjectDeltaOperation<? extends ObjectType>> collection) { if (collection == null) { return "null"; } StringBuilder sb = new StringBuilder("["); Iterator<ObjectDeltaOperation<? extends ObjectType>> iterator = collection.iterator(); while (iterator.hasNext()) { ObjectDeltaOperation<?> delta = iterator.next(); sb.append(delta.getObjectDelta().getOid()).append(":").append(delta.getObjectDelta().getChangeType()); if (iterator.hasNext()) { sb.append(","); } } sb.append("]"); return sb.toString(); }
private static <T extends Objectable> ObjectDelta<T> mergeToDelta(ObjectDelta<T> firstDelta, List<ObjectDelta<T>> modifyDeltas) throws SchemaException { if (modifyDeltas.size() == 0) { return firstDelta; } ObjectDelta<T> delta = firstDelta.clone(); for (ObjectDelta<T> modifyDelta : modifyDeltas) { if (modifyDelta == null) { continue; } if (modifyDelta.getChangeType() != ChangeType.MODIFY) { throw new IllegalArgumentException("Can only merge MODIFY changes, got " + modifyDelta.getChangeType()); } delta.mergeModifications(modifyDelta.getModifications()); } return delta; }
private List<ApprovalRequest<AssignmentType>> getApprovalRequests(ModelContext<?> modelContext, PrimaryChangeProcessorConfigurationType wfConfigurationType, ObjectDelta<? extends ObjectType> change, Task taskFromModel, OperationResult result) { if (change.getChangeType() != ChangeType.ADD && change.getChangeType() != ChangeType.MODIFY) { return null; } PcpAspectConfigurationType config = primaryChangeAspectHelper.getPcpAspectConfigurationType(wfConfigurationType, this); if (change.getChangeType() == ChangeType.ADD) { return getApprovalRequestsFromFocusAdd(config, change, modelContext, taskFromModel, result); } else { return getApprovalRequestsFromFocusModify(config, modelContext.getFocusContext().getObjectOld(), change, modelContext, taskFromModel, result); } }
public <O extends ObjectType> boolean containsItem(ObjectDelta<O> delta, ItemPath itemPath) { if (delta.getChangeType() == ChangeType.ADD) { return containsItem(delta.getObjectToAdd(), itemPath); } else if (delta.getChangeType() == ChangeType.MODIFY) { return containsItemInModifications(delta.getModifications(), itemPath); } else { return false; } }
private boolean wasProjectionDeleted(LensProjectionContext accContext) { ObjectDelta<ShadowType> delta = accContext.getSyncDelta(); if (delta != null && ChangeType.DELETE.equals(delta.getChangeType())) { return true; } return false; }
/** * @param change * @return method checks change type in object delta if available, otherwise * returns {@link ChangeType#ADD} */ private ChangeType getModificationType(ResourceObjectShadowChangeDescription change) { if (change.getObjectDelta() != null) { return change.getObjectDelta().getChangeType(); } return ChangeType.ADD; }
private boolean isDeleteAccountDelta(LensProjectionContext accountContext) throws SchemaException { if (accountContext.getSyncDelta() != null && ChangeType.DELETE == accountContext.getSyncDelta().getChangeType()){ return true; } if (accountContext.getDelta() != null && ChangeType.DELETE == accountContext.getDelta().getChangeType()){ return true; } return false; }
public ObjectDeltaAsserter<O,RA> assertChangeType(ChangeType expected) { assertEquals("Wrong change type in "+desc(), expected, delta.getChangeType()); return this; }
public static void assertIsAdd(ObjectDelta<?> objectDelta) { assert objectDelta.isAdd() : "Expected that object delta "+objectDelta+" is ADD, but it is "+objectDelta.getChangeType(); assert objectDelta.getObjectToAdd() != null : "Object to add is null in add delta " + objectDelta; }
public <O extends ObjectType> ObjectDeltaOperation<O> getExecutionDelta(int index, ChangeType changeType, Class<O> typeClass) { for (ObjectDeltaOperation<? extends ObjectType> deltaOp: getExecutionDeltas(index)) { ObjectDelta<? extends ObjectType> delta = deltaOp.getObjectDelta(); if (delta.getObjectTypeClass() == typeClass && delta.getChangeType() == changeType) { return (ObjectDeltaOperation<O>) deltaOp; } } return null; }
private <F extends ObjectType> ObjectDelta<F> simplifyDelta(ObjectDelta<F> delta) { return prismContext.deltaFactory().object().create(delta.getObjectTypeClass(), delta.getChangeType()); }
@SuppressWarnings("rawtypes") private Collection<? extends ItemDelta> createShadowResultModification(Change change, OperationResult shadowResult) { PrismObjectDefinition<ShadowType> shadowDefinition = getResourceObjectShadowDefinition(); Collection<ItemDelta> modifications = new ArrayList<>(); PropertyDelta resultDelta = prismContext.deltaFactory().property().createModificationReplaceProperty(ShadowType.F_RESULT, shadowDefinition, shadowResult.createOperationResultType()); modifications.add(resultDelta); if (change.getObjectDelta() != null && change.getObjectDelta().getChangeType() == ChangeType.DELETE) { PropertyDelta failedOperationTypeDelta = prismContext.deltaFactory().property().createModificationReplaceProperty( ShadowType.F_FAILED_OPERATION_TYPE, shadowDefinition, FailedOperationTypeType.DELETE); modifications.add(failedOperationTypeDelta); } return modifications; }
public void generateFocusOidIfNeeded(ModelContext<?> modelContext, ObjectDelta<? extends ObjectType> change) { if (modelContext.getFocusContext().getOid() != null) { return; } String newOid = OidUtil.generateOid(); LOGGER.trace("This is ADD operation with no focus OID provided. Generated new OID to be used: {}", newOid); if (change.getChangeType() != ADD) { throw new IllegalStateException("Change type is not ADD for no-oid focus situation: " + change); } else if (change.getObjectToAdd() == null) { throw new IllegalStateException("Object to add is null for change: " + change); } else if (change.getObjectToAdd().getOid() != null) { throw new IllegalStateException("Object to add has already an OID present: " + change); } change.getObjectToAdd().setOid(newOid); ((LensFocusContext<?>) modelContext.getFocusContext()).setOid(newOid); }
@Test public void testAddDelta() throws SchemaException, SAXException, IOException { System.out.println("===[ testAddDelta ]==="); // WHEN ObjectDelta<UserType> userDelta = DiffUtil.diff(null,new File(TEST_DIR, "user-jack-after.xml"), UserType.class, getPrismContext()); //THEN System.out.println("DELTA:"); System.out.println(userDelta.debugDump()); userDelta.checkConsistence(); assertEquals("Wrong delta OID", "deadbeef-c001-f00d-1111-222233330001", userDelta.getOid()); assertEquals("Wrong change type", ChangeType.ADD, userDelta.getChangeType()); // TODO }
private List<ApprovalRequest<T>> getApprovalRequests(ModelContext<?> modelContext, PcpAspectConfigurationType config, ObjectDelta<? extends ObjectType> change, Task taskFromModel, OperationResult result) { if (change.getChangeType() != ChangeType.ADD) { return null; } T objectType = (T) change.getObjectToAdd().asObjectable().clone(); if (objectType.getOid() == null) { String newOid = OidUtil.generateOid(); objectType.setOid(newOid); ((LensFocusContext<?>) modelContext.getFocusContext()).setOid(newOid); } change.setObjectToAdd(null); // make the change empty return Arrays.asList(createApprovalRequest(config, objectType, modelContext, taskFromModel, result)); }
private ObjectDelta<ShadowType> assertAssignAccountToJack(LensContext<UserType> context) { display("Output context", context); assertTrue(context.getFocusContext().getPrimaryDelta().getChangeType() == ChangeType.MODIFY); assertFalse("No account changes", context.getProjectionContexts().isEmpty()); Collection<LensProjectionContext> accountContexts = context.getProjectionContexts(); assertEquals(1, accountContexts.size()); LensProjectionContext accContext = accountContexts.iterator().next(); assertNull("Account primary delta sneaked in", accContext.getPrimaryDelta()); ObjectDelta<ShadowType> accountSecondaryDelta = accContext.getSecondaryDelta(); assertEquals("Wrong decision", SynchronizationPolicyDecision.KEEP,accContext.getSynchronizationPolicyDecision()); assertEquals(ChangeType.MODIFY, accountSecondaryDelta.getChangeType()); return accountSecondaryDelta; }
private void deleteShadowFromRepoIfNeeded(Change change, OperationResult parentResult) throws ObjectNotFoundException { if (change.getObjectDelta() != null && change.getObjectDelta().getChangeType() == ChangeType.DELETE && change.getOldShadow() != null) { LOGGER.trace("Deleting detected shadow object form repository."); try { repositoryService.deleteObject(ShadowType.class, change.getOldShadow().getOid(), parentResult); LOGGER.debug("Shadow object successfully deleted form repository."); } catch (ObjectNotFoundException ex) { // What we want to delete is already deleted. Not a big problem. LOGGER.debug("Shadow object {} already deleted from repository ({})", change.getOldShadow(), ex); parentResult.recordHandledError( "Shadow object " + change.getOldShadow() + " already deleted from repository", ex); } } }