private PrismContainerDefinition<ActivationType> getActivationDefinition() { if (activationDefinition == null) { PrismObjectDefinition<UserType> userDefinition = getUserDefinition(); activationDefinition = userDefinition.findContainerDefinition(UserType.F_ACTIVATION); } return activationDefinition; } }
@NotNull @Override public <T extends Objectable> PrismObject<T> createObject(@NotNull Class<T> clazz) throws SchemaException { PrismObjectDefinition<T> definition = schemaRegistry.findObjectDefinitionByCompileTimeClass(clazz); if (definition == null) { throw new SchemaException("Definition for prism object holding " + clazz + " couldn't be found"); } return definition.instantiate(); }
private <O extends ObjectType> PrismPropertyDefinition<?> getItemDefinition(PrismObject<O> object, ItemPath path) { ItemDefinition<?> itemDef = object.getDefinition().findItemDefinition(path); if (itemDef == null) { return null; } else if (!(itemDef instanceof PrismPropertyDefinition)) { return null; } return (PrismPropertyDefinition<?>) itemDef; }
public static <O extends Objectable,T> PropertyDelta<T> createDelta(ItemPath propertyPath, PrismObjectDefinition<O> objectDefinition) { PrismPropertyDefinition propDef = objectDefinition.findPropertyDefinition(propertyPath); return new PropertyDeltaImpl<T>(propertyPath, propDef, objectDefinition.getPrismContext()); // hoping the prismContext is there }
public static <T extends Containerable,O extends Objectable> ContainerDeltaImpl<T> createDelta(ItemPath containerPath, PrismObjectDefinition<O> objectDefinition) { PrismContainerDefinition<T> containerDefinition = objectDefinition.findContainerDefinition(containerPath); if (containerDefinition == null) { throw new IllegalArgumentException("No definition for "+containerPath+" in "+objectDefinition); } ContainerDeltaImpl<T> delta = new ContainerDeltaImpl<>(containerPath, containerDefinition, objectDefinition.getPrismContext()); return delta; }
public static ReferenceDeltaImpl createModificationDelete(ItemPath path, PrismObjectDefinition<?> objectDefinition, Collection<PrismReferenceValue> refValues) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.addValuesToDelete(refValues); return referenceDelta; }
@Test public void testAccountDefinition() { System.out.println("===[ testAccountDefinition ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); SchemaRegistry schemaRegistry = prismContext.getSchemaRegistry(); // WHEN PrismObjectDefinition<ShadowType> accountDefinition = schemaRegistry.findObjectDefinitionByElementName( SchemaConstants.C_SHADOW); assertNotNull("No account definition", accountDefinition); System.out.println("Account definition:"); System.out.println(accountDefinition.debugDump()); PrismObjectDefinition<ShadowType> accountDefinitionByClass = schemaRegistry.findObjectDefinitionByCompileTimeClass(ShadowType.class); assertTrue("Different account def", accountDefinition == accountDefinitionByClass); assertEquals("Wrong compile-time class in account definition", ShadowType.class, accountDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(accountDefinition, ShadowType.F_NAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertPropertyDefinition(accountDefinition, ShadowType.F_DESCRIPTION, DOMUtil.XSD_STRING, 0, 1); assertFalse("Account definition is marked as runtime", accountDefinition.isRuntimeSchema()); PrismContainerDefinition attributesContainer = accountDefinition.findContainerDefinition(ShadowType.F_ATTRIBUTES); PrismAsserts.assertDefinition(attributesContainer, ShadowType.F_ATTRIBUTES, ShadowAttributesType.COMPLEX_TYPE, 0, 1); assertTrue("Attributes is NOT runtime", attributesContainer.isRuntimeSchema()); assertEquals("Wrong attributes compile-time class", ShadowAttributesType.class, attributesContainer.getCompileTimeClass()); }
private void assertUserDefinition(PrismObjectDefinition<UserType> userDefinition) { assertEquals("Wrong compile-time class in user definition", UserType.class, userDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(userDefinition, USER_NAME_QNAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertItemDefinitionDisplayName(userDefinition, USER_NAME_QNAME, "ObjectType.name"); PrismAsserts.assertPropertyDefinition(userDefinition, USER_FAMILYNAME_QNAME, DOMUtil.XSD_STRING, 0, 1); PrismAsserts.assertPropertyDefinition(userDefinition, USER_ADDITIONALNAMES_QNAME, DOMUtil.XSD_STRING, 0, -1); assertFalse("User definition is marked as runtime", userDefinition.isRuntimeSchema()); PrismContainerDefinition extensionContainer = userDefinition.findContainerDefinition(USER_EXTENSION_QNAME); PrismAsserts.assertDefinition(extensionContainer, USER_EXTENSION_QNAME, DOMUtil.XSD_ANY, 0, 1); assertTrue("Extension is not runtime", extensionContainer.isRuntimeSchema()); PrismAsserts.assertItemDefinitionHelp(userDefinition, USER_EXTENSION_QNAME, "Object extension contains extra properties"); PrismContainerDefinition activationContainer = userDefinition.findContainerDefinition(USER_ACTIVATION_QNAME); PrismAsserts.assertDefinition(activationContainer, USER_ACTIVATION_QNAME, ACTIVATION_TYPE_QNAME, 0, 1); assertFalse("Activation is runtime", activationContainer.isRuntimeSchema()); PrismAsserts.assertPropertyDefinition(activationContainer, USER_VALID_TO_QNAME, DOMUtil.XSD_DATETIME, 0, 1); PrismContainerDefinition assignmentContainer = userDefinition.findContainerDefinition(USER_ASSIGNMENT_QNAME); PrismAsserts.assertDefinition(assignmentContainer, USER_ASSIGNMENT_QNAME, ASSIGNMENT_TYPE_QNAME, 0, -1); assertFalse("Assignment is runtime", assignmentContainer.isRuntimeSchema()); PrismReferenceDefinition accountRefDef = userDefinition.findItemDefinition(USER_ACCOUNTREF_QNAME, PrismReferenceDefinition.class); PrismAsserts.assertDefinition(accountRefDef, USER_ACCOUNTREF_QNAME, OBJECT_REFERENCE_TYPE_QNAME, 0, -1); assertEquals("Wrong target type in accountRef", ACCOUNT_TYPE_QNAME, accountRefDef.getTargetTypeName());
public static <T> PropertyDelta<T> createModificationDeleteProperty(ItemPath propertyPath, PrismObjectDefinition<?> objectDefinition, T... propertyValues) { PrismPropertyDefinition<T> propertyDefinition = objectDefinition.findPropertyDefinition(propertyPath); return createModificationDeleteProperty(propertyPath, propertyDefinition, propertyValues); }
@Test public void testCommonSchemaAccountType() throws SchemaException, SAXException, IOException { MidPointPrismContextFactory factory = getContextFactory(); PrismContext context = factory.createInitializedPrismContext(); SchemaRegistry schemaRegistry = context.getSchemaRegistry(); PrismObjectDefinition<ShadowType> accountDef = schemaRegistry.findObjectDefinitionByCompileTimeClass(ShadowType.class); assertNotNull("No account definition", accountDef); System.out.println("testCommonSchemaAccountType:"); System.out.println(accountDef.debugDump()); PrismPropertyDefinition nameDef = accountDef.findPropertyDefinition(ShadowType.F_NAME); assertNotNull("No name definition", nameDef); PrismContainerDefinition extensionDef = accountDef.findContainerDefinition(ShadowType.F_EXTENSION); assertNotNull("No 'extension' definition", extensionDef); assertTrue("'extension' definition is not marked as runtime", extensionDef.isRuntimeSchema()); PrismContainerDefinition attributesDef = accountDef.findContainerDefinition(ShadowType.F_ATTRIBUTES); assertNotNull("No 'attributes' definition", attributesDef); assertTrue("'attributes' definition is not marked as runtime", attributesDef.isRuntimeSchema()); }
private void assertAccountDefinition(PrismObjectDefinition<AccountType> accountDefinition) { assertEquals("Wrong compile-time class in account definition", AccountType.class, accountDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(accountDefinition, ACCOUNT_NAME_QNAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertPropertyDefinition(accountDefinition, ACCOUNT_DESCRIPTION_QNAME, DOMUtil.XSD_STRING, 0, 1); assertFalse("Account definition is marked as runtime", accountDefinition.isRuntimeSchema()); PrismContainerDefinition attributesContainer = accountDefinition.findContainerDefinition(ACCOUNT_ATTRIBUTES_QNAME); PrismAsserts.assertDefinition(attributesContainer, ACCOUNT_ATTRIBUTES_QNAME, ATTRIBUTES_TYPE_QNAME, 0, 1); assertTrue("Attributes is NOT runtime", attributesContainer.isRuntimeSchema()); }
@Override protected void appendDebugDumpSuffix(StringBuilder sb) { sb.append("(").append(getOid()); if (getVersion() != null) { sb.append(", v").append(getVersion()); } PrismObjectDefinition<O> def = getDefinition(); if (def != null) { sb.append(", ").append(DebugUtil.formatElementName(def.getTypeName())); } sb.append(")"); }
public static <T extends Objectable> void assertObjectDefinition(PrismObjectDefinition<T> objDef, QName elementName, QName typeName, Class<T> compileTimeClass) { assertNotNull("No definition", objDef); assertEquals("Wrong elementName for "+objDef, elementName, objDef.getName()); assertEquals("Wrong typeName for "+objDef, typeName, objDef.getTypeName()); assertEquals("Wrong compileTimeClass for " + objDef, compileTimeClass, objDef.getCompileTimeClass()); }
@Override public Class<? extends ObjectType> getCompileTimeClassForObjectType(QName objectType) { PrismObjectDefinition definition = findObjectDefinitionByType(objectType); if (definition == null) { return null; } return definition.getCompileTimeClass(); }
@Test public void test250EditSchemaRole() throws Exception { final String TEST_NAME="test250EditSchemaRole"; displayTestTitle(TEST_NAME); // GIVEN Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismObjectDefinition<RoleType> roleDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(RoleType.class); PrismObject<RoleType> role = roleDef.instantiate(); // WHEN displayWhen(TEST_NAME); PrismObjectDefinition<RoleType> editDef = getEditObjectDefinition(role); // THEN displayThen(TEST_NAME); // TODO PrismPropertyDefinition requestableDef = editDef.findPropertyDefinition(RoleType.F_REQUESTABLE); assertNotNull("No definition for requestable in role", requestableDef); assertEquals("Wrong requestable displayName", "Can request", requestableDef.getDisplayName()); assertSteadyResources(); }
public <V extends PrismValue, D extends ItemDefinition, AH extends AssignmentHolderType> Source<V,D> constructDefaultSource(ObjectDeltaObject<AH> focusOdo) throws SchemaException { if (objectTemplateMappingType != null) { return null; } PrismObject<AH> focus = focusOdo.getAnyObject(); assignmentDef = focus.getDefinition().findContainerDefinition(FocusType.F_ASSIGNMENT); PrismContainer<AssignmentType> assignment = assignmentDef.instantiate(); assignmentType = assignment.createNewValue().asContainerable(); QName relation = null; AssignmentPropertiesSpecificationType assignmentProperties = autoassignMappingType.getAssignmentProperties(); if (assignmentProperties != null) { relation = assignmentProperties.getRelation(); assignmentType.getSubtype().addAll(assignmentProperties.getSubtype()); } assignmentType.targetRef(role.getOid(), role.asPrismObject().getDefinition().getTypeName(), relation); Source<PrismContainerValue<AssignmentType>, PrismContainerDefinition<AssignmentType>> source = new Source<>(assignment, null, assignment, FocusType.F_ASSIGNMENT); return (Source<V, D>) source; }
public <O extends ObjectType> void applyObjectTemplateToDefinition(PrismObjectDefinition<O> objectDefinition, ObjectTemplateType objectTemplateType, OperationResult result) throws ObjectNotFoundException, SchemaException { if (objectTemplateType == null) { return; } for (ObjectReferenceType includeRef: objectTemplateType.getIncludeRef()) { PrismObject<ObjectTemplateType> subTemplate = cacheRepositoryService.getObject(ObjectTemplateType.class, includeRef.getOid(), null, result); applyObjectTemplateToDefinition(objectDefinition, subTemplate.asObjectable(), result); } for (ObjectTemplateItemDefinitionType templateItemDefType: objectTemplateType.getItem()) { ItemPathType ref = templateItemDefType.getRef(); if (ref == null) { throw new SchemaException("No 'ref' in item definition in "+objectTemplateType); } ItemPath itemPath = prismContext.toPath(ref); ItemDefinition itemDef = objectDefinition.findItemDefinition(itemPath); if (itemDef != null) { applyObjectTemplateItem(itemDef, templateItemDefType, "item " + itemPath + " in object type " + objectDefinition.getTypeName() + " as specified in item definition in " + objectTemplateType); } else { OperationResult subResult = result.createMinorSubresult(SchemaTransformer.class.getName() + ".applyObjectTemplateToDefinition"); subResult.recordPartialError("No definition for item " + itemPath + " in object type " + objectDefinition.getTypeName() + " as specified in item definition in " + objectTemplateType); continue; } } }
@Nullable // null means not supported yet public static PathResolutionResult resolvePathForType(@NotNull Class<? extends ObjectType> clazz, @NotNull ItemPath path, @NotNull PathResolutionContext context) { PrismObjectDefinition<?> def = context.prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(clazz); if (def == null) { return new PathResolutionResult(new Issue(Issue.Severity.WARNING, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "No definition for " + clazz + " in item path: '" + path + "'", null, null)); } ItemDefinition<?> itemDef = def.findItemDefinition(path); if (itemDef != null) { return new PathResolutionResult(itemDef); } else { if (FocusType.class.equals(clazz) && context instanceof ResourceResolutionContext) { ResourceResolutionContext rctx = (ResourceResolutionContext) context; return new PathResolutionResult(new Issue(Issue.Severity.INFO, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "Couldn't verify item path '" + path + "' because specific focus type (user, role, org, ...) is not defined for kind=" + rctx.kind + ", intent=" + rctx.intent, null, null)); } else { return new PathResolutionResult(new Issue(Issue.Severity.WARNING, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "No definition for '" + path + "' in " + def.getName().getLocalPart(), null, null)); } } } }
@Test public void testRoleDefinition() { System.out.println("===[ testRoleDefinition ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); SchemaRegistry schemaRegistry = prismContext.getSchemaRegistry(); // WHEN PrismObjectDefinition<RoleType> roleDefinition = schemaRegistry.findObjectDefinitionByElementName(new QName(SchemaConstantsGenerated.NS_COMMON,"role")); // THEN assertNotNull("No role definition", roleDefinition); System.out.println("Role definition:"); System.out.println(roleDefinition.debugDump()); PrismObjectDefinition<RoleType> roleDefinitionByClass = schemaRegistry.findObjectDefinitionByCompileTimeClass(RoleType.class); assertTrue("Different role def", roleDefinition == roleDefinitionByClass); assertEquals("Wrong compile-time class in role definition", RoleType.class, roleDefinition.getCompileTimeClass()); PrismAsserts.assertPropertyDefinition(roleDefinition, ObjectType.F_NAME, PolyStringType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertItemDefinitionDisplayName(roleDefinition, ObjectType.F_NAME, "ObjectType.name"); PrismAsserts.assertItemDefinitionDisplayOrder(roleDefinition, ObjectType.F_NAME, 0); PrismAsserts.assertPropertyDefinition(roleDefinition, ObjectType.F_DESCRIPTION, DOMUtil.XSD_STRING, 0, 1); PrismAsserts.assertItemDefinitionDisplayName(roleDefinition, ObjectType.F_DESCRIPTION, "ObjectType.description"); PrismAsserts.assertItemDefinitionDisplayOrder(roleDefinition, ObjectType.F_DESCRIPTION, 10); PrismAsserts.assertPropertyDefinition(roleDefinition, RoleType.F_REQUESTABLE, DOMUtil.XSD_BOOLEAN, 0, 1); }
public static <T extends Objectable> ObjectDelta<T> createObjectDelta(ObjectModificationType objectModification, PrismObjectDefinition<T> objDef) throws SchemaException { ObjectDelta<T> objectDelta = objDef.getPrismContext().deltaFactory().object().create(objDef.getCompileTimeClass(), ChangeType.MODIFY); objectDelta.setOid(objectModification.getOid()); for (ItemDeltaType propMod : objectModification.getItemDelta()) { ItemDelta itemDelta = createItemDelta(propMod, objDef); objectDelta.addModification(itemDelta); } return objectDelta; }