public <I extends Item> void addExtensionItem(I item) throws SchemaException { PrismContainer<?> extension = getExtension(); if (extension == null) { extension = createExtension(); } extension.add(item); }
static <V extends PrismContainerValue> void createParentIfNeeded(V value, ItemDefinition definition) throws SchemaException { if (value.getParent() != null) { return; } if (!(definition instanceof PrismContainerDefinition)) { throw new SchemaException("Missing or invalid definition for a PrismContainer: " + definition); } PrismContainer<?> rv = (PrismContainer) definition.instantiate(); rv.add(value); }
/** * Returns a single-valued container (with a single-valued definition) holding just this value. * @param itemName Item name for newly-created container. * @return */ public PrismContainer<C> asSingleValuedContainer(@NotNull QName itemName) throws SchemaException { PrismContext prismContext = getPrismContext(); Validate.notNull(prismContext, "Prism context is null"); PrismContainerDefinitionImpl<C> definition = new PrismContainerDefinitionImpl<>(itemName, getComplexTypeDefinition(), prismContext); definition.setMaxOccurs(1); PrismContainer<C> pc = definition.instantiate(); pc.add(clone()); return pc; }
/** * Breaks user assignment delta in the context by inserting some empty value. This may interfere with comparing the values to * existing user values. */ protected <F extends FocusType> void breakAssignmentDelta(ObjectDelta<F> userDelta) throws SchemaException { ContainerDelta<?> assignmentDelta = userDelta.findContainerDelta(UserType.F_ASSIGNMENT); PrismContainerValue<?> assignmentDeltaValue = null; if (assignmentDelta.getValuesToAdd() != null) { assignmentDeltaValue = assignmentDelta.getValuesToAdd().iterator().next(); } if (assignmentDelta.getValuesToDelete() != null) { assignmentDeltaValue = assignmentDelta.getValuesToDelete().iterator().next(); } PrismContainer<ActivationType> activationContainer = assignmentDeltaValue.findOrCreateContainer(AssignmentType.F_ACTIVATION); PrismContainerValue<ActivationType> emptyValue = prismContext.itemFactory().createContainerValue(); activationContainer.add(emptyValue); }
public static void setAttribute(PrismObject<ShadowType> account, QName attrName, QName typeName, PrismContext prismContext, String value) throws SchemaException { PrismContainer<Containerable> attributesContainer = account.findContainer(ShadowType.F_ATTRIBUTES); ResourceAttributeDefinition attrDef = ObjectFactory.createResourceAttributeDefinition(attrName, typeName, prismContext); ResourceAttribute attribute = attrDef.instantiate(); attribute.setRealValue(value); attributesContainer.add(attribute); }
private <C extends Containerable> void parseContainerValueToContainer(PrismContainer<C> container, XNodeImpl node, @NotNull ParsingContext pc) throws SchemaException { container.add(parseContainerValue(node, container.getDefinition(), pc)); if (node instanceof MapXNodeImpl && container instanceof PrismObject) { MapXNodeImpl map = (MapXNodeImpl) node; PrismObject object = (PrismObject) container; object.setOid(getOid(map)); object.setVersion(getVersion(map)); } }
@Deprecated public static void copyDefinition(Containerable aClone, Containerable original, PrismContext prismContext) { try { Validate.notNull(original.asPrismContainerValue().getParent(), "original PrismContainerValue has no parent"); ComplexTypeDefinition definition = original.asPrismContainerValue().getComplexTypeDefinition(); Validate.notNull(definition, "original PrismContainer definition is null"); PrismContainer<?> aCloneParent = prismContext.getSchemaRegistry() .findContainerDefinitionByCompileTimeClass((Class<? extends Containerable>) definition.getCompileTimeClass()) .instantiate(); aCloneParent.add(aClone.asPrismContainerValue()); } catch (SchemaException e) { throw new SystemException("Unexpected SchemaException when copying definition from original object to its clone", e); } }
@Override public boolean add(T t) { PrismContainerValue value = getValueFrom(t); try { if (container.getParent() == null) { parent.add(container); } return container.add(value); } catch (SchemaException ex) { throw new SystemException(ex.getMessage(), ex); } }
@Deprecated static void copyDefinition(Containerable aClone, Containerable original, PrismContext prismContext) { try { Validate.notNull(original.asPrismContainerValue().getParent(), "original PrismContainerValue has no parent"); ComplexTypeDefinition definition = original.asPrismContainerValue().getComplexTypeDefinition(); Validate.notNull(definition, "original PrismContainer definition is null"); PrismContainer<?> aCloneParent = prismContext.getSchemaRegistry() .findContainerDefinitionByCompileTimeClass((Class<? extends Containerable>) definition.getCompileTimeClass()) .instantiate(); aCloneParent.add(aClone.asPrismContainerValue()); } catch (SchemaException e) { throw new SystemException("Unexpected SchemaException when copying definition from original object to its clone", e); } }
private <T extends Containerable> PrismContainer<T> unmarshalSingleValueContainer(JAXBElement<T> element) throws JAXBException, SchemaException { if (element == null) { return null; } T value = element.getValue(); // this is a bit tricky - we have to create a container and put the newly obtained value into it PrismContainerValue<T> containerValue = value.asPrismContainerValue(); containerValue.revive(prismContext); PrismContainerDefinition<T> definition = prismContext.getSchemaRegistry().findContainerDefinitionByElementName(element.getName()); if (definition == null) { throw new IllegalStateException("There's no container definition for element name " + element.getName()); } containerValue.applyDefinition(definition, false); PrismContainer container = definition.instantiate(); container.add(containerValue); return container; }
public static <T extends Containerable> boolean setFieldContainerValue(PrismContainerValue<?> parent, ItemName fieldName, PrismContainerValue<T> fieldContainerValue) { Validate.notNull(parent, "Prism container value must not be null."); Validate.notNull(fieldName, "QName must not be null."); try { PrismContainer<T> fieldContainer = null; if (fieldContainerValue == null) { parent.removeContainer(fieldName); } else { if (fieldContainerValue.getParent() != null && fieldContainerValue.getParent() != parent) { // This value is already part of another prism. We need to clone it to add it here. fieldContainerValue = fieldContainerValue.clone(); } fieldContainer = new PrismContainerImpl<>(fieldName, parent.getPrismContext()); fieldContainer.add(fieldContainerValue); parent.addReplaceExisting(fieldContainer); } } catch (SchemaException e) { // This should not happen. Code generator and compiler should take care of that. throw new IllegalStateException("Internal schema error: "+e.getMessage(),e); } return true; }
private void transplantIdentifiers(PrismContainerValue<ShadowAssociationType> association, PrismObject<ShadowType> repoShadow) throws SchemaException { PrismContainer<Containerable> identifiersContainer = association .findContainer(ShadowAssociationType.F_IDENTIFIERS); if (identifiersContainer == null) { ResourceAttributeContainer origContainer = ShadowUtil.getAttributesContainer(repoShadow); identifiersContainer = ObjectFactory.createResourceAttributeContainer(ShadowAssociationType.F_IDENTIFIERS, origContainer.getDefinition(), prismContext); association.add(identifiersContainer); } Collection<ResourceAttribute<?>> identifiers = ShadowUtil.getPrimaryIdentifiers(repoShadow); for (ResourceAttribute<?> identifier : identifiers) { identifiersContainer.add(identifier.clone()); } Collection<ResourceAttribute<?>> secondaryIdentifiers = ShadowUtil .getSecondaryIdentifiers(repoShadow); for (ResourceAttribute<?> identifier : secondaryIdentifiers) { identifiersContainer.add(identifier.clone()); } }
@SuppressWarnings("unchecked") private static void resolveLocalReferences(PolicyConstraintsType pc, ConstraintResolver resolver) throws ObjectNotFoundException, SchemaException { for (PolicyConstraintReferenceType ref : pc.getRef()) { String refName = ref != null ? ref.getName() : null; if (StringUtils.isEmpty(refName)) { throw new SchemaException("Illegal empty reference: " + ref); } List<String> pathToRoot = getPathToRoot(pc); if (pathToRoot.contains(refName)) { throw new SchemaException("Trying to resolve cyclic reference to constraint '" + refName + "'. Contained in: " + pathToRoot); } JAXBElement<? extends AbstractPolicyConstraintType> resolved = resolver.resolve(refName); QName constraintName = resolved.getName(); AbstractPolicyConstraintType constraintValue = resolved.getValue(); PrismContainer<? extends AbstractPolicyConstraintType> container = pc.asPrismContainerValue().findOrCreateContainer(constraintName); container.add(constraintValue.asPrismContainerValue().clone()); } pc.getRef().clear(); }
private <T> void setAttribute(PrismObject<ShadowType> account, String attrName, T val) throws SchemaException { PrismContainer<Containerable> attrsCont = account.findContainer(ShadowType.F_ATTRIBUTES); ResourceAttribute<T> attr = ObjectFactory.createResourceAttribute( dummyResourceCtl.getAttributeQName(attrName), null, prismContext); attr.setRealValue(val); attrsCont.add(attr); }
protected AssignmentType getAssignmentType(File assignmentFile) throws java.io.IOException, JAXBException, SchemaException { AssignmentType assignmentType = unmarshallValueFromFile(assignmentFile, AssignmentType.class); // We need to make sure that the assignment has a parent PrismContainerDefinition<AssignmentType> assignmentContainerDefinition = userTypeJack.asPrismObject().getDefinition().findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> assignmentContainer = assignmentContainerDefinition.instantiate(); assignmentContainer.add(assignmentType.asPrismContainerValue().clone()); return assignmentType; }
@Test public void singleValuedItems() throws Exception { System.out.println("===[ singleValuedItems ]==="); UserType userBean = getPrismContext().createObjectable(UserType.class) .beginAssignment() .id(1L) .targetRef(new ObjectReferenceType().oid("123456").type(RoleType.COMPLEX_TYPE)) .end(); //noinspection unchecked PrismContainerValue<AssignmentType> assignmentPcv = userBean.getAssignment().get(0).asPrismContainerValue(); PrismContainer<Containerable> limitContentPc = assignmentPcv .findOrCreateContainer(AssignmentType.F_LIMIT_TARGET_CONTENT); PrismContainerValue<Containerable> val1 = limitContentPc.createNewValue(); val1.setId(1L); PrismContainerValue<Containerable> val2 = val1.clone(); val2.setId(2L); try { limitContentPc.add(val2); fail("unexpected success"); } catch (SchemaException e) { System.out.println("Got expected exception: " + e); } }
@Test(enabled = false) // normalization no longer removes empty values public void testEqualsBrokenAssignmentActivation() throws Exception { final String TEST_NAME="testEqualsBrokenAssignmentActivation"; displayTestTitle(TEST_NAME); // GIVEN PrismObjectDefinition<UserType> userDef = PrismInternalTestUtil.getUserTypeDefinition(); PrismContainerDefinition<AssignmentType> assignmentDef = userDef.findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> goodAssignment = assignmentDef.instantiate(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> brokenAssignment = goodAssignment.clone(); assertEquals("Not equals after clone", goodAssignment, brokenAssignment); // lets break one of these ... PrismContainerValue<AssignmentType> emptyValue = getPrismContext().itemFactory().createContainerValue(); brokenAssignment.add(emptyValue); // WHEN assertFalse("Unexpected equals", goodAssignment.equals(brokenAssignment)); brokenAssignment.normalize(); assertEquals("Not equals after normalize(bad)", goodAssignment, brokenAssignment); goodAssignment.normalize(); assertEquals("Not equals after normalize(good)", goodAssignment, brokenAssignment); } }
@Test public void test132JackUnAssignRolePirateWithSeaInAssignment() throws Exception { final String TEST_NAME = "test132JackUnAssignRolePirateWithSeaInAssignment"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismContainer<?> extension = getAssignmentExtensionInstance(); PrismSchema piracySchema = getPiracySchema(); PrismPropertyDefinition<String> seaPropDef = piracySchema.findPropertyDefinitionByElementName(PIRACY_SEA_QNAME); PrismProperty<String> seaProp = seaPropDef.instantiate(); seaProp.setRealValue("Caribbean"); extension.add(seaProp); // WHEN unassignRole(USER_JACK_OID, ROLE_PIRATE_OID, extension, task, result); // THEN result.computeStatus(); TestUtil.assertSuccess(result); PrismObject<UserType> userJack = getUser(USER_JACK_OID); display("User after", userJack); assertAssignments(userJack, 0); assertRoleMembershipRef(userJack); assertDelegatedRef(userJack); assertNoDummyAccount(ACCOUNT_JACK_DUMMY_USERNAME); }
@Test public void test139JackUnAssignRoleAdriaticPirateWithSeaInAssignment() throws Exception { final String TEST_NAME = "test139JackUnAssignRoleAdriaticPirateWithSeaInAssignment"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismContainer<?> extension = getAssignmentExtensionInstance(); PrismSchema piracySchema = getPiracySchema(); PrismPropertyDefinition<String> seaPropDef = piracySchema.findPropertyDefinitionByElementName(PIRACY_SEA_QNAME); PrismProperty<String> seaProp = seaPropDef.instantiate(); seaProp.setRealValue("Caribbean"); extension.add(seaProp); // WHEN unassignRole(USER_JACK_OID, ROLE_ADRIATIC_PIRATE_OID, extension, getDefaultOptions(), task, result); // THEN result.computeStatus(); TestUtil.assertSuccess(result); PrismObject<UserType> userJack = getUser(USER_JACK_OID); display("User after", userJack); assertAssignments(userJack, 0); assertRoleMembershipRef(userJack); assertDelegatedRef(userJack); assertNoDummyAccount(ACCOUNT_JACK_DUMMY_USERNAME); }
@Test public void test149JackUnAssignRoleBlackSeaPirateWithSeaInAssignment() throws Exception { final String TEST_NAME = "test149JackUnAssignRoleBlackSeaPirateWithSeaInAssignment"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismContainer<?> extension = getAssignmentExtensionInstance(); PrismSchema piracySchema = getPiracySchema(); PrismPropertyDefinition<String> seaPropDef = piracySchema.findPropertyDefinitionByElementName(PIRACY_SEA_QNAME); PrismProperty<String> seaProp = seaPropDef.instantiate(); seaProp.setRealValue("Caribbean"); extension.add(seaProp); // WHEN unassignRole(USER_JACK_OID, ROLE_BLACK_SEA_PIRATE_OID, extension, getDefaultOptions(), task, result); // THEN result.computeStatus(); TestUtil.assertSuccess(result); PrismObject<UserType> userJack = getUser(USER_JACK_OID); display("User after", userJack); assertAssignments(userJack, 0); assertRoleMembershipRef(userJack); assertDelegatedRef(userJack); assertNoDummyAccount(ACCOUNT_JACK_DUMMY_USERNAME); }