protected void checkConsistence(ObjectDelta<O> delta, boolean requireOid, String contextDesc) { try { delta.checkConsistence(requireOid, true, true, ConsistencyCheckScope.THOROUGH); } catch (IllegalArgumentException e) { throw new IllegalArgumentException(e.getMessage()+"; in "+contextDesc, e); } catch (IllegalStateException e) { throw new IllegalStateException(e.getMessage()+"; in "+contextDesc, e); } if (delta.isAdd()) { checkConsistence(delta.getObjectToAdd(), "add object", contextDesc); } }
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 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); }
private <T extends ObjectType> void generateObjectOidIfNeeded(ObjectDelta<T> focusDelta, ModelContext<T> modelContext) { if (focusDelta.isAdd()) { if (focusDelta.getObjectToAdd().getOid() == null) { String newOid = OidUtil.generateOid(); focusDelta.getObjectToAdd().setOid(newOid); ((LensFocusContext<?>) modelContext.getFocusContext()).setOid(newOid); } } }
public <F extends FocusType> boolean wasAddExecuted() { for (LensObjectDeltaOperation<O> executedDeltaOperation : getExecutedDeltas()){ ObjectDelta<O> executedDelta = executedDeltaOperation.getObjectDelta(); if (!executedDelta.isAdd()){ continue; } else if (executedDelta.getObjectToAdd() != null && executedDelta.getObjectTypeClass().equals(getObjectTypeClass())){ return true; } } return false; }
public void addAssignmentApprovalMetadata(ObjectDelta<?> objectDelta, Task task, OperationResult result) throws SchemaException { if (objectDelta.isAdd()) { addAssignmentApprovalMetadataOnObjectAdd(objectDelta.getObjectToAdd(), task, result); } else if (objectDelta.isModify()) { addAssignmentApprovalMetadataOnObjectModify(objectDelta, task, result); } }
public boolean isProtected() { if ((currentShadow != null && ShadowUtil.isProtected(currentShadow)) || (oldShadow != null && ShadowUtil.isProtected(oldShadow))) { return true; } if (delta != null && delta.isAdd() && ShadowUtil.isProtected(delta.getObjectToAdd())) { return true; } return false; }
public boolean isProtected() { if ((currentShadow != null && ShadowUtil.isProtected(currentShadow)) || (oldShadow != null && ShadowUtil.isProtected(oldShadow))) { return true; } if (objectDelta != null && objectDelta.isAdd() && ShadowUtil.isProtected(objectDelta.getObjectToAdd())) { return true; } return false; }
public PrismObject<ShadowType> getShadow() { PrismObject<ShadowType> shadow; if (getCurrentShadow() != null) { shadow = getCurrentShadow(); } else if (getOldShadow() != null) { shadow = getOldShadow(); } else if (getDelta() != null && getDelta().isAdd()) { if (getDelta().getObjectToAdd() == null) { throw new IllegalStateException("Found ADD delta, but no object to add was specified."); } shadow = getDelta().getObjectToAdd(); } else { throw new IllegalStateException("Resource event description does not contain neither old shadow, nor current shadow, nor shadow in delta"); } return shadow; } }
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 void handleErrorHandlerException(ProvisioningContext ctx, ProvisioningOperationState<? extends AsynchronousOperationResult> opState, ObjectDelta<ShadowType> delta, Task task, OperationResult parentResult) throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, ObjectAlreadyExistsException, ExpressionEvaluationException { // Error handler had re-thrown the exception. We will throw the exception later. But first we need to record changes in opState. shadowManager.recordOperationException(ctx, opState, delta, parentResult); PrismObject<ShadowType> shadow = opState.getRepoShadow(); if (delta.isAdd()) { // This is more precise. Besides, there is no repo shadow in some cases (e.g. adding protected shadow). shadow = delta.getObjectToAdd(); } ResourceOperationDescription operationDescription = ProvisioningUtil.createResourceFailureDescription(shadow, ctx.getResource(), delta, parentResult); operationListener.notifyFailure(operationDescription, task, parentResult); }
private <AH extends AssignmentHolderType> boolean pathMatches(ObjectDelta<?> delta, PrismObject<AH> objectOld, ItemPath path, boolean exactPathMatch) throws SchemaException { if (delta.isAdd()) { return delta.getObjectToAdd().containsItem(path, false); } else if (delta.isDelete()) { return objectOld != null && objectOld.containsItem(path, false); } else { return ItemDeltaCollectionsUtil.pathMatches(emptyIfNull(delta.getModifications()), path, 0, exactPathMatch); } }
protected <O extends ObjectType> String addObject(PrismObject<O> object, ModelExecuteOptions options, Task task, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { ObjectDelta<O> addDelta = object.createAddDelta(); assertFalse("Immutable object provided?",addDelta.getObjectToAdd().isImmutable()); Collection<ObjectDeltaOperation<? extends ObjectType>> executedDeltas = executeChanges(addDelta, options, task, result); object.setOid(ObjectDeltaOperation.findFocusDeltaOidInCollection(executedDeltas)); return object.getOid(); }
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)); }
public ObjectDelta<O> getWaveExecutableDelta(int wave) throws SchemaException { if (wave == 0) { if (getFixedPrimaryDelta() != null && getFixedPrimaryDelta().isAdd()) { ObjectDelta delta = getFixedPrimaryDelta().clone(); for (ObjectDelta<O> secondary : getSecondaryDeltas()) { if (secondary != null) { secondary.applyTo(delta.getObjectToAdd()); } } return delta; } } return getWaveDelta(wave); }
private static PrismReferenceValue getAuditTarget(ObjectDelta<? extends ObjectType> delta, PrismContext prismContext) { PrismReferenceValue targetRef = prismContext.itemFactory().createReferenceValue(delta.getOid()); targetRef.setTargetType(ObjectTypes.getObjectType(delta.getObjectTypeClass()).getTypeQName()); if (delta.isAdd()) { targetRef.setObject(delta.getObjectToAdd()); } return targetRef; }
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); } } }
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 }
private <O extends ObjectType> void applyLastProvisioningTimestamp(LensContext<O> context, ObjectDelta<O> focusDelta) throws SchemaException { if (!context.hasProjectionChange()) { return; } if (focusDelta.isAdd()) { PrismObject<O> objectToAdd = focusDelta.getObjectToAdd(); PrismContainer<MetadataType> metadataContainer = objectToAdd.findOrCreateContainer(ObjectType.F_METADATA); metadataContainer.getRealValue().setLastProvisioningTimestamp(clock.currentTimeXMLGregorianCalendar()); } else if (focusDelta.isModify()) { PropertyDelta<XMLGregorianCalendar> provTimestampDelta = prismContext.deltaFactory().property().createModificationReplaceProperty( ItemPath.create(ObjectType.F_METADATA, MetadataType.F_LAST_PROVISIONING_TIMESTAMP), context.getFocusContext().getObjectDefinition(), clock.currentTimeXMLGregorianCalendar()); focusDelta.addModification(provTimestampDelta); } }
@Override public void assertsAfterClockworkRun(Task rootTask, List<Task> wfSubtasks, OperationResult result) throws Exception { ModelContext taskModelContext = wfTaskUtil.getModelContext(rootTask, result); PrismObject<UserType> objectToAdd = taskModelContext.getFocusContext().getPrimaryDelta().getObjectToAdd(); assertNotNull("There is no object to add left in primary focus delta", objectToAdd); assertFalse("There is assignment of R1 in reduced primary focus delta", assignmentExists(objectToAdd.asObjectable().getAssignment(), ROLE_R1_OID)); assertFalse("There is assignment of R2 in reduced primary focus delta", assignmentExists(objectToAdd.asObjectable().getAssignment(), ROLE_R2_OID)); assertFalse("There is assignment of R3 in reduced primary focus delta", assignmentExists(objectToAdd.asObjectable().getAssignment(), ROLE_R3_OID)); assertTrue("There is no assignment of R4 in reduced primary focus delta", assignmentExists(objectToAdd.asObjectable().getAssignment(), ROLE_R4_OID)); }