private static void addRealValue(Item<PrismValue, ItemDefinition> extensionItem, Object value, PrismContext prismContext) throws SchemaException { if (value != null) { extensionItem.add(prismContext.itemFactory().createValue(value).clone()); } }
private <X> PrismProperty<X> resolveStructuredPropertyItem(PrismProperty<Structured> sourceProperty, ItemPath resolvePath, PrismPropertyDefinition outputDefinition) { if (sourceProperty == null) { return null; } PrismProperty<X> outputProperty = outputDefinition.instantiate(); for (Structured sourceRealValue: sourceProperty.getRealValues()) { X outputRealValue = (X) sourceRealValue.resolve(resolvePath); outputProperty.addRealValue(outputRealValue); } return outputProperty; }
@SuppressWarnings("unchecked") public static PrismObject<ConnectorType> getConnectorIfPresent(PrismObject<ResourceType> resource) { PrismReference existingConnectorRef = resource.findReference(ResourceType.F_CONNECTOR_REF); if (existingConnectorRef == null || existingConnectorRef.isEmpty()) { return null; } return (PrismObject<ConnectorType>) existingConnectorRef.getValue().getObject(); }
private boolean isEquivalentAddDelta(PrismObject<ShadowType> object1, PrismObject<ShadowType> object2) { PrismContainer attributes1 = object1.findContainer(ShadowType.F_ATTRIBUTES); PrismContainer attributes2 = object2.findContainer(ShadowType.F_ATTRIBUTES); if (attributes1 == null || attributes2 == null || attributes1.size() != 1 || attributes2.size() != 1) { // suspicious cases return false; } return attributes1.getValue().equivalent(attributes2.getValue()); }
protected PrismObject<UserType> createUserFoo() throws SchemaException { PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismObject<UserType> user = userDef.instantiate(); user.setOid(USER_FOO_OID); user.setPropertyRealValue(UserType.F_NAME, createPolyString("foo")); PrismProperty<PolyString> anamesProp = user.findOrCreateProperty(UserType.F_ADDITIONAL_NAMES); anamesProp.addRealValue(createPolyString("foobar")); return user; }
@Override public PrismObject<UserType> getOwner() { PrismReference ownerRef = taskPrism.findReference(TaskType.F_OWNER_REF); if (ownerRef == null) { return null; } return ownerRef.getValue().getObject(); }
private <C extends Containerable, O extends ObjectType> Collection<PrismContainerValue<C>> determineContainerValuesFromCurrentObject( ItemPath path, PrismObject<O> currentObject) { PrismContainer<C> container = currentObject.findContainer(path); if (container == null) { return null; } return container.getValues(); }
@Override public String getObjectOid() { PrismReference objectRef = taskPrism.findReference(TaskType.F_OBJECT_REF); if (objectRef == null) { return null; } return objectRef.getValue().getOid(); }
private PrismObject findObjectFromAccountRef(PrismObject<UserType> user) { for (PrismReferenceValue rval: user.findReference(UserType.F_ACCOUNT_REF).getValues()) { if (rval.getObject() != null) { return rval.getObject(); } } return null; }
protected PrismContainerValue<AssignmentType> createAssignmentValue(Long id, String description) throws SchemaException { PrismContainerDefinition<AssignmentType> assignmentDef = getUserTypeDefinition().findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainerValue<AssignmentType> assignmentValue = getPrismContext().itemFactory().createContainerValue(); populateAssignmentValue(assignmentValue, id, description); return assignmentValue; }
private <C extends Containerable> ItemDefinition getItemDefinition(PrismContainerValue<C> cval, Item<?, ?> item) { if (item.getDefinition() != null) { return item.getDefinition(); } ComplexTypeDefinition ctd = cval.getComplexTypeDefinition(); if (ctd == null) { return null; } return ctd.findLocalItemDefinition(item.getElementName()); }
public static String toObjectTreeDeltasTypeXml(ObjectTreeDeltasType objectTreeDeltasType, PrismContext prismContext) throws SchemaException { if (objectTreeDeltasType != null) { return prismContext.xmlSerializer().serializeRealValue(objectTreeDeltasType, SchemaConstantsGenerated.C_OBJECT_TREE_DELTAS); } else { return null; } }
private void assertUserWill(PrismObject<UserType> user) throws SchemaException { user.checkConsistence(); user.assertDefinitions("test"); assertUserWillExtension(user); assertVisitor(user,55); }
private <T extends ObjectType> void removeOperationalItems(PrismObject<T> object) { if (object != null) { object.getValue().removeOperationalItems(); } }
protected void assertUserAdhoc(PrismObject<UserType> user, boolean expectRawInConstructions) throws SchemaException { user.checkConsistence(); assertUserJackContent(user, expectRawInConstructions); assertUserExtensionAdhoc(user); assertVisitor(user, 58); }
protected void addAssignment(PrismObject<UserType> user, Long id, String description) throws SchemaException { PrismContainer<AssignmentType> assignment = user.findOrCreateContainer(UserType.F_ASSIGNMENT); PrismContainerValue<AssignmentType> assignmentValue = assignment.createNewValue(); populateAssignmentValue(assignmentValue, id, description); }
public static ItemPathType createItemPathType(String stringPath, PrismContext prismContext) { String pathDeclaration = "declare default namespace '" + NS_COMMON + "'; " + stringPath; ItemPathType itemPathType = prismContext.itemPathParser().asItemPathType(pathDeclaration); return itemPathType; }
default ComplexTypeDefinition getComplexTypeDefinition() { PrismContainerDefinition def = getDefinition(); return def != null ? def.getComplexTypeDefinition() : null; } }
public static PrismContext constructInitializedPrismContext(File extraSchema) throws SchemaException, SAXException, IOException { PrismContext context = constructPrismContext(extraSchema); context.initialize(); return context; }
public void revive(PrismContext prismContext) throws SchemaException { // it is necessary to do e.g. PolyString recomputation even if PrismContext is set if (this.prismContext == null) { this.prismContext = prismContext; if (definition != null) { definition.revive(prismContext); } } for (V value: values) { value.revive(prismContext); } }