@Override public LayerRefinedObjectClassDefinition getDefaultRefinedDefinition(ShadowKindType kind) { return LayerRefinedObjectClassDefinitionImpl .wrap(refinedResourceSchema.getDefaultRefinedDefinition(kind), layer); }
@Override public RefinedObjectClassDefinition getRefinedDefinition(ShadowKindType kind, Collection<String> intents) throws SchemaException { return refinedResourceSchema.getRefinedDefinition(kind, intents); }
@Override public List<? extends RefinedObjectClassDefinition> getRefinedDefinitions() { return refinedResourceSchema.getRefinedDefinitions(); }
private void assertRefinedSchema(ResourceType resourceType, RefinedResourceSchema rSchema, LayerType sourceLayer, LayerType validationLayer, boolean assertEntitlements, boolean assertPasswordPolicy) { assertEquals("Unexpected number of object classes in refined schema", 2, rSchema.getDefinitions().size()); for (Definition def: rSchema.getDefinitions()) { if (!(def instanceof RefinedObjectClassDefinition)) { AssertJUnit.fail("Non-refined definition sneaked into resource schema: "+def); assertFalse("No account definitions", rSchema.getRefinedDefinitions(ShadowKindType.ACCOUNT).isEmpty()); RefinedObjectClassDefinition rAccountDef = rSchema.getRefinedDefinition(ShadowKindType.ACCOUNT, (String)null); RefinedObjectClassDefinition accountDefByNullObjectclass = rSchema.findRefinedDefinitionByObjectClassQName(ShadowKindType.ACCOUNT, null); assertEquals("findAccountDefinitionByObjectClass(null) returned wrong value", rAccountDef, accountDefByNullObjectclass); RefinedObjectClassDefinition accountDefByIcfAccountObjectclass = rSchema.findRefinedDefinitionByObjectClassQName(ShadowKindType.ACCOUNT, new QName(resourceType.getNamespace(), SchemaTestConstants.ICF_ACCOUNT_OBJECT_CLASS_LOCAL_NAME)); assertEquals("findAccountDefinitionByObjectClass(ICF account) returned wrong value", rAccountDef, accountDefByIcfAccountObjectclass); assertFalse("No entitlement definitions", rSchema.getRefinedDefinitions(ShadowKindType.ENTITLEMENT).isEmpty()); RefinedObjectClassDefinition rEntDef = rSchema.getRefinedDefinition(ShadowKindType.ENTITLEMENT, (String)null); assertNotNull("No entitlement definition for null intent", rEntDef); RefinedObjectClassDefinition rEntDefGroup = rSchema.getRefinedDefinition(ShadowKindType.ENTITLEMENT, ENTITLEMENT_GROUP_INTENT); assertNotNull("No entitlement for intent '"+ENTITLEMENT_GROUP_INTENT+"'", rEntDefGroup);
assertNotNull("Refined schema is null", rSchema); System.out.println("Refined schema"); System.out.println(rSchema.debugDump()); assertFalse("No account definitions", rSchema.getRefinedDefinitions(ShadowKindType.ACCOUNT).isEmpty()); RefinedObjectClassDefinition rAccountDef = rSchema.getRefinedDefinition(ShadowKindType.ACCOUNT, (String)null); assertNotNull("No default account definition", rAccountDef); RefinedObjectClassDefinition accountDefByIcfAccountObjectclass = rSchema.findRefinedDefinitionByObjectClassQName(ShadowKindType.ACCOUNT, OBJECT_CLASS_INETORGPERSON_QNAME); assertTrue("findAccountDefinitionByObjectClass("+OBJECT_CLASS_INETORGPERSON_QNAME+") returned wrong value", rAccountDef.equals(accountDefByIcfAccountObjectclass)); assertEquals("Unexpected number of propertyDefinitions", 53, propertyDefinitions.size()); assertFalse("No entitlement definitions", rSchema.getRefinedDefinitions(ShadowKindType.ENTITLEMENT).isEmpty()); RefinedObjectClassDefinition rEntDef = rSchema.getRefinedDefinition(ShadowKindType.ENTITLEMENT, (String)null); assertNotNull("No entitlement definition for null intent", rEntDef); RefinedObjectClassDefinition rEntDefGroup = rSchema.getRefinedDefinition(ShadowKindType.ENTITLEMENT, ENTITLEMENT_LDAP_GROUP_INTENT); assertNotNull("No entitlement for intent '"+ENTITLEMENT_LDAP_GROUP_INTENT+"'", rEntDefGroup);
@Test public void test130ProtectedAccount() throws Exception { final String TEST_NAME = "test130ProtectedAccount"; 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 Collection<ResourceObjectPattern> protectedAccounts = rAccount.getProtectedObjectPatterns(); // THEN assertNotNull("Null protectedAccounts", protectedAccounts); assertFalse("Empty protectedAccounts", protectedAccounts.isEmpty()); assertEquals("Unexpected number of protectedAccounts", 2, protectedAccounts.size()); Iterator<ResourceObjectPattern> iterator = protectedAccounts.iterator(); assertDeprecatedProtectedAccount("first protected account", iterator.next(), "uid=idm,ou=Administrators,dc=example,dc=com", rAccount); assertDeprecatedProtectedAccount("second protected account", iterator.next(), "uid=root,ou=Administrators,dc=example,dc=com", rAccount); }
refinedSchema == RefinedResourceSchemaImpl.getRefinedSchema(resourceType, prismContext)); RefinedObjectClassDefinition accountDef = refinedSchema.getDefaultRefinedDefinition(ShadowKindType.ACCOUNT); assertNotNull("Account definition is missing", accountDef); assertNotNull("Null identifiers in account", accountDef.getPrimaryIdentifiers()); accountDef.findAttributeDefinition(new QName(SchemaConstants.NS_ICF_SCHEMA, "password"))); RefinedObjectClassDefinition posixAccountDef = refinedSchema.getRefinedDefinition(RESOURCE_OPENDJ_POSIX_ACCOUNT_OBJECTCLASS); assertNotNull("posixAccount definition is missing", posixAccountDef); assertNotNull("Null identifiers in posixAccount", posixAccountDef.getPrimaryIdentifiers());
ObjectClassComplexTypeDefinition objectClassDefinition = refinedSchema.getOriginalResourceSchema().findObjectClassDefinition(objectclass); if (objectClassDefinition == null) { throw new SchemaException("No object class "+objectclass+" in the schema for "+source); refinedObjectClassDefinition = refinedSchema.getRefinedDefinition(kind, intent); LOGGER.trace("Determined refined object class {} by using kind={}, intent={}", new Object[]{refinedObjectClassDefinition, kind, intent}); } else if (objectclass != null) { refinedObjectClassDefinition = refinedSchema.getRefinedDefinition(objectclass); LOGGER.trace("Determined refined object class {} by using objectClass={}", new Object[]{refinedObjectClassDefinition, objectclass});
private RefinedObjectClassDefinition determineObjectClassDefinition(PrismObject<ShadowType> shadow, ResourceType resource) throws SchemaException, ConfigurationException { ShadowType shadowType = shadow.asObjectable(); RefinedResourceSchema refinedSchema = RefinedResourceSchemaImpl.getRefinedSchema(resource, prismContext); if (refinedSchema == null) { throw new ConfigurationException("No schema definied for "+resource); } RefinedObjectClassDefinition objectClassDefinition = null; ShadowKindType kind = shadowType.getKind(); String intent = shadowType.getIntent(); QName objectClass = shadow.asObjectable().getObjectClass(); if (kind != null) { objectClassDefinition = refinedSchema.getRefinedDefinition(kind, intent); } else { // Fallback to objectclass only if (objectClass == null) { throw new SchemaException("No kind nor objectclass definied in "+shadow); } objectClassDefinition = refinedSchema.findRefinedDefinitionByObjectClassQName(null, objectClass); } if (objectClassDefinition == null) { throw new SchemaException("Definition for "+shadow+" not found (objectClass=" + PrettyPrinter.prettyPrint(objectClass) + ", kind="+kind+", intent='"+intent+"') in schema of " + resource); } return objectClassDefinition; }
@Override public ObjectClassComplexTypeDefinition findObjectClassDefinition( ShadowKindType kind, String intent) { return refinedResourceSchema.findObjectClassDefinition(kind, intent); }
@Test public void test110ApplyAttributeDefinition() throws Exception { final String TEST_NAME = "test110ApplyAttributeDefinition"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext prismContext = createInitializedPrismContext(); PrismObject<ResourceType> resource = prismContext.parseObject(RESOURCE_COMPLEX_FILE); RefinedResourceSchema rSchema = RefinedResourceSchemaImpl.parse(resource, prismContext); System.out.println("Refined schema:"); System.out.println(rSchema.debugDump(1)); RefinedObjectClassDefinition defaultAccountDefinition = rSchema.getDefaultRefinedDefinition(ShadowKindType.ACCOUNT); assertNotNull("No refined default account definition in "+rSchema, defaultAccountDefinition); System.out.println("Refined account definition:"); System.out.println(defaultAccountDefinition.debugDump(1)); PrismObject<ShadowType> accObject = prismContext.parseObject(new File(TEST_DIR_NAME, "account-jack.xml")); PrismContainer<Containerable> attributesContainer = accObject.findContainer(ShadowType.F_ATTRIBUTES); System.out.println("Attributes container:"); System.out.println(attributesContainer.debugDump(1)); // WHEN attributesContainer.applyDefinition((PrismContainerDefinition)defaultAccountDefinition.toResourceAttributeContainerDefinition(), true); // THEN System.out.println("Parsed account:"); System.out.println(accObject.debugDump(1)); assertAccountShadow(accObject, resource, prismContext); }
protected void assertGlobalStateUntouched() throws SchemaException { RefinedResourceSchema refinedSchema = RefinedResourceSchema.getRefinedSchema(getDummyResourceObject()); RefinedObjectClassDefinition rOcDef = refinedSchema.getDefaultRefinedDefinition(ShadowKindType.ACCOUNT); assertAttributeFlags(rOcDef, SchemaConstants.ICFS_UID, true, false, false); assertAttributeFlags(rOcDef, SchemaConstants.ICFS_NAME, true, true, true); assertAttributeFlags(rOcDef, new QName("location"), true, true, true); assertAttributeFlags(rOcDef, new QName("weapon"), true, true, true); }
refinedSchema == RefinedResourceSchemaImpl.getRefinedSchema(resourceType, prismContext)); RefinedObjectClassDefinition accountDef = refinedSchema.getDefaultRefinedDefinition(ShadowKindType.ACCOUNT); assertNotNull("Account definition is missing", accountDef); assertNotNull("Null identifiers in account", accountDef.getPrimaryIdentifiers()); for (Definition def: refinedSchema.getDefinitions()) { if (!(def instanceof RefinedObjectClassDefinition)) { fail("Non-refined definition sneaked into resource schema: "+def); assertEquals("Unexpected number of schema definitions", getExpectedRefinedSchemaDefinitions(), refinedSchema.getDefinitions().size());
@Test public void test010ParseFromResourceComplex() throws Exception { final String TEST_NAME = "test010ParseFromResourceComplex"; TestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext prismContext = createInitializedPrismContext(); PrismObject<ResourceType> resource = prismContext.parseObject(RESOURCE_COMPLEX_FILE); ResourceType resourceType = resource.asObjectable(); // WHEN TestUtil.displayWhen(TEST_NAME); RefinedResourceSchema rSchema = RefinedResourceSchemaImpl.parse(resourceType, prismContext); // THEN TestUtil.displayThen(TEST_NAME); assertNotNull("Refined schema is null", rSchema); System.out.println("Refined schema"); System.out.println(rSchema.debugDump()); assertRefinedSchema(resourceType, rSchema, null, LayerType.MODEL, true, true); assertLayerRefinedSchema(resourceType, rSchema, LayerType.SCHEMA, LayerType.SCHEMA, true, true); assertLayerRefinedSchema(resourceType, rSchema, LayerType.MODEL, LayerType.MODEL, true, true); assertLayerRefinedSchema(resourceType, rSchema, LayerType.PRESENTATION, LayerType.PRESENTATION, true, true); RefinedObjectClassDefinition rAccount = rSchema.getRefinedDefinition(ShadowKindType.ACCOUNT, (String)null); RefinedAttributeDefinition userPasswordAttribute = rAccount.findAttributeDefinition("userPassword"); assertNotNull("No userPassword attribute", userPasswordAttribute); assertTrue("userPassword not ignored", userPasswordAttribute.isIgnored()); }
@Override public CompositeRefinedObjectClassDefinition determineCompositeObjectClassDefinition( PrismObject<ShadowType> shadow, Collection<QName> additionalAuxiliaryObjectClassQNames) throws SchemaException { return refinedResourceSchema.determineCompositeObjectClassDefinition(shadow, additionalAuxiliaryObjectClassQNames); }
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; }
policyObjectClass = schema.findDefaultObjectClassDefinition(policyKind); policyIntent = policyObjectClass.getIntent(); } else { policyObjectClass = schema.findObjectClassDefinition(policyKind, policyIntent);
public LayerRefinedObjectClassDefinition findRefinedDefinitionByObjectClassQName(ShadowKindType kind, QName objectClass) { return LayerRefinedObjectClassDefinitionImpl .wrap(refinedResourceSchema.findRefinedDefinitionByObjectClassQName(kind, objectClass), layer); }
private PrismObject<ShadowType> getGroupShadow(DummyResourceContoller dummyResourceCtl, QName objectClass, String name, Task task, OperationResult result) throws Exception { PrismObject<ResourceType> resource = dummyResourceCtl.getResource(); ObjectClassComplexTypeDefinition groupDef = RefinedResourceSchema.getRefinedSchema(resource) .findObjectClassDefinition(dummyResourceCtl.getGroupObjectClass()); ResourceAttributeDefinition<Object> nameDef = groupDef.findAttributeDefinition(SchemaConstants.ICFS_NAME); assertNotNull("No icfs:name definition", nameDef); ObjectQuery query = ObjectQueryUtil.createResourceAndObjectClassFilterPrefix(resource.getOid(), objectClass, prismContext) .and().item(ItemPath.create(ShadowType.F_ATTRIBUTES, SchemaConstants.ICFS_NAME), nameDef).eq(name) .build(); SearchResultList<PrismObject<ShadowType>> shadows = modelService.searchObjects(ShadowType.class, query, null, task, result); assertEquals("Wrong # of results for " + name + " of " + objectClass + " at " + resource, 1, shadows.size()); return shadows.get(0); }
@Override public String debugDump(int indent) { StringBuilder sb = new StringBuilder(); DebugUtil.indentDebugDump(sb, indent); sb.append("LRSchema(layer=").append(layer).append(",\n"); sb.append(refinedResourceSchema.debugDump(indent + 1)); return sb.toString(); }