private static PrismContext getPrismContext(PrismObject<?>... objects) { for (PrismObject<?> object: objects) { if (object != null && object.getPrismContext() != null) { return object.getPrismContext(); } } return null; }
public static String serializeObjectToXml(PrismObject<? extends ObjectType> object) { return serializeObjectToXml(object, object.getPrismContext()); }
public static RefinedResourceSchema getRefinedSchema(PrismObject<ResourceType> resource) throws SchemaException { return getRefinedSchema(resource, resource.getPrismContext()); }
public static RefinedResourceSchema getRefinedSchema(ResourceType resourceType) throws SchemaException { return getRefinedSchema(resourceType, resourceType.asPrismObject().getPrismContext()); }
public static LayerRefinedResourceSchema getRefinedSchema(ResourceType resourceType, LayerType layer) throws SchemaException { return getRefinedSchema(resourceType, layer, resourceType.asPrismObject().getPrismContext()); }
@NotNull public static <T extends ObjectType> AssignmentType createAssignmentTo(@NotNull PrismObject<T> object, QName relation) { AssignmentType assignment = new AssignmentType(object.getPrismContext()); if (object.asObjectable() instanceof ResourceType) { ConstructionType construction = new ConstructionType(object.getPrismContext()); construction.setResourceRef(createObjectRef(object, relation)); assignment.setConstruction(construction); } else { assignment.setTargetRef(createObjectRef(object, relation)); } return assignment; }
public static ObjectQuery createNameQuery(ObjectType object) throws SchemaException { return createNameQuery(object.getName(), object.asPrismObject().getPrismContext()); }
public static <O extends ObjectType> ObjectQuery createNameQuery(PrismObject<O> object) throws SchemaException { return createNameQuery(object.asObjectable().getName(), object.getPrismContext()); }
public static RefinedResourceSchemaAsserter<Void> forResource(PrismObject<ResourceType> resource) throws SchemaException { RefinedResourceSchema refinedSchema = RefinedResourceSchemaImpl.getRefinedSchema(resource, resource.getPrismContext()); assertNotNull("No refined schema for "+resource, refinedSchema); return new RefinedResourceSchemaAsserter<>(refinedSchema, resource.toString()); }
public static RefinedResourceSchemaAsserter<Void> forResource(PrismObject<ResourceType> resource, String details) throws SchemaException { RefinedResourceSchema refinedSchema = RefinedResourceSchemaImpl.getRefinedSchema(resource, resource.getPrismContext()); assertNotNull("No refined schema for "+resource+" ("+details+")", refinedSchema); return new RefinedResourceSchemaAsserter<>(refinedSchema, resource.toString()+" ("+details+")"); }
public static <O extends Objectable> ObjectDeltaImpl<O> createAddDelta(PrismObject<O> objectToAdd) { ObjectDeltaImpl<O> objectDelta = new ObjectDeltaImpl<>(objectToAdd.getCompileTimeClass(), ChangeType.ADD, objectToAdd.getPrismContext()); objectDelta.setOid(objectToAdd.getOid()); objectDelta.setObjectToAdd(objectToAdd); return objectDelta; }
static <O extends Objectable> ObjectDelta<O> createAddDelta(PrismObject<O> objectToAdd) { ObjectDelta<O> objectDelta = objectToAdd.getPrismContext().deltaFactory().object().create(objectToAdd.getCompileTimeClass(), ChangeType.ADD); objectDelta.setOid(objectToAdd.getOid()); objectDelta.setObjectToAdd(objectToAdd); return objectDelta; }
@Override public ObjectQuery getOwnerQuery() { return getObject().getPrismContext() .queryFor(UserType.class) .item(UserType.F_PERSONA_REF).ref(getObject().getOid()) .build(); } }
@Override public ObjectQuery getOwnerQuery() { return getObject().getPrismContext() .queryFor(UserType.class) .item(UserType.F_LINK_REF).ref(getObject().getOid()) .build(); } }
@Override protected boolean handleObject(PrismObject<ResourceType> resource, Task workerTask, OperationResult taskResult) throws CommonException { LOGGER.trace("Propagating provisioning operations on {}", resource); ObjectQuery query = resource.getPrismContext().queryFactory().createQuery(); ObjectFilter filter = resource.getPrismContext().queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(resource.getOid()) .and() .exists(ShadowType.F_PENDING_OPERATION) .buildFilter(); query.setFilter(filter); ResultHandler<ShadowType> handler = (shadow, result) -> { propagateShadowOperations(resource, shadow, workerTask, result); return true; }; repositoryService.searchObjectsIterative(ShadowType.class, query, handler, null, true, taskResult); LOGGER.trace("Propagation of {} done", resource); return true; }
public void update(ItemDelta<?, ?> itemDelta) throws SchemaException { if (delta == null) { delta = getAnyObject().getPrismContext().deltaFactory().object() .createModifyDelta(getAnyObject().getOid(), itemDelta, getAnyObject().getCompileTimeClass() ); } else { delta.swallow(itemDelta); itemDelta.applyTo(newObject); } }
private void reactShadowGone(PrismObject<ShadowType> shadow, PrismObject<ResourceType> resource, Task task, OperationResult result) { try { provisioningService.applyDefinition(shadow, task, result); ResourceObjectShadowChangeDescription change = new ResourceObjectShadowChangeDescription(); change.setSourceChannel(QNameUtil.qNameToUri(SchemaConstants.CHANGE_CHANNEL_RECON)); change.setResource(resource); ObjectDelta<ShadowType> shadowDelta = shadow.getPrismContext().deltaFactory().object() .createDeleteDelta(ShadowType.class, shadow.getOid() ); change.setObjectDelta(shadowDelta); // Need to also set current shadow. This will get reflected in "old" object in lens context change.setCurrentShadow(shadow); ModelImplUtils.clearRequestee(task); changeNotificationDispatcher.notifyChange(change, task, result); } catch (SchemaException | ObjectNotFoundException | CommunicationException | ConfigurationException | ExpressionEvaluationException e) { processShadowReconError(e, shadow, result); } }
public RefinedObjectClassDefinition getObjectClassDefinition() throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, ExpressionEvaluationException { if (objectClassDefinition == null) { if (useRefinedDefinition) { if (originalShadow != null) { objectClassDefinition = getRefinedSchema().determineCompositeObjectClassDefinition(originalShadow, additionalAuxiliaryObjectClassQNames); } else if (shadowCoordinates != null && !shadowCoordinates.isWildcard()) { objectClassDefinition = getRefinedSchema().determineCompositeObjectClassDefinition(shadowCoordinates); } } else { if (shadowCoordinates.getObjectClass() == null) { throw new IllegalStateException("No objectclass"); } ObjectClassComplexTypeDefinition origObjectClassDefinition = getRefinedSchema().getOriginalResourceSchema().findObjectClassDefinition(shadowCoordinates.getObjectClass()); if (origObjectClassDefinition == null) { throw new SchemaException("No object class definition for "+shadowCoordinates.getObjectClass()+" in original resource schema for "+getResource()); } else { objectClassDefinition = RefinedObjectClassDefinitionImpl.parseFromSchema(origObjectClassDefinition, getResource(), getRefinedSchema(), getResource().asPrismObject().getPrismContext(), "objectclass "+origObjectClassDefinition+" in "+getResource()); } } } return objectClassDefinition; }
@Test public void test120CreateShadow() throws Exception { final String TEST_NAME = "test120CreateShadow"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext prismContext = createInitializedPrismContext(); PrismObject<ResourceType> resource = prismContext.parseObject(RESOURCE_COMPLEX_FILE); ResourceType resourceType = resource.asObjectable(); RefinedResourceSchema rSchema = RefinedResourceSchemaImpl.parse(resourceType, prismContext); assertNotNull("Refined schema is null", rSchema); assertFalse("No account definitions", rSchema.getRefinedDefinitions(ShadowKindType.ACCOUNT).isEmpty()); RefinedObjectClassDefinition rAccount = rSchema.getRefinedDefinition(ShadowKindType.ACCOUNT, (String)null); // WHEN PrismObject<ShadowType> blankShadow = rAccount.createBlankShadow(); // THEN assertNotNull("No blank shadow", blankShadow); assertNotNull("No prism context in blank shadow", blankShadow.getPrismContext()); PrismObjectDefinition<ShadowType> objectDef = blankShadow.getDefinition(); assertNotNull("Blank shadow has no definition", objectDef); PrismContainerDefinition<?> attrDef = objectDef.findContainerDefinition(ShadowType.F_ATTRIBUTES); assertNotNull("Blank shadow has no definition for attributes", attrDef); assertTrue("Wrong class for attributes definition: "+attrDef.getClass(), attrDef instanceof ResourceAttributeContainerDefinition); }
private static void assertUserJackExtension(PrismObject<UserType> user) throws SchemaException { PrismContext prismContext = user.getPrismContext(); PrismContainer<?> extension = user.getExtension(); assertContainerDefinition(extension, "extension", DOMUtil.XSD_ANY, 0, 1);