public static void assertClass(String message, Class<?> expectedClass, PrismObject<?> actualObject) { assert actualObject != null : message + "is null"; Class<?> actualCompileTimeClass = actualObject.getCompileTimeClass(); assert actualCompileTimeClass == expectedClass : message+" wrong class, expected "+expectedClass+" but was "+actualCompileTimeClass; }
@Override public boolean isUserRelated() { if (object instanceof UserType) { return true; } else if (object instanceof PrismObject) { PrismObject prismObject = (PrismObject) object; return prismObject.getCompileTimeClass() != null && UserType.class.isAssignableFrom(prismObject.getCompileTimeClass()); } else { return false; } }
private <O extends AssignmentHolderType> boolean isHolderType(List<QName> requiredHolderTypes, PrismObject<O> holder) { if (requiredHolderTypes.isEmpty()) { return true; } for (QName requiredHolderType : requiredHolderTypes) { if (MiscSchemaUtil.canBeAssignedFrom(requiredHolderType, holder.getCompileTimeClass())) { return true; } } return false; }
protected <F extends FocusType> boolean isTypeAndSubtype(PrismObject<F> focus, Class<F> expectedType, String subtype) { if (!expectedType.isAssignableFrom(focus.getCompileTimeClass())) { return false; } if (!FocusTypeUtil.hasSubtype(focus, subtype)) { return false; } return true; }
private <O extends ObjectType> AbstractValuePolicyOriginResolver<O> getOriginResolver(PrismObject<O> object) { if (object != null && UserType.class.equals(object.getCompileTimeClass())) { return (AbstractValuePolicyOriginResolver) new UserValuePolicyOriginResolver((PrismObject<UserType>) object, objectResolver); } //TODO not supported yet, throw exception instead of null??? return null; }
private void fixProvisioningTypeInObject(PrismObject<O> object, Task task, OperationResult result) { if (object != null && object.getCompileTimeClass() != null && (ShadowType.class.isAssignableFrom(object.getCompileTimeClass()) || ResourceType.class.isAssignableFrom(object.getCompileTimeClass()))) { try { lensContext.getProvisioningService().applyDefinition(object, task, result); } catch (Exception e) { LOGGER.warn("Error applying provisioning definitions to object {}: {}", object, 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); } } }
@Override public <T extends ObjectType> void invoke(PrismObject<T> object, Collection<SelectorOptions<GetOperationOptions>> options, Task task, OperationResult parentResult) throws SchemaException, ObjectNotFoundException, SecurityViolationException, CommunicationException, ConfigurationException { if (!ReportType.class.equals(object.getCompileTimeClass())) { return; } boolean raw = isRaw(options); if (!raw) { ReportTypeUtil.applyDefinition((PrismObject<ReportType>) object, prismContext); } }
public static <O extends ObjectType> ObjectPolicyConfigurationType determineObjectPolicyConfiguration(PrismObject<O> object, SystemConfigurationType systemConfigurationType) throws ConfigurationException { List<String> subTypes = FocusTypeUtil.determineSubTypes(object); return determineObjectPolicyConfiguration(object.getCompileTimeClass(), subTypes, systemConfigurationType); }
public void setObjectToAdd(PrismObject<O> objectToAdd) { checkMutability(); if (getChangeType() != ChangeType.ADD) { throw new IllegalStateException("Cannot set object to "+getChangeType()+" delta"); } this.objectToAdd = objectToAdd; if (objectToAdd != null) { this.objectTypeClass = objectToAdd.getCompileTimeClass(); } }
protected <F extends FocusType> ObjectDelta<F> createAssignmentFocusEmptyDeleteDelta(PrismObject<F> existingFocus, String roleOid, QName relation) throws SchemaException { Collection<ItemDelta<?,?>> modifications = new ArrayList<>(); modifications.add((createAssignmentEmptyDeleteModification(existingFocus, roleOid, relation))); return prismContext.deltaFactory().object() .createModifyDelta(existingFocus.getOid(), modifications, existingFocus.getCompileTimeClass() ); }
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 static <O extends ObjectType> ObjectReferenceType createObjectReference(PrismObject<O> object, Class<? extends ObjectType> implicitReferenceTargetType) { ObjectReferenceType ref = new ObjectReferenceType(); ref.setOid(object.getOid()); if (implicitReferenceTargetType == null || !implicitReferenceTargetType.equals(object.getCompileTimeClass())) { ref.setType(ObjectTypes.getObjectType(object.getCompileTimeClass()).getTypeQName()); } ref.setTargetName(PolyString.toPolyStringType(object.getName())); return ref; }
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; }
protected void unassignRoleByAssignmentValue(PrismObject<? extends FocusType> focus, String roleOid, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, CommunicationException, ConfigurationException, ObjectAlreadyExistsException, PolicyViolationException, SecurityViolationException { AssignmentType assignment = findAssignmentByTargetRequired(focus, roleOid); ObjectDelta<? extends FocusType> delta = prismContext.deltaFor(focus.getCompileTimeClass()) .item(FocusType.F_ASSIGNMENT) .delete(assignment.clone()) .asObjectDeltaCast(focus.getOid()); modelService.executeChanges(singleton(delta), null, task, result); }
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; }
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); }
@Override protected LensContext<F> createModelContext(OperationResult result) throws Exception { PrismObject<F> focus = testDetails2.getFocus(result); // TODO "object create" context LensContext<F> lensContext = createLensContext(focus.getCompileTimeClass()); fillContextWithFocus(lensContext, focus); addFocusDeltaToContext(lensContext, testDetails2.getFocusDelta()); if (immediate) { lensContext.setOptions(ModelExecuteOptions.createExecuteImmediatelyAfterApproval()); } return lensContext; }
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 assertUserDrake(PrismObject<UserType> user, boolean assertDefinitions, PrismContext prismContext) throws SchemaException, SAXException, IOException { assertEquals("Wrong OID", USER_OID, user.getOid()); assertEquals("Wrong compileTimeClass", UserType.class, user.getCompileTimeClass()); user.checkConsistence(); assertUserDrakeContent(user, assertDefinitions); if (assertDefinitions) { serializeAndValidate(user, prismContext); } }
private void assertObjectTemplatePrism(PrismObject<ObjectTemplateType> object, QName elementName) { assertEquals("Wrong oid", "10000000-0000-0000-0000-000000000002", object.getOid()); PrismObjectDefinition<ObjectTemplateType> objectDefinition = object.getDefinition(); assertNotNull("No object definition", objectDefinition); PrismAsserts.assertObjectDefinition(objectDefinition, elementName, ObjectTemplateType.COMPLEX_TYPE, ObjectTemplateType.class); assertEquals("Wrong class", ObjectTemplateType.class, object.getCompileTimeClass()); assertEquals("Wrong object item name", elementName, object.getElementName()); ObjectTemplateType objectType = object.asObjectable(); assertNotNull("asObjectable resulted in null", objectType); assertPropertyValue(object, "name", PrismTestUtil.createPolyString("Default User Template")); assertPropertyDefinition(object, "name", PolyStringType.COMPLEX_TYPE, 0, 1); }