private CallableResult<List<AssignmentItemDto>> loadAssignments() throws Exception { LOGGER.debug("Loading assignments."); CallableResult callableResult = new CallableResult(); List<AssignmentItemDto> list = new ArrayList<AssignmentItemDto>(); callableResult.setValue(list); PrismObject<UserType> user = principalModel.getObject(); if (user == null || user.findContainer(UserType.F_ASSIGNMENT) == null) { return callableResult; } Task task = createSimpleTask(OPERATION_LOAD_ASSIGNMENTS); OperationResult result = task.getResult(); callableResult.setResult(result); PrismContainer assignments = user.findContainer(UserType.F_ASSIGNMENT); List<PrismContainerValue> values = assignments.getValues(); for (PrismContainerValue assignment : values) { AssignmentItemDto item = createAssignmentItem(user, assignment, task, result); if (item != null) { list.add(item); } } result.recordSuccessIfUnknown(); result.recomputeStatus(); Collections.sort(list); LOGGER.debug("Finished assignments loading."); return callableResult; }
// @Test public void testDefinitionlessConstructionAndSchemaApplication() throws Exception { final String TEST_NAME = "testDefinitionlessConstructionAndSchemaApplication"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN // No context needed (yet) PrismObject<UserType> user = new PrismObject<UserType>(USER_QNAME, UserType.class); // Fill-in object values, no schema checking fillInUserDrake(user, false); // Make sure the object is OK PrismContext ctx = constructInitializedPrismContext(); assertUserDrake(user, false, ctx); PrismObjectDefinition<UserType> userDefinition = getFooSchema(ctx).findObjectDefinitionByElementName(new QName(NS_FOO, "user")); // WHEN user.applyDefinition(userDefinition); // THEN System.out.println("User:"); System.out.println(user.debugDump()); // Check schema now assertUserDrake(user, true, ctx); }
public static ResourceSchema getResourceSchema( PrismObject<ResourceType> resource, PrismContext prismContext) throws SchemaException { Element resourceXsdSchema = ResourceTypeUtil.getResourceXsdSchema(resource); if (resourceXsdSchema == null) { return null; } Object userDataEntry = resource.getUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA); if (userDataEntry != null) { if (userDataEntry instanceof ResourceSchema) { return (ResourceSchema) userDataEntry; } else { throw new IllegalStateException( "Expected ResourceSchema under user data key " + USER_DATA_KEY_PARSED_RESOURCE_SCHEMA + "in " + resource + ", but got " + userDataEntry.getClass()); } } else { InternalMonitor.recordResourceSchemaParse(); ResourceSchemaImpl parsedSchema = ResourceSchemaImpl.parse( resourceXsdSchema, "resource schema of " + resource, prismContext); if (parsedSchema == null) { throw new IllegalStateException("Parsed schema is null: most likely an internall error"); } resource.setUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA, parsedSchema); parsedSchema.setNamespace(ResourceTypeUtil.getResourceNamespace(resource)); return parsedSchema; } }
public static RefinedResourceSchema getRefinedSchema( PrismObject<ResourceType> resource, PrismContext prismContext) throws SchemaException { if (resource == null) { throw new SchemaException("Could not get refined schema, resource does not exist."); } Object userDataEntry = resource.getUserData(USER_DATA_KEY_REFINED_SCHEMA); if (userDataEntry != null) { if (userDataEntry instanceof RefinedResourceSchema) { return (RefinedResourceSchema) userDataEntry; } else { throw new IllegalStateException( "Expected RefinedResourceSchema under user data key " + USER_DATA_KEY_REFINED_SCHEMA + "in " + resource + ", but got " + userDataEntry.getClass()); } } else { RefinedResourceSchema refinedSchema = parse(resource, prismContext); resource.setUserData(USER_DATA_KEY_REFINED_SCHEMA, refinedSchema); return refinedSchema; } }
public static void setParsedResourceSchemaConditional( ResourceType resourceType, ResourceSchema parsedSchema) { if (hasParsedSchema(resourceType)) { return; } PrismObject<ResourceType> resource = resourceType.asPrismObject(); resource.setUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA, parsedSchema); }
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 AssignmentItemDto createAssignmentItem( PrismObject<UserType> user, PrismContainerValue assignment, Task task, OperationResult result) { PrismReference targetRef = assignment.findReference(AssignmentType.F_TARGET_REF); if (targetRef == null || targetRef.isEmpty()) { // account construction PrismContainer construction = assignment.findContainer(AssignmentType.F_CONSTRUCTION); String name = null; String description = null; if (construction.getValue().asContainerable() != null && !construction.isEmpty()) { ConstructionType constr = (ConstructionType) construction.getValue().asContainerable(); description = (String) construction.getPropertyRealValue(ConstructionType.F_DESCRIPTION, String.class); if (constr.getResourceRef() != null) { ObjectReferenceType resourceRef = constr.getResourceRef(); PrismObject resource = WebModelUtils.loadObject( ResourceType.class, resourceRef.getOid(), this, task, result); name = WebMiscUtil.getName(resource); } } return new AssignmentItemDto( AssignmentEditorDtoType.ACCOUNT_CONSTRUCTION, name, description, null); } PrismReferenceValue refValue = targetRef.getValue(); PrismObject value = refValue.getObject(); if (value == null) { // resolve reference value = WebModelUtils.loadObject(ObjectType.class, refValue.getOid(), this, task, result); } if (value == null) { // we couldn't resolve assignment details return new AssignmentItemDto(null, null, null, null); } String name = WebMiscUtil.getName(value); AssignmentEditorDtoType type = AssignmentEditorDtoType.getType(value.getCompileTimeClass()); String relation = refValue.getRelation() != null ? refValue.getRelation().getLocalPart() : null; String description = null; if (RoleType.class.isAssignableFrom(value.getCompileTimeClass())) { description = (String) value.getPropertyRealValue(RoleType.F_DESCRIPTION, String.class); } return new AssignmentItemDto(type, name, description, relation); }
private AccountCallableResult<List<SimpleAccountDto>> loadAccounts() throws Exception { LOGGER.debug("Loading accounts."); AccountCallableResult callableResult = new AccountCallableResult(); List<SimpleAccountDto> list = new ArrayList<SimpleAccountDto>(); callableResult.setValue(list); PrismObject<UserType> user = principalModel.getObject(); if (user == null) { return callableResult; } Task task = createSimpleTask(OPERATION_LOAD_ACCOUNTS); OperationResult result = task.getResult(); callableResult.setResult(result); Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection( ShadowType.F_RESOURCE, GetOperationOptions.createResolve()); List<ObjectReferenceType> references = user.asObjectable().getLinkRef(); for (ObjectReferenceType reference : references) { PrismObject<ShadowType> account = WebModelUtils.loadObject( ShadowType.class, reference.getOid(), options, this, task, result); if (account == null) { continue; } ShadowType accountType = account.asObjectable(); OperationResultType fetchResult = accountType.getFetchResult(); if (fetchResult != null) { callableResult.getFetchResults().add(OperationResult.createOperationResult(fetchResult)); } ResourceType resource = accountType.getResource(); String resourceName = WebMiscUtil.getName(resource); list.add( new SimpleAccountDto( WebMiscUtil.getOrigStringFromPoly(accountType.getName()), resourceName)); } result.recordSuccessIfUnknown(); result.recomputeStatus(); LOGGER.debug("Finished accounts loading."); return callableResult; }
private List<String> prepareAutoCompleteList( String input, PrismObject<LookupTableType> lookupTable) { List<String> values = new ArrayList<>(); if (lookupTable == null) { return values; } List<LookupTableRowType> rows = lookupTable.asObjectable().getRow(); if (input == null || input.isEmpty()) { for (LookupTableRowType row : rows) { values.add(WebComponentUtil.getOrigStringFromPoly(row.getLabel())); } } else { for (LookupTableRowType row : rows) { if (WebComponentUtil.getOrigStringFromPoly(row.getLabel()) != null && WebComponentUtil.getOrigStringFromPoly(row.getLabel()) .toLowerCase() .contains(input.toLowerCase())) { values.add(WebComponentUtil.getOrigStringFromPoly(row.getLabel())); } } } return values; }
private ObjectQuery getAssociationsSearchQuery( PrismContext prismContext, PrismObject resource, QName objectClass, ShadowKindType kind, String intent) { try { ObjectFilter andFilter = AndFilter.createAnd( EqualFilter.createEqual( ShadowType.F_OBJECT_CLASS, ShadowType.class, prismContext, objectClass), EqualFilter.createEqual(ShadowType.F_KIND, ShadowType.class, prismContext, kind), // EqualFilter.createEqual(ShadowType.F_INTENT, ShadowType.class, // prismContext, intent), RefFilter.createReferenceEqual( new ItemPath(ShadowType.F_RESOURCE_REF), ShadowType.class, prismContext, resource.getOid())); ObjectQuery query = ObjectQuery.createObjectQuery(andFilter); return query; } catch (SchemaException ex) { LoggingUtils.logUnexpectedException(LOGGER, "Unable to create associations search query", ex); return null; } }
@Test public void testCloneEquals() throws Exception { final String TEST_NAME = "testCloneEquals"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext ctx = constructInitializedPrismContext(); PrismObjectDefinition<UserType> userDefinition = getFooSchema(ctx).findObjectDefinitionByElementName(new QName(NS_FOO, "user")); PrismObject<UserType> user = userDefinition.instantiate(); fillInUserDrake(user, true); PrismObject<UserType> clone = user.clone(); // WHEN, THEN assertTrue("Clone not equal", clone.equals(user)); assertTrue("Clone not equivalent", clone.equivalent(user)); }
@Test public void testUserSimplePropertyDiffReplace() throws Exception { System.out.println("\n\n===[ testUserSimplePropertyDiffReplace ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismObject<UserType> user1 = userDef.instantiate(); user1.setOid(USER_JACK_OID); user1.setPropertyRealValue(UserType.F_NAME, PrismTestUtil.createPolyString("test name")); PrismObject<UserType> user2 = userDef.instantiate(); user2.setOid(USER_JACK_OID); user2.setPropertyRealValue(UserType.F_NAME, PrismTestUtil.createPolyString("other name")); // WHEN ObjectDelta<UserType> delta = user1.diff(user2); // THEN assertNotNull(delta); System.out.println(delta.debugDump()); assertEquals("Unexpected number of midifications", 1, delta.getModifications().size()); PrismAsserts.assertPropertyReplace( delta, UserType.F_NAME, PrismTestUtil.createPolyString("other name")); assertEquals("Wrong OID", USER_JACK_OID, delta.getOid()); delta.checkConsistence(); }
@Test public void testUserSimpleDiffMultiAdd() throws Exception { System.out.println("\n\n===[ testUserSimpleDiffMulti ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismObject<UserType> user1 = userDef.instantiate(); user1.setOid(USER_JACK_OID); PrismProperty<String> anamesProp1 = user1.findOrCreateProperty(UserType.F_ADDITIONAL_NAMES); anamesProp1.addRealValue("foo"); anamesProp1.addRealValue("bar"); PrismObject<UserType> user2 = userDef.instantiate(); user2.setOid(USER_JACK_OID); PrismProperty<String> anamesProp2 = user2.findOrCreateProperty(UserType.F_ADDITIONAL_NAMES); anamesProp2.addRealValue("foo"); anamesProp2.addRealValue("bar"); anamesProp2.addRealValue("baz"); // WHEN ObjectDelta<UserType> delta = user1.diff(user2); // THEN assertNotNull(delta); System.out.println(delta.debugDump()); assertEquals("Unexpected number of midifications", 1, delta.getModifications().size()); PrismAsserts.assertPropertyAdd(delta, UserType.F_ADDITIONAL_NAMES, "baz"); assertEquals("Wrong OID", USER_JACK_OID, delta.getOid()); delta.checkConsistence(); }
/** * Construct object without schema. Starts by creating object "out of the blue" and the working * downwards. */ @Test(enabled = false) // definition-less containers are no longer supported public void testDefinitionlessConstruction() throws Exception { final String TEST_NAME = "testDefinitionlessConstruction"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN // No context needed // WHEN PrismObject<UserType> user = new PrismObject<UserType>(USER_QNAME, UserType.class); // Fill-in object values, no schema checking fillInUserDrake(user, false); // THEN System.out.println("User:"); System.out.println(user.debugDump()); // Check if the values are correct, no schema checking PrismContext ctx = constructInitializedPrismContext(); assertUserDrake(user, false, ctx); }
/** * Construct object with schema. Starts by instantiating a definition and working downwards. All * the items in the object should have proper definition. */ @Test public void testConstructionWithSchema() throws Exception { final String TEST_NAME = "testConstructionWithSchema"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext ctx = constructInitializedPrismContext(); PrismObjectDefinition<UserType> userDefinition = getFooSchema(ctx).findObjectDefinitionByElementName(new QName(NS_FOO, "user")); // WHEN PrismObject<UserType> user = userDefinition.instantiate(); // Fill-in object values, checking presence of definition while doing so fillInUserDrake(user, true); // THEN System.out.println("User:"); System.out.println(user.debugDump()); // Check if the values are correct, also checking definitions assertUserDrake(user, true, ctx); }
@Test public void test500ScriptingUsers() throws Exception { final String TEST_NAME = "test500ScriptingUsers"; TestUtil.displayTestTile(this, TEST_NAME); // GIVEN OperationResult result = new OperationResult(DOT_CLASS + TEST_NAME); PrismProperty<ScriptingExpressionType> expression = parseAnyData(SCRIPTING_USERS_FILE); // WHEN ExecutionContext output = scriptingExpressionEvaluator.evaluateExpression( expression.getAnyValue().getValue(), result); // THEN TestUtil.assertSuccess(result); Data data = output.getFinalOutput(); assertEquals("Unexpected # of items in output", 5, data.getData().size()); Set<String> realOids = new HashSet<>(); for (PrismValue value : data.getData()) { PrismObject<UserType> user = ((PrismObjectValue<UserType>) value).asPrismObject(); assertEquals("Description not set", "Test", user.asObjectable().getDescription()); realOids.add(user.getOid()); } assertEquals( "Unexpected OIDs in output", Sets.newHashSet( Arrays.asList( USER_ADMINISTRATOR_OID, USER_JACK_OID, USER_BARBOSSA_OID, USER_GUYBRUSH_OID, USER_ELAINE_OID)), realOids); IntegrationTestTools.display("stdout", output.getConsoleOutput()); IntegrationTestTools.display(result); result.computeStatus(); }
@Test public void testClone() throws Exception { final String TEST_NAME = "testClone"; PrismInternalTestUtil.displayTestTitle(TEST_NAME); // GIVEN PrismContext ctx = constructInitializedPrismContext(); PrismObjectDefinition<UserType> userDefinition = getFooSchema(ctx).findObjectDefinitionByElementName(new QName(NS_FOO, "user")); PrismObject<UserType> user = userDefinition.instantiate(); fillInUserDrake(user, true); // precondition assertUserDrake(user, true, ctx); // WHEN PrismObject<UserType> clone = user.clone(); // THEN System.out.println("Cloned user:"); System.out.println(clone.debugDump()); // Check if the values are correct, also checking definitions assertUserDrake(clone, true, ctx); }
@Override public CompositeRefinedObjectClassDefinition determineCompositeObjectClassDefinition( PrismObject<ShadowType> shadow, Collection<QName> additionalAuxiliaryObjectClassQNames) throws SchemaException { ShadowType shadowType = shadow.asObjectable(); RefinedObjectClassDefinition structuralObjectClassDefinition = null; ShadowKindType kind = shadowType.getKind(); String intent = shadowType.getIntent(); QName structuralObjectClassQName = shadowType.getObjectClass(); if (kind != null) { structuralObjectClassDefinition = getRefinedDefinition(kind, intent); } if (structuralObjectClassDefinition == null) { // Fallback to objectclass only if (structuralObjectClassQName == null) { return null; } structuralObjectClassDefinition = getRefinedDefinition(structuralObjectClassQName); } if (structuralObjectClassDefinition == null) { return null; } List<QName> auxiliaryObjectClassQNames = shadowType.getAuxiliaryObjectClass(); if (additionalAuxiliaryObjectClassQNames != null) { auxiliaryObjectClassQNames.addAll(additionalAuxiliaryObjectClassQNames); } Collection<RefinedObjectClassDefinition> auxiliaryObjectClassDefinitions = new ArrayList<>(auxiliaryObjectClassQNames.size()); for (QName auxiliaryObjectClassQName : auxiliaryObjectClassQNames) { RefinedObjectClassDefinition auxiliaryObjectClassDef = getRefinedDefinition(auxiliaryObjectClassQName); if (auxiliaryObjectClassDef == null) { throw new SchemaException( "Auxiliary object class " + auxiliaryObjectClassQName + " specified in " + shadow + " does not exist"); } auxiliaryObjectClassDefinitions.add(auxiliaryObjectClassDef); } return new CompositeRefinedObjectClassDefinitionImpl( structuralObjectClassDefinition, auxiliaryObjectClassDefinitions); }
public static RefinedResourceSchema parse( PrismObject<ResourceType> resource, PrismContext prismContext) throws SchemaException { return parse(resource.asObjectable(), prismContext); }
private List<ItemWrapper> createProperties(PageBase pageBase) { result = new OperationResult(CREATE_PROPERTIES); List<ItemWrapper> properties = new ArrayList<ItemWrapper>(); PrismContainerDefinition definition = null; PrismObject parent = getObject().getObject(); Class clazz = parent.getCompileTimeClass(); if (ShadowType.class.isAssignableFrom(clazz)) { QName name = containerDefinition.getName(); if (ShadowType.F_ATTRIBUTES.equals(name)) { try { definition = objectWrapper.getRefinedAttributeDefinition(); if (definition == null) { PrismReference resourceRef = parent.findReference(ShadowType.F_RESOURCE_REF); PrismObject<ResourceType> resource = resourceRef.getValue().getObject(); definition = pageBase .getModelInteractionService() .getEditObjectClassDefinition( (PrismObject<ShadowType>) objectWrapper.getObject(), resource, AuthorizationPhaseType.REQUEST) .toResourceAttributeContainerDefinition(); if (LOGGER.isTraceEnabled()) { LOGGER.trace("Refined account def:\n{}", definition.debugDump()); } } } catch (Exception ex) { LoggingUtils.logException( LOGGER, "Couldn't load definitions from refined schema for shadow", ex); result.recordFatalError( "Couldn't load definitions from refined schema for shadow, reason: " + ex.getMessage(), ex); return properties; } } else { definition = containerDefinition; } } else if (ResourceType.class.isAssignableFrom(clazz)) { if (containerDefinition != null) { definition = containerDefinition; } else { definition = container.getDefinition(); } } else { definition = containerDefinition; } if (definition == null) { LOGGER.error( "Couldn't get property list from null definition {}", new Object[] {container.getElementName()}); return properties; } // assignments are treated in a special way -- we display names of // org.units and roles // (but only if ObjectWrapper.isShowAssignments() is true; otherwise // they are filtered out by ObjectWrapper) if (container.getCompileTimeClass() != null && AssignmentType.class.isAssignableFrom(container.getCompileTimeClass())) { for (Object o : container.getValues()) { PrismContainerValue<AssignmentType> pcv = (PrismContainerValue<AssignmentType>) o; AssignmentType assignmentType = pcv.asContainerable(); if (assignmentType.getTargetRef() == null) { continue; } // hack... we want to create a definition for Name // PrismPropertyDefinition def = ((PrismContainerValue) // pcv.getContainer().getParent()).getContainer().findProperty(ObjectType.F_NAME).getDefinition(); PrismPropertyDefinition def = new PrismPropertyDefinition( ObjectType.F_NAME, DOMUtil.XSD_STRING, pcv.getPrismContext()); if (OrgType.COMPLEX_TYPE.equals(assignmentType.getTargetRef().getType())) { def.setDisplayName("Org.Unit"); def.setDisplayOrder(100); } else if (RoleType.COMPLEX_TYPE.equals(assignmentType.getTargetRef().getType())) { def.setDisplayName("Role"); def.setDisplayOrder(200); } else { continue; } PrismProperty<Object> temp = def.instantiate(); String value = formatAssignmentBrief(assignmentType); temp.setValue(new PrismPropertyValue<Object>(value)); // TODO: do this.isReadOnly() - is that OK? (originally it was the default behavior for all // cases) properties.add(new PropertyWrapper(this, temp, this.isReadonly(), ValueStatus.NOT_CHANGED)); } } else if (isShadowAssociation()) { PrismContext prismContext = objectWrapper.getObject().getPrismContext(); Map<QName, PrismContainer<ShadowAssociationType>> assocMap = new HashMap<>(); if (objectWrapper.getAssociations() != null) { for (PrismContainerValue<ShadowAssociationType> cval : objectWrapper.getAssociations()) { ShadowAssociationType associationType = cval.asContainerable(); QName assocName = associationType.getName(); PrismContainer<ShadowAssociationType> fractionalContainer = assocMap.get(assocName); if (fractionalContainer == null) { fractionalContainer = new PrismContainer<>( ShadowType.F_ASSOCIATION, ShadowAssociationType.class, cval.getPrismContext()); fractionalContainer.setDefinition(cval.getParent().getDefinition()); // HACK: set the name of the association as the element name so wrapper.getName() will // return correct data. fractionalContainer.setElementName(assocName); assocMap.put(assocName, fractionalContainer); } try { fractionalContainer.add(cval.clone()); } catch (SchemaException e) { // Should not happen throw new SystemException("Unexpected error: " + e.getMessage(), e); } } } PrismReference resourceRef = parent.findReference(ShadowType.F_RESOURCE_REF); PrismObject<ResourceType> resource = resourceRef.getValue().getObject(); // HACK. The revive should not be here. Revive is no good. The next use of the resource will // cause parsing of resource schema. We need some centralized place to maintain live cached // copies // of resources. try { resource.revive(prismContext); } catch (SchemaException e) { throw new SystemException(e.getMessage(), e); } RefinedResourceSchema refinedSchema; CompositeRefinedObjectClassDefinition rOcDef; try { refinedSchema = RefinedResourceSchema.getRefinedSchema(resource); rOcDef = refinedSchema.determineCompositeObjectClassDefinition(parent); } catch (SchemaException e) { throw new SystemException(e.getMessage(), e); } // Make sure even empty associations have their wrappers so they can be displayed and edited for (RefinedAssociationDefinition assocDef : rOcDef.getAssociations()) { QName name = assocDef.getName(); if (!assocMap.containsKey(name)) { PrismContainer<ShadowAssociationType> fractionalContainer = new PrismContainer<>( ShadowType.F_ASSOCIATION, ShadowAssociationType.class, prismContext); fractionalContainer.setDefinition(getItemDefinition()); // HACK: set the name of the association as the element name so wrapper.getName() will // return correct data. fractionalContainer.setElementName(name); assocMap.put(name, fractionalContainer); } } for (Entry<QName, PrismContainer<ShadowAssociationType>> assocEntry : assocMap.entrySet()) { // HACK HACK HACK, the container wrapper should not parse itself. This code should not be // here. AssociationWrapper assocWrapper = new AssociationWrapper( this, assocEntry.getValue(), this.isReadonly(), ValueStatus.NOT_CHANGED); properties.add(assocWrapper); } } else { // if not an assignment if ((container.getValues().size() == 1 || container.getValues().isEmpty()) && (containerDefinition == null || containerDefinition.isSingleValue())) { // there's no point in showing properties for non-single-valued // parent containers, // so we continue only if the parent is single-valued Collection<ItemDefinition> propertyDefinitions = definition.getDefinitions(); for (ItemDefinition itemDef : propertyDefinitions) { if (itemDef instanceof PrismPropertyDefinition) { PrismPropertyDefinition def = (PrismPropertyDefinition) itemDef; if (def.isIgnored() || skipProperty(def)) { continue; } if (!showInheritedObjectAttributes && INHERITED_OBJECT_ATTRIBUTES.contains(def.getName())) { continue; } // capability handling for activation properties if (isShadowActivation() && !hasCapability(def)) { continue; } if (isShadowAssociation()) { continue; } PrismProperty property = container.findProperty(def.getName()); boolean propertyIsReadOnly; // decision is based on parent object status, not this // container's one (because container can be added also // to an existing object) if (objectWrapper.getStatus() == ContainerStatus.MODIFYING) { propertyIsReadOnly = !def.canModify(); } else { propertyIsReadOnly = !def.canAdd(); } if (property == null) { properties.add( new PropertyWrapper( this, def.instantiate(), propertyIsReadOnly, ValueStatus.ADDED)); } else { properties.add( new PropertyWrapper(this, property, propertyIsReadOnly, ValueStatus.NOT_CHANGED)); } } else if (itemDef instanceof PrismReferenceDefinition) { PrismReferenceDefinition def = (PrismReferenceDefinition) itemDef; if (INHERITED_OBJECT_ATTRIBUTES.contains(def.getName())) { continue; } PrismReference reference = container.findReference(def.getName()); boolean propertyIsReadOnly; // decision is based on parent object status, not this // container's one (because container can be added also // to an existing object) if (objectWrapper.getStatus() == ContainerStatus.MODIFYING) { propertyIsReadOnly = !def.canModify(); } else { propertyIsReadOnly = !def.canAdd(); } if (reference == null) { properties.add( new ReferenceWrapper( this, def.instantiate(), propertyIsReadOnly, ValueStatus.ADDED)); } else { properties.add( new ReferenceWrapper( this, reference, propertyIsReadOnly, ValueStatus.NOT_CHANGED)); } } } } } Collections.sort(properties, new ItemWrapperComparator()); result.recomputeStatus(); return properties; }
public static RefinedResourceSchema getRefinedSchema(PrismObject<ResourceType> resource) throws SchemaException { return getRefinedSchema(resource, resource.getPrismContext()); }
public static boolean hasRefinedSchema(ResourceType resourceType) { PrismObject<ResourceType> resource = resourceType.asPrismObject(); return resource.getUserData(USER_DATA_KEY_REFINED_SCHEMA) != null; }
public static boolean hasParsedSchema(ResourceType resourceType) { PrismObject<ResourceType> resource = resourceType.asPrismObject(); return resource.getUserData(USER_DATA_KEY_PARSED_RESOURCE_SCHEMA) != null; }
private void assertUserDrakeContent(PrismObject<UserType> user, boolean assertDefinitions) { // fullName PrismProperty fullNameProperty = user.findProperty(USER_FULLNAME_QNAME); if (assertDefinitions) PrismAsserts.assertDefinition(fullNameProperty, DOMUtil.XSD_STRING, 1, 1); assertEquals("Wrong fullname", "Sir Fancis Drake", fullNameProperty.getValue().getValue()); // activation PrismContainer activationContainer = user.findContainer(USER_ACTIVATION_QNAME); assertEquals(USER_ACTIVATION_QNAME, activationContainer.getElementName()); if (assertDefinitions) PrismAsserts.assertDefinition(activationContainer, ACTIVATION_TYPE_QNAME, 0, 1); // activation/enabled PrismProperty enabledProperty = user.findProperty(USER_ENABLED_PATH); assertEquals(USER_ENABLED_QNAME, enabledProperty.getElementName()); if (assertDefinitions) PrismAsserts.assertDefinition(enabledProperty, DOMUtil.XSD_BOOLEAN, 0, 1); assertEquals("Wrong enabled", true, enabledProperty.getValue().getValue()); // assignment PrismContainer assignmentContainer = user.findContainer(USER_ASSIGNMENT_QNAME); assertEquals(USER_ASSIGNMENT_QNAME, assignmentContainer.getElementName()); if (assertDefinitions) PrismAsserts.assertDefinition(assignmentContainer, ASSIGNMENT_TYPE_QNAME, 0, -1); // assignment values List<PrismContainerValue> assValues = assignmentContainer.getValues(); assertEquals("Wrong number of assignment values", 3, assValues.size()); // assignment values: blue PrismContainerValue assBlueValue = assValues.get(0); PrismProperty assBlueDescriptionProperty = assBlueValue.findProperty(USER_DESCRIPTION_QNAME); if (assertDefinitions) PrismAsserts.assertDefinition(assBlueDescriptionProperty, DOMUtil.XSD_STRING, 0, 1); assertEquals( "Wrong blue assignment description", "Assignment created out of the blue", assBlueDescriptionProperty.getValue().getValue()); // assignment values: cyan PrismContainerValue assCyanValue = assValues.get(1); PrismProperty assCyanDescriptionProperty = assCyanValue.findProperty(USER_DESCRIPTION_QNAME); if (assertDefinitions) PrismAsserts.assertDefinition(assCyanDescriptionProperty, DOMUtil.XSD_STRING, 0, 1); assertEquals( "Wrong cyan assignment description", "Assignment created out of the cyan", assCyanDescriptionProperty.getValue().getValue()); // assignment values: red PrismContainerValue assRedValue = assValues.get(2); PrismProperty assRedDescriptionProperty = assRedValue.findProperty(USER_DESCRIPTION_QNAME); if (assertDefinitions) PrismAsserts.assertDefinition(assRedDescriptionProperty, DOMUtil.XSD_STRING, 0, 1); assertEquals( "Wrong red assignment description", "Assignment created out of the red", assRedDescriptionProperty.getValue().getValue()); // accountRef PrismReference accountRef = user.findReference(USER_ACCOUNTREF_QNAME); if (assertDefinitions) PrismAsserts.assertDefinition(accountRef, OBJECT_REFERENCE_TYPE_QNAME, 0, -1); PrismAsserts.assertReferenceValue(accountRef, ACCOUNT1_OID); PrismAsserts.assertReferenceValue(accountRef, ACCOUNT2_OID); assertEquals("accountRef size", 2, accountRef.getValues().size()); PrismAsserts.assertParentConsistency(user); }
// normally this method returns an InputPanel; // however, for some special readonly types (like ObjectDeltaType) it will return a Panel private Panel createTypedInputComponent(String id) { // ValueWrapper valueWrapper = model.getObject(); // ItemWrapper itemWrapper = final Item item = valueWrapperModel.getObject().getItem().getItem(); Panel panel = null; if (item instanceof PrismProperty) { final PrismProperty property = (PrismProperty) item; PrismPropertyDefinition definition = property.getDefinition(); final QName valueType = definition.getTypeName(); final String baseExpression = "value.value"; // pointing to prism property real value // fixing MID-1230, will be improved with some kind of annotation or something like that // now it works only in description if (ObjectType.F_DESCRIPTION.equals(definition.getName())) { return new TextAreaPanel(id, new PropertyModel(valueWrapperModel, baseExpression), null); } if (ActivationType.F_ADMINISTRATIVE_STATUS.equals(definition.getName())) { return WebComponentUtil.createEnumPanel( ActivationStatusType.class, id, new PropertyModel<ActivationStatusType>(valueWrapperModel, baseExpression), this); } else if (ActivationType.F_LOCKOUT_STATUS.equals(definition.getName())) { return new LockoutStatusPanel( id, new PropertyModel<LockoutStatusType>(valueWrapperModel, baseExpression)); } else { // nothing to do } if (DOMUtil.XSD_DATETIME.equals(valueType)) { panel = new DatePanel( id, new PropertyModel<XMLGregorianCalendar>(valueWrapperModel, baseExpression)); } else if (ProtectedStringType.COMPLEX_TYPE.equals(valueType)) { boolean showRemovePasswordButton = true; if (pageBase instanceof PageUser && ((PageUser) pageBase).getObjectWrapper().getObject() != null && ((PageUser) pageBase).getObjectWrapper().getObject().getOid() != null && ((PageUser) pageBase) .getObjectWrapper() .getObject() .getOid() .equals(SecurityUtils.getPrincipalUser().getOid())) { showRemovePasswordButton = false; } panel = new PasswordPanel( id, new PropertyModel<ProtectedStringType>(valueWrapperModel, baseExpression), valueWrapperModel.getObject().isReadonly(), showRemovePasswordButton); } else if (DOMUtil.XSD_BOOLEAN.equals(valueType)) { panel = new TriStateComboPanel( id, new PropertyModel<Boolean>(valueWrapperModel, baseExpression)); } else if (SchemaConstants.T_POLY_STRING_TYPE.equals(valueType)) { InputPanel inputPanel; PrismPropertyDefinition def = property.getDefinition(); if (def.getValueEnumerationRef() != null) { PrismReferenceValue valueEnumerationRef = def.getValueEnumerationRef(); String lookupTableUid = valueEnumerationRef.getOid(); Task task = pageBase.createSimpleTask("loadLookupTable"); OperationResult result = task.getResult(); Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection( LookupTableType.F_ROW, GetOperationOptions.createRetrieve(RetrieveOption.INCLUDE)); final PrismObject<LookupTableType> lookupTable = WebModelServiceUtils.loadObject( LookupTableType.class, lookupTableUid, options, pageBase, task, result); if (lookupTable != null) { inputPanel = new AutoCompleteTextPanel<String>( id, new LookupPropertyModel<String>( valueWrapperModel, baseExpression + ".orig", lookupTable.asObjectable()), String.class) { @Override public Iterator<String> getIterator(String input) { return prepareAutoCompleteList(input, lookupTable).iterator(); } }; } else { inputPanel = new TextPanel<>( id, new PropertyModel<String>(valueWrapperModel, baseExpression + ".orig"), String.class); } } else { inputPanel = new TextPanel<>( id, new PropertyModel<String>(valueWrapperModel, baseExpression + ".orig"), String.class); } if (ObjectType.F_NAME.equals(def.getName()) || UserType.F_FULL_NAME.equals(def.getName())) { inputPanel.getBaseFormComponent().setRequired(true); } panel = inputPanel; } else if (DOMUtil.XSD_BASE64BINARY.equals(valueType)) { panel = new UploadDownloadPanel(id, valueWrapperModel.getObject().isReadonly()) { @Override public InputStream getStream() { Object object = ((PrismPropertyValue) valueWrapperModel.getObject().getValue()).getValue(); return object != null ? new ByteArrayInputStream((byte[]) object) : new ByteArrayInputStream(new byte[0]); // return super.getStream(); } @Override public void updateValue(byte[] file) { ((PrismPropertyValue) valueWrapperModel.getObject().getValue()).setValue(file); } @Override public void uploadFilePerformed(AjaxRequestTarget target) { super.uploadFilePerformed(target); target.add(PrismValuePanel.this.get(ID_FEEDBACK)); } @Override public void removeFilePerformed(AjaxRequestTarget target) { super.removeFilePerformed(target); target.add(PrismValuePanel.this.get(ID_FEEDBACK)); } @Override public void uploadFileFailed(AjaxRequestTarget target) { super.uploadFileFailed(target); target.add(PrismValuePanel.this.get(ID_FEEDBACK)); target.add(((PageBase) getPage()).getFeedbackPanel()); } }; } else if (ObjectDeltaType.COMPLEX_TYPE.equals(valueType)) { panel = new ModificationsPanel( id, new AbstractReadOnlyModel<DeltaDto>() { @Override public DeltaDto getObject() { if (valueWrapperModel.getObject() == null || valueWrapperModel.getObject().getValue() == null || ((PrismPropertyValue) valueWrapperModel.getObject().getValue()) .getValue() == null) { return null; } PrismContext prismContext = ((PageBase) getPage()).getPrismContext(); ObjectDeltaType objectDeltaType = (ObjectDeltaType) ((PrismPropertyValue) valueWrapperModel.getObject().getValue()) .getValue(); try { ObjectDelta delta = DeltaConvertor.createObjectDelta(objectDeltaType, prismContext); return new DeltaDto(delta); } catch (SchemaException e) { throw new IllegalStateException( "Couldn't convert object delta: " + objectDeltaType); } } }); } else if (QueryType.COMPLEX_TYPE.equals(valueType) || CleanupPoliciesType.COMPLEX_TYPE.equals(valueType)) { return new TextAreaPanel( id, new AbstractReadOnlyModel() { @Override public Object getObject() { if (valueWrapperModel.getObject() == null || valueWrapperModel.getObject().getValue() == null) { return null; } PrismPropertyValue ppv = (PrismPropertyValue) valueWrapperModel.getObject().getValue(); if (ppv == null || ppv.getValue() == null) { return null; } QName name = property.getElementName(); if (name == null && property.getDefinition() != null) { name = property.getDefinition().getName(); } if (name == null) { name = SchemaConstants.C_VALUE; } PrismContext prismContext = ((PageBase) getPage()).getPrismContext(); try { return prismContext.serializeAnyData(ppv.getValue(), name, PrismContext.LANG_XML); } catch (SchemaException e) { throw new SystemException( "Couldn't serialize property value of type: " + valueType + ": " + e.getMessage(), e); } } }, 10); } else { Class type = XsdTypeMapper.getXsdToJavaMapping(valueType); if (type != null && type.isPrimitive()) { type = ClassUtils.primitiveToWrapper(type); } if (isEnum(property)) { return WebComponentUtil.createEnumPanel( definition, id, new PropertyModel<>(valueWrapperModel, baseExpression), this); } // // default QName validation is a bit weird, so let's treat QNames as // strings [TODO finish this - at the parsing side] // if (type == QName.class) { // type = String.class; // } PrismPropertyDefinition def = property.getDefinition(); if (def.getValueEnumerationRef() != null) { PrismReferenceValue valueEnumerationRef = def.getValueEnumerationRef(); String lookupTableUid = valueEnumerationRef.getOid(); Task task = pageBase.createSimpleTask("loadLookupTable"); OperationResult result = task.getResult(); Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection( LookupTableType.F_ROW, GetOperationOptions.createRetrieve(RetrieveOption.INCLUDE)); final PrismObject<LookupTableType> lookupTable = WebModelServiceUtils.loadObject( LookupTableType.class, lookupTableUid, options, pageBase, task, result); if (lookupTable != null) { panel = new AutoCompleteTextPanel<String>( id, new LookupPropertyModel<String>( valueWrapperModel, baseExpression, lookupTable == null ? null : lookupTable.asObjectable()), type) { @Override public Iterator<String> getIterator(String input) { return prepareAutoCompleteList(input, lookupTable).iterator(); } @Override public void checkInputValue( AutoCompleteTextField input, AjaxRequestTarget target, LookupPropertyModel model) { Iterator<String> lookupTableValuesIterator = prepareAutoCompleteList("", lookupTable).iterator(); String value = input.getInput(); boolean isValueExist = false; if (value != null) { if (value.trim().equals("")) { isValueExist = true; } else { while (lookupTableValuesIterator.hasNext()) { String lookupTableValue = lookupTableValuesIterator.next(); if (value.trim().equals(lookupTableValue)) { isValueExist = true; break; } } } } if (isValueExist) { input.setModelValue(new String[] {value}); target.add(PrismValuePanel.this.get(ID_FEEDBACK)); } else { input.error( "Entered value doesn't match any of available values and will not be saved."); target.add(PrismValuePanel.this.get(ID_FEEDBACK)); } } }; } else { panel = new TextPanel<>( id, new PropertyModel<String>(valueWrapperModel, baseExpression), type); } } else { panel = new TextPanel<>( id, new PropertyModel<String>(valueWrapperModel, baseExpression), type); } } } else if (item instanceof PrismReference) { PrismContext prismContext = item.getPrismContext(); if (prismContext == null) { prismContext = pageBase.getPrismContext(); } QName targetTypeName = ((PrismReferenceDefinition) item.getDefinition()).getTargetTypeName(); Class targetClass = null; if (targetTypeName != null && prismContext != null) { targetClass = prismContext.getSchemaRegistry().determineCompileTimeClass(targetTypeName); } final Class typeClass = targetClass != null ? targetClass : (item.getDefinition().getTypeClassIfKnown() != null ? item.getDefinition().getTypeClassIfKnown() : FocusType.class); Collection typeClasses = new ArrayList(); // HACK HACK MID-3201 MID-3231 if (isUserOrgItem(item, typeClass)) { typeClasses.add(UserType.class); typeClasses.add(OrgType.class); } else { typeClasses.add(typeClass); } panel = new ValueChoosePanel( id, new PropertyModel<>(valueWrapperModel, "value"), item.getValues(), false, typeClasses); } else if (item instanceof PrismContainer<?>) { AssociationWrapper itemWrapper = (AssociationWrapper) valueWrapperModel.getObject().getItem(); final PrismContainer container = (PrismContainer) item; PrismContainerDefinition definition = container.getDefinition(); QName valueType = definition.getTypeName(); if (ShadowAssociationType.COMPLEX_TYPE.equals(valueType)) { PrismContext prismContext = item.getPrismContext(); if (prismContext == null) { prismContext = pageBase.getPrismContext(); } ShadowType shadowType = ((ShadowType) itemWrapper.getContainer().getObject().getObject().asObjectable()); PrismObject<ResourceType> resource = shadowType.getResource().asPrismObject(); // HACK. The revive should not be here. Revive is no good. The next use of the resource will // cause parsing of resource schema. We need some centralized place to maintain live cached // copies // of resources. try { resource.revive(prismContext); } catch (SchemaException e) { throw new SystemException(e.getMessage(), e); } RefinedResourceSchema refinedSchema; CompositeRefinedObjectClassDefinition rOcDef; try { refinedSchema = RefinedResourceSchema.getRefinedSchema(resource); rOcDef = refinedSchema.determineCompositeObjectClassDefinition(shadowType.asPrismObject()); } catch (SchemaException e) { throw new SystemException(e.getMessage(), e); } RefinedAssociationDefinition assocDef = itemWrapper.getRefinedAssociationDefinition(); RefinedObjectClassDefinition assocTargetDef = assocDef.getAssociationTarget(); ObjectQuery query = getAssociationsSearchQuery( prismContext, resource, assocTargetDef.getTypeName(), assocTargetDef.getKind(), assocTargetDef.getIntent()); List values = item.getValues(); return new AssociationValueChoicePanel( id, valueWrapperModel, values, false, ShadowType.class, query, assocTargetDef); } } return panel; }
private void fillInUserDrake(PrismObject<UserType> user, boolean assertDefinitions) throws SchemaException { user.setOid(USER_OID); // fullName PrismProperty<String> fullNameProperty = user.findOrCreateProperty(USER_FULLNAME_QNAME); assertEquals(USER_FULLNAME_QNAME, fullNameProperty.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(fullNameProperty, DOMUtil.XSD_STRING, 1, 1); fullNameProperty.setValue(new PrismPropertyValue<String>("Sir Fancis Drake")); PrismProperty<String> fullNamePropertyAgain = user.findOrCreateProperty(USER_FULLNAME_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Property not the same", fullNameProperty == fullNamePropertyAgain); // activation PrismContainer<ActivationType> activationContainer = user.findOrCreateContainer(USER_ACTIVATION_QNAME); assertEquals(USER_ACTIVATION_QNAME, activationContainer.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(activationContainer, ACTIVATION_TYPE_QNAME, 0, 1); PrismContainer<ActivationType> activationContainerAgain = user.findOrCreateContainer(USER_ACTIVATION_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Property not the same", activationContainer == activationContainerAgain); // activation/enabled PrismProperty<Boolean> enabledProperty = user.findOrCreateProperty(USER_ENABLED_PATH); assertEquals(USER_ENABLED_QNAME, enabledProperty.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(enabledProperty, DOMUtil.XSD_BOOLEAN, 0, 1); enabledProperty.setValue(new PrismPropertyValue<Boolean>(true)); PrismProperty<Boolean> enabledPropertyAgain = activationContainer.findOrCreateProperty(USER_ENABLED_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Property not the same", enabledProperty == enabledPropertyAgain); // assignment // Try to create this one from the value. It should work the same, but let's test a different // code path PrismContainer<AssignmentType> assignmentContainer = user.getValue().findOrCreateContainer(USER_ASSIGNMENT_QNAME); assertEquals(USER_ASSIGNMENT_QNAME, assignmentContainer.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(assignmentContainer, ASSIGNMENT_TYPE_QNAME, 0, -1); PrismContainer<AssignmentType> assignmentContainerAgain = user.findOrCreateContainer(USER_ASSIGNMENT_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Property not the same", assignmentContainer == assignmentContainerAgain); assertEquals( "Wrong number of assignment values (empty)", 0, assignmentContainer.getValues().size()); // assignment values: construct assignment value as a new container "out of the blue" and then // add it. PrismContainer<AssignmentType> assBlueContainer = new PrismContainer<AssignmentType>(USER_ASSIGNMENT_QNAME); PrismProperty<String> assBlueDescriptionProperty = assBlueContainer.findOrCreateProperty(USER_DESCRIPTION_QNAME); assBlueDescriptionProperty.addValue( new PrismPropertyValue<String>("Assignment created out of the blue")); PrismAsserts.assertParentConsistency(user); assignmentContainer.mergeValues(assBlueContainer); assertEquals( "Wrong number of assignment values (after blue)", 1, assignmentContainer.getValues().size()); PrismAsserts.assertParentConsistency(user); // assignment values: construct assignment value as a new container value "out of the blue" and // then add it. PrismContainerValue<AssignmentType> assCyanContainerValue = new PrismContainerValue<AssignmentType>(); PrismProperty<String> assCyanDescriptionProperty = assCyanContainerValue.findOrCreateProperty(USER_DESCRIPTION_QNAME); assCyanDescriptionProperty.addValue( new PrismPropertyValue<String>("Assignment created out of the cyan")); assignmentContainer.mergeValue(assCyanContainerValue); assertEquals( "Wrong number of assignment values (after cyan)", 2, assignmentContainer.getValues().size()); PrismAsserts.assertParentConsistency(user); // assignment values: construct assignment value from existing container PrismContainerValue<AssignmentType> assRedContainerValue = assignmentContainer.createNewValue(); PrismProperty<String> assRedDescriptionProperty = assRedContainerValue.findOrCreateProperty(USER_DESCRIPTION_QNAME); assRedDescriptionProperty.addValue( new PrismPropertyValue<String>("Assignment created out of the red")); assertEquals( "Wrong number of assignment values (after red)", 3, assignmentContainer.getValues().size()); PrismAsserts.assertParentConsistency(user); // accountRef PrismReference accountRef = user.findOrCreateReference(USER_ACCOUNTREF_QNAME); assertEquals(USER_ACCOUNTREF_QNAME, accountRef.getElementName()); if (assertDefinitions) PrismAsserts.assertDefinition(accountRef, OBJECT_REFERENCE_TYPE_QNAME, 0, -1); accountRef.add(new PrismReferenceValue(ACCOUNT1_OID)); accountRef.add(new PrismReferenceValue(ACCOUNT2_OID)); PrismReference accountRefAgain = user.findOrCreateReference(USER_ACCOUNTREF_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Property not the same", accountRef == accountRefAgain); assertEquals("accountRef size", 2, accountRef.getValues().size()); PrismAsserts.assertParentConsistency(user); // extension PrismContainer<?> extensionContainer = user.findOrCreateContainer(USER_EXTENSION_QNAME); assertEquals(USER_EXTENSION_QNAME, extensionContainer.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(extensionContainer, DOMUtil.XSD_ANY, 0, 1); PrismContainer<AssignmentType> extensionContainerAgain = user.findOrCreateContainer(USER_EXTENSION_QNAME); // The "==" is there by purpose. We really want to make sure that is the same *instance*, that // is was not created again assertTrue("Extension not the same", extensionContainer == extensionContainerAgain); assertEquals( "Wrong number of extension values (empty)", 0, extensionContainer.getValues().size()); // extension / stringType PrismProperty<String> stringTypeProperty = extensionContainer.findOrCreateProperty(EXTENSION_STRING_TYPE_ELEMENT); assertEquals(EXTENSION_STRING_TYPE_ELEMENT, stringTypeProperty.getElementName()); PrismAsserts.assertParentConsistency(user); if (assertDefinitions) PrismAsserts.assertDefinition(stringTypeProperty, DOMUtil.XSD_STRING, 0, -1); // TODO }