public static void assertClass(String message, Class<?> expectedClass, ObjectDelta<?> actualDelta) { assert actualDelta != null : message + "is null"; Class<?> actualCompileTimeClass = actualDelta.getObjectTypeClass(); assert actualCompileTimeClass == expectedClass : message+" wrong class, expected "+expectedClass+" but was "+actualCompileTimeClass; }
private void fixProvisioningTypeInDelta(ObjectDelta delta, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, ExpressionEvaluationException { if (delta != null && delta.getObjectTypeClass() != null && (ShadowType.class.isAssignableFrom(delta.getObjectTypeClass()) || ResourceType.class.isAssignableFrom(delta.getObjectTypeClass()))) { // TODO exception can be thrown here (MID-4391) e.g. if resource does not exist any more; consider what to do // Currently we are on the safe side by making whole conversion fail getProvisioningService().applyDefinition(delta, task, result); } }
@Override protected LensContext createModelContext(OperationResult result) throws Exception { Class<T> clazz = objectDelta.getObjectTypeClass(); //PrismObject<T> object = getObject(clazz, objectDelta.getOid()); LensContext<T> lensContext = createLensContext(clazz); addFocusDeltaToContext(lensContext, objectDelta); return lensContext; }
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 ObjectDeltaOperation<? extends ObjectType> findFocusDeltaInCollection(Collection<ObjectDeltaOperation<? extends ObjectType>> odos) { for (ObjectDeltaOperation<? extends ObjectType> odo : odos) { Class<? extends ObjectType> objectTypeClass = odo.getObjectDelta().getObjectTypeClass(); if (!ShadowType.class.equals(objectTypeClass)) { return odo; } } return null; }
public static List<ObjectDeltaOperation<ShadowType>> findProjectionDeltasInCollection(Collection<ObjectDeltaOperation<? extends ObjectType>> odos) { List<ObjectDeltaOperation<ShadowType>> projectionDeltas = new ArrayList<>(); for (ObjectDeltaOperation<? extends ObjectType> odo : odos) { Class<? extends ObjectType> objectTypeClass = odo.getObjectDelta().getObjectTypeClass(); if (ShadowType.class.equals(objectTypeClass)) { projectionDeltas.add((ObjectDeltaOperation<ShadowType>) odo); } } return projectionDeltas; }
protected void fixProvisioningTypeInDelta(ObjectDelta<O> delta, Objectable object, Task task, OperationResult result) { if (delta != null && delta.getObjectTypeClass() != null && (ShadowType.class.isAssignableFrom(delta.getObjectTypeClass()) || ResourceType.class.isAssignableFrom(delta.getObjectTypeClass()))) { try { lensContext.getProvisioningService().applyDefinition(delta, object, task, result); } catch (Exception e) { LOGGER.warn("Error applying provisioning definitions to delta {}: {}", delta, e.getMessage()); // In case of error just go on. Maybe we do not have correct definition here. But at least we can // display the GUI pages and maybe we can also salvage the operation. result.recordWarning(e); } } }
public ObjectDeltaAsserter<O,RA> assertObjectTypeClass(Class<ShadowType> expected) { assertEquals("Wrong object type class in "+desc(), expected, delta.getObjectTypeClass()); return this; }
@Override public <T extends Objectable> void adopt(ObjectDelta<T> delta) throws SchemaException { delta.revive(this); getSchemaRegistry().applyDefinition(delta, delta.getObjectTypeClass(), false); }
public static <O extends ObjectType> ObjectDeltaOperation<O> findAddDelta(Collection<ObjectDeltaOperation<? extends ObjectType>> executedChanges, PrismObject<O> object) { for (ObjectDeltaOperation<? extends ObjectType> odo : executedChanges) { Class<? extends ObjectType> objectTypeClass = odo.getObjectDelta().getObjectTypeClass(); if (odo.getObjectDelta().isAdd() && object.getCompileTimeClass().equals(objectTypeClass)) { return (ObjectDeltaOperation<O>) odo; } } return null; }
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; }
@SafeVarargs static <O extends Objectable, C extends Containerable> void fillInModificationDeleteContainer( ObjectDelta<O> objectDelta, ItemPath propertyPath, PrismContext prismContext, C... containerables) throws SchemaException { ContainerDelta<C> containerDelta = objectDelta.createContainerModification(propertyPath); if (containerables != null) { for (C containerable: containerables) { prismContext.adopt(containerable, objectDelta.getObjectTypeClass(), propertyPath); PrismContainerValue<C> prismContainerValue = containerable.asPrismContainerValue(); containerDelta.addValueToDelete(prismContainerValue); } } }
@SafeVarargs static <O extends Objectable, C extends Containerable> void fillInModificationAddContainer( ObjectDelta<O> objectDelta, ItemPath propertyPath, PrismContext prismContext, C... containerables) throws SchemaException { ContainerDelta<C> containerDelta = objectDelta.createContainerModification(propertyPath); if (containerables != null) { for (C containerable: containerables) { prismContext.adopt(containerable, objectDelta.getObjectTypeClass(), propertyPath); PrismContainerValue<C> prismContainerValue = containerable.asPrismContainerValue(); containerDelta.addValueToAdd(prismContainerValue); } } }
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; }
@SafeVarargs private static <O extends Objectable, C extends Containerable> void fillInModificationReplaceContainer( ObjectDelta<O> objectDelta, ItemPath propertyPath, C... containerValues) throws SchemaException { if (containerValues != null) { ContainerDelta<C> containerDelta = objectDelta.createContainerModification(propertyPath); Collection<PrismContainerValue<C>> valuesToReplace = PrismValueCollectionsUtil .toPrismContainerValues(objectDelta.getObjectTypeClass(), propertyPath, objectDelta.getPrismContext(), containerValues); containerDelta.setValuesToReplace(valuesToReplace); objectDelta.addModification(containerDelta); } }
@Override public PrismObjectDefinition<O> getDefinition() { PrismObject<O> anyObject = getAnyObject(); if (anyObject != null) { return anyObject.getDefinition(); } if (delta != null) { return delta.getPrismContext().getSchemaRegistry().findObjectDefinitionByCompileTimeClass(delta.getObjectTypeClass()); } return null; }
public Class<? extends ObjectType> getFocusClass(ModelContext<? extends ObjectType> context) { if (context.getFocusClass() != null) { return context.getFocusClass(); } // if for some reason context.focusClass is not set... here is a fallback if (context.getFocusContext() == null) { return null; } ObjectDelta<? extends ObjectType> change = context.getFocusContext().getPrimaryDelta(); if (change == null) { return null; } return change.getObjectTypeClass(); }
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 <F extends FocusType> void unlink(LensContext<F> context, FocusType persona, OperationResult result) throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException { ObjectDelta<F> delta = context.getFocusContext().getObjectNew().createModifyDelta(); PrismReferenceValue refValue = prismContext.itemFactory().createReferenceValue(); refValue.setOid(persona.getOid()); refValue.setTargetType(persona.asPrismObject().getDefinition().getTypeName()); delta.addModificationDeleteReference(FocusType.F_PERSONA_REF, refValue); repositoryService.modifyObject(delta.getObjectTypeClass(), delta.getOid(), delta.getModifications(), result); }
private <F extends FocusType> void link(LensContext<F> context, FocusType persona, OperationResult result) throws ObjectNotFoundException, SchemaException, ObjectAlreadyExistsException { ObjectDelta<F> delta = context.getFocusContext().getObjectNew().createModifyDelta(); PrismReferenceValue refValue = prismContext.itemFactory().createReferenceValue(); refValue.setOid(persona.getOid()); refValue.setTargetType(persona.asPrismObject().getDefinition().getTypeName()); delta.addModificationAddReference(FocusType.F_PERSONA_REF, refValue); repositoryService.modifyObject(delta.getObjectTypeClass(), delta.getOid(), delta.getModifications(), result); }