public static void assertPropertyDefinition(PrismContainerDefinition<?> containerDef, QName propertyName, QName type, int minOccurs, int maxOccurs) { PrismPropertyDefinition definition = containerDef.findPropertyDefinition(ItemName.fromQName(propertyName)); assertDefinition(definition, propertyName, type, minOccurs, maxOccurs); }
protected PrismContainer<?> getAssignmentExtensionInstance() throws SchemaException { return getAssignmentExtensionDefinition().instantiate(); }
private PrismContainerDefinition<?> getSceneDefinition(SceneImpl ownerScene, ItemPath deltaParentItemPath) { PrismContainerDefinition<?> rootDefinition = getRootDefinition(ownerScene); if (rootDefinition == null) { return null; } else { return rootDefinition.findContainerDefinition(deltaParentItemPath); } }
public static <T extends Containerable,O extends Objectable> ContainerDeltaImpl<T> createDelta(ItemPath containerPath, PrismContainerDefinition<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 <O extends Objectable, T> PropertyDelta<T> createReplaceDelta(PrismContainerDefinition<O> containerDefinition, QName propertyName, PrismPropertyValue<T>... pValues) { PrismPropertyDefinition<T> propertyDefinition = containerDefinition.findPropertyDefinition(ItemName.fromQName(propertyName)); if (propertyDefinition == null) { throw new IllegalArgumentException("No definition for "+propertyName+" in "+containerDefinition); } PropertyDelta<T> delta = new PropertyDeltaImpl<>(ItemName.fromQName(propertyName), propertyDefinition, containerDefinition.getPrismContext()); // hoping the prismContext is there Collection<PrismPropertyValue<T>> valuesToReplace = new ArrayList<>(pValues.length); for (PrismPropertyValue<T> pVal: pValues) { valuesToReplace.add(pVal); } delta.setValuesToReplace(valuesToReplace); return delta; }
/** * Adds XSD definitions from PropertyContainerDefinition. This is complexType and element. * If the property container is an ResourceObjectDefinition, it will add only annotated * complexType definition. * * @param definition PropertyContainerDefinition to process * @param parent element under which the XSD definition will be added */ private void addContainerDefinition(PrismContainerDefinition definition, Element elementParent, Element complexTypeParent) { ComplexTypeDefinition complexTypeDefinition = definition.getComplexTypeDefinition(); if (complexTypeDefinition != null && // Check if the complex type is a top-level complex type. If it is then it was already processed and we can skip it schema.findComplexTypeDefinition(complexTypeDefinition.getTypeName()) == null && // If the definition is not in this schema namespace then skip it. It is only a "ref" getNamespace().equals(complexTypeDefinition.getTypeName().getNamespaceURI()) ) { addComplexTypeDefinition(complexTypeDefinition,complexTypeParent); } Element elementElement = addElementDefinition(definition.getName(), definition.getTypeName(), definition.getMinOccurs(), definition.getMaxOccurs(), elementParent); if (complexTypeDefinition == null || !complexTypeDefinition.isContainerMarker()) { // Need to add a:container annotation to the element as the complex type does not have it addAnnotationToDefinition(elementElement, A_PROPERTY_CONTAINER); } }
assertTrue("<connectorConfiguration> is NOT dynamic", connectorConfContainerDef.isDynamic()); assertEquals("Wrong compile-time class for <connectorConfiguration> in resource definition", ConnectorConfigurationType.class, connectorConfContainerDef.getCompileTimeClass()); assertFalse("Schema is runtime", schemaContainerDef.isRuntimeSchema()); assertEquals("Wrong compile-time class for <schema> in resource definition", XmlSchemaType.class, schemaContainerDef.getCompileTimeClass()); assertEquals("Unexpected number of definitions in <schema>", 3, schemaContainerDef.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(schemaContainerDef, XmlSchemaType.F_CACHING_METADATA, CachingMetadataType.COMPLEX_TYPE, 0, 1); PrismAsserts.assertPropertyDefinition(schemaContainerDef, XmlSchemaType.F_DEFINITION, SchemaDefinitionType.COMPLEX_TYPE, 0, 1); PrismPropertyDefinition definitionPropertyDef = schemaContainerDef.findPropertyDefinition(XmlSchemaType.F_DEFINITION); assertNotNull("Null <definition> definition", definitionPropertyDef);
@Test public void testSubtractAssignmentFromAddDelta() throws Exception { final String TEST_NAME = "testSubtractAssignmentFromAddDelta"; displayTestTile(TEST_NAME); // GIVEN PrismObject<UserType> user = PrismTestUtil.parseObject(USER_BILL_FILE); ObjectDelta<UserType> addDelta = DeltaFactory.Object.createAddDelta(user); // WHEN PrismContainerDefinition<AssignmentType> assignmentDef = PrismTestUtil.getSchemaRegistry() .findContainerDefinitionByCompileTimeClass(AssignmentType.class).clone(); assignmentDef.toMutable().setMaxOccurs(1); PrismContainer<AssignmentType> assignmentContainer = assignmentDef.instantiate(); PrismContainerValue<AssignmentType> assignmentValue = ObjectTypeUtil.createAssignmentTo("00000001-d34d-b33f-f00d-000000000002", ObjectTypes.ROLE, getPrismContext()) .asPrismContainerValue(); assignmentContainer.add(assignmentValue); System.out.println("Delta before operation:\n" + addDelta.debugDump() + "\n"); System.out.println("Assignment to subtract:\n" + assignmentValue.debugDump() + "\n"); boolean removed = addDelta.subtract(ItemPath.create(SchemaConstants.PATH_ASSIGNMENT), assignmentValue, false, false); // THEN System.out.println("Delta after operation:\n" + addDelta.debugDump() + "\n"); System.out.println("Removed: " + removed + "\n"); assertTrue("Not removed", removed); assertTrue("Remaining delta is not an ADD delta", addDelta.isAdd()); assertEquals("Wrong # of remaining assignments", 2, addDelta.getObjectToAdd().asObjectable().getAssignment().size()); }
assertTrue("Extension is NOT runtime", extensionContainer.isRuntimeSchema()); assertTrue("Extension is NOT dynamic", extensionContainer.isDynamic()); assertEquals("Extension size", 0, extensionContainer.getDefinitions().size()); PrismAsserts.assertItemDefinitionDisplayName(complexTypeDefinition, UserType.F_EXTENSION, "ObjectType.extension"); PrismAsserts.assertItemDefinitionDisplayOrder(complexTypeDefinition, UserType.F_EXTENSION, 1000); assertFalse("Activation is runtime", activationContainer.isRuntimeSchema()); assertEquals("Activation size", 12, activationContainer.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(activationContainer, ActivationType.F_ADMINISTRATIVE_STATUS, SchemaConstants.C_ACTIVATION_STATUS_TYPE, 0, 1); assertFalse("Assignment is runtime", assignmentContainer.isRuntimeSchema()); assertEquals("Assignment definition size", 24, assignmentContainer.getDefinitions().size()); PrismContainerDefinition<ConstructionType> constructionContainer = assignmentContainer.findContainerDefinition(AssignmentType.F_CONSTRUCTION); PrismAsserts.assertDefinition(constructionContainer, AssignmentType.F_CONSTRUCTION, ConstructionType.COMPLEX_TYPE, 0, 1); assertFalse("Construction is runtime", constructionContainer.isRuntimeSchema()); assertFalse("Metadata is runtime", metadataContainer.isRuntimeSchema()); assertFalse("Metadata is dynamic", metadataContainer.isDynamic()); assertTrue("Metadata is NOT operational", metadataContainer.isOperational()); assertEquals("Metadata size", 23, metadataContainer.getDefinitions().size());
System.out.println(extDef.debugDump()); assertTrue("Extension is not dynamic", extDef.isRuntimeSchema()); assertTrue("Wrong extension type "+extDef.getTypeName(), USER_EXTENSION_TYPE_QNAME.equals(extDef.getTypeName()) || USER_2_EXTENSION_TYPE_QNAME.equals(extDef.getTypeName())); assertEquals("Wrong extension displayOrder", (Integer)1000, extDef.getDisplayOrder()); PrismPropertyDefinition barPropDef = extDef.findPropertyDefinition(USER_EXT_BAR_ELEMENT); assertNotNull("No 'bar' definition in user extension", barPropDef); PrismAsserts.assertDefinition(barPropDef, USER_EXT_BAR_ELEMENT, DOMUtil.XSD_STRING, 1, 1); assertTrue("'bar' not indexed", barPropDef.isIndexed()); PrismPropertyDefinition foobarPropDef = extDef.findPropertyDefinition(USER_EXT_FOOBAR_ELEMENT); assertNotNull("No 'foobar' definition in user extension", foobarPropDef); PrismAsserts.assertDefinition(foobarPropDef, USER_EXT_FOOBAR_ELEMENT, DOMUtil.XSD_STRING, 0, 1); assertNull("'foobar' has non-null indexed flag", foobarPropDef.isIndexed()); PrismPropertyDefinition multiPropDef = extDef.findPropertyDefinition(USER_EXT_MULTI_ELEMENT); assertNotNull("No 'multi' definition in user extension", multiPropDef); PrismAsserts.assertDefinition(multiPropDef, USER_EXT_MULTI_ELEMENT, DOMUtil.XSD_STRING, 0, -1); assertFalse("'multi' not indexed", multiPropDef.isIndexed()); PrismPropertyDefinition ext2Def = extDef.findPropertyDefinition(USER_EXT_2_ELEMENT); assertNotNull("No 'ext2' definition in user extension", ext2Def); PrismAsserts.assertDefinition(ext2Def, USER_EXT_2_ELEMENT, DOMUtil.XSD_STRING, 1, 1);
public static ItemDefinition findItemDefinition(ItemPath itemPath, PrismContainerDefinition<? extends Containerable> containerDef) { ItemDefinition itemDef = containerDef.findItemDefinition(itemPath); if (itemDef == null) { throw new IllegalStateException("No definition for item " + itemPath + " in container definition " + containerDef); } return itemDef; }
@Test public void test010ConnectorSchemaSanity() throws Exception { final String TEST_NAME = "test010ConnectorSchemaSanity"; TestUtil.displayTestTitle(TEST_NAME); IntegrationTestTools.assertConnectorSchemaSanity(connectorSchema, "LDAP connector", true); PrismContainerDefinition configurationDefinition = connectorSchema.findItemDefinition(ResourceType.F_CONNECTOR_CONFIGURATION.getLocalPart(), PrismContainerDefinition.class); PrismContainerDefinition configurationPropertiesDefinition = configurationDefinition.findContainerDefinition(SchemaConstants.CONNECTOR_SCHEMA_CONFIGURATION_PROPERTIES_ELEMENT_QNAME); PrismPropertyDefinition<String> propHost = configurationPropertiesDefinition.findPropertyDefinition(new ItemName(UcfTestUtil.CONNECTOR_LDAP_NS,"host")); assertNotNull("No definition for configuration property 'host' in connector schema", propHost); PrismAsserts.assertDefinition(propHost, new QName(UcfTestUtil.CONNECTOR_LDAP_NS,"host"), DOMUtil.XSD_STRING, 1, 1); assertEquals("Wrong property 'host' display name", "Host", propHost.getDisplayName()); assertEquals("Wrong property 'host' help", "The name or IP address of the LDAP server host.", propHost.getHelp()); assertEquals("Wrong property 'host' display order", (Integer)1, propHost.getDisplayOrder()); // MID-2642 PrismPropertyDefinition<String> propPort = configurationPropertiesDefinition.findPropertyDefinition(new ItemName(UcfTestUtil.CONNECTOR_LDAP_NS,"port")); assertNotNull("No definition for configuration property 'port' in connector schema", propPort); PrismAsserts.assertDefinition(propPort, new QName(UcfTestUtil.CONNECTOR_LDAP_NS,"port"), DOMUtil.XSD_INT, 0, 1); assertEquals("Wrong property 'port' display name", "Port number", propPort.getDisplayName()); assertEquals("Wrong property 'port' help", "LDAP server port number.", propPort.getHelp()); assertEquals("Wrong property 'port' display order", (Integer)2, propPort.getDisplayOrder()); // MID-2642 }
private void assertConfigurationPropertyDefinition(PrismContainerDefinition<Containerable> containerDefinition, String propertyLocalName, QName expectedType, int expectedMinOccurs, int expectedMaxOccurs, String expectedDisplayName, String expectedHelp) { ItemName propName = new ItemName(containerDefinition.getTypeName().getNamespaceURI(),propertyLocalName); PrismPropertyDefinition propDef = containerDefinition.findPropertyDefinition(propName); assertConfigurationPropertyDefinition(propDef, expectedType, expectedMinOccurs, expectedMaxOccurs, expectedDisplayName, expectedHelp); }
PrismContainerDefinition<PasswordHistoryEntryType> historyEntryDefinition = oldCredentialContainer.getDefinition().findContainerDefinition(PasswordType.F_HISTORY_ENTRY); PrismContainer<PasswordHistoryEntryType> historyEntry = historyEntryDefinition.instantiate();
public static void assertConnectorSchemaSanity(PrismSchema schema, String connectorDescription, boolean expectConnIdSchema) { assertNotNull("Cannot parse connector schema of "+connectorDescription,schema); assertFalse("Empty connector schema in "+connectorDescription,schema.isEmpty()); display("Parsed connector schema of "+connectorDescription,schema); // Local schema namespace is used here. PrismContainerDefinition configurationDefinition = schema.findItemDefinition(ResourceType.F_CONNECTOR_CONFIGURATION.getLocalPart(), PrismContainerDefinition.class); assertNotNull("Definition of <configuration> property container not found in connector schema of "+connectorDescription, configurationDefinition); assertFalse("Empty definition of <configuration> property container in connector schema of "+connectorDescription, configurationDefinition.isEmpty()); if (expectConnIdSchema) { // ICFC schema is used on other elements PrismContainerDefinition configurationPropertiesDefinition = configurationDefinition.findContainerDefinition(SchemaConstants.CONNECTOR_SCHEMA_CONFIGURATION_PROPERTIES_ELEMENT_QNAME); assertNotNull("Definition of <configurationProperties> property container not found in connector schema of "+connectorDescription, configurationPropertiesDefinition); assertFalse("Empty definition of <configurationProperties> property container in connector schema of "+connectorDescription, configurationPropertiesDefinition.isEmpty()); assertFalse("No definitions in <configurationProperties> in "+connectorDescription, configurationPropertiesDefinition.getDefinitions().isEmpty()); // TODO: other elements } }
assertTrue("Extension is not runtime", extensionContainer.isRuntimeSchema()); assertTrue("Extension is not empty", extensionContainer.getDefinitions().isEmpty()); PrismAsserts.assertItemDefinitionDisplayName(userDefinition, USER_EXTENSION_QNAME, "ObjectType.extension"); PrismAsserts.assertItemDefinitionDisplayOrder(userDefinition, USER_EXTENSION_QNAME, 1000); assertFalse("Activation is runtime", activationContainer.isRuntimeSchema()); assertTrue("Activation is NOT operational", activationContainer.isOperational()); assertEquals("Activation size", 3, activationContainer.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(activationContainer, USER_ENABLED_QNAME, DOMUtil.XSD_BOOLEAN, 0, 1); PrismAsserts.assertPropertyDefinition(activationContainer, USER_VALID_FROM_QNAME, DOMUtil.XSD_DATETIME, 0, 1); assertFalse("Assignment is runtime", assignmentContainer.isRuntimeSchema()); assertEquals("Wrong compile time class for assignment container", AssignmentType.class, assignmentContainer.getCompileTimeClass()); assertEquals("Assignment size", 4, assignmentContainer.getDefinitions().size()); PrismAsserts.assertPropertyDefinition(assignmentContainer, USER_DESCRIPTION_QNAME, DOMUtil.XSD_STRING, 0, 1); PrismAsserts.assertPropertyDefinition(assignmentContainer, USER_ACCOUNT_CONSTRUCTION_QNAME, ACCOUNT_CONSTRUCTION_TYPE_QNAME, 0, 1);
public boolean isFocusObject() { return sourceDefinition != null && sourceDefinition.getCompileTimeClass() != null && FocusType.class.isAssignableFrom(sourceDefinition.getCompileTimeClass()); }
ItemDefinition containingPcd = pcDef.findItemDefinition(parentPath); PrismContainerDefinition containerDef = null; if (containingPcd == null) { containerDef = pcDef.findContainerDefinition(parentPath.allUpToLastName()); if (containerDef == null){ if (allowRawValues){
/** * Test if a schema directory can be loaded to the schema registry. This contains definition of * user extension, therefore check if it is applied to the user definition. */ @Test public void testTypeOverride() throws SAXException, IOException, SchemaException { System.out.println("===[ testTypeOverride ]==="); PrismContext context = constructPrismContext(); SchemaRegistryImpl reg = (SchemaRegistryImpl) context.getSchemaRegistry(); reg.registerPrismSchemasFromDirectory(EXTRA_SCHEMA_DIR); context.initialize(); PrismSchema schema = reg.getPrismSchema(NS_ROOT); System.out.println("Parsed root schema:"); System.out.println(schema.debugDump()); PrismContainerDefinition rootContDef = schema.findContainerDefinitionByElementName(new QName(NS_ROOT,"root")); assertNotNull("Not <root> definition", rootContDef); PrismContainerDefinition extensionContDef = rootContDef.findContainerDefinition(new ItemName(NS_FOO, "extension")); assertNotNull("Not <extension> definition", extensionContDef); assertEquals("Wrong <extension> type", new QName(NS_ROOT, "MyExtensionType"), extensionContDef.getTypeName()); }
/** * Looks for a top-level definition for the specified element name (in all schemas). */ @Override @Deprecated public ItemDefinition resolveGlobalItemDefinition(QName elementQName, PrismContainerDefinition<?> containerDefinition) throws SchemaException { return resolveGlobalItemDefinition(elementQName, containerDefinition != null ? containerDefinition.getComplexTypeDefinition() : null); }