protected PrismContainer<?> getAssignmentExtensionInstance() throws SchemaException { return getAssignmentExtensionDefinition().instantiate(); }
static <V extends Containerable> PrismContainer<V> newInstance(PrismContext prismContext, QName type) throws SchemaException { PrismContainerDefinition<V> definition = prismContext.getSchemaRegistry().findContainerDefinitionByType(type); if (definition == null) { throw new SchemaException("Definition for " + type + " couldn't be found"); } return definition.instantiate(); }
@NotNull private <C extends Containerable> PrismContainer<C> parseContainer(@NotNull XNodeImpl node, @NotNull QName itemName, @NotNull PrismContainerDefinition<C> containerDef, @NotNull ParsingContext pc) throws SchemaException { PrismContainer<C> container = containerDef.instantiate(itemName); if (node instanceof ListXNodeImpl) { ListXNodeImpl list = (ListXNodeImpl) node; if (containerDef instanceof PrismObject && list.size() > 1) { pc.warnOrThrow(LOGGER, "Multiple values for a PrismObject: " + node.debugDump()); parseContainerValueToContainer(container, list.get(0), pc); } else { for (XNodeImpl subNode : list) { parseContainerValueToContainer(container, subNode, pc); } } } else { parseContainerValueToContainer(container, node, pc); } return container; }
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; }
@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); } }
public PrismContainer<?> createExtension() throws SchemaException { PrismObjectDefinition<O> objeDef = getDefinition(); PrismContainerDefinition<Containerable> extensionDef = objeDef.findContainerDefinition(getExtensionContainerElementName()); PrismContainer<?> extensionContainer = extensionDef.instantiate(); getValue().add(extensionContainer); return extensionContainer; }
@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); } }
@NotNull PrismContainerDefinition<WorkItemActionsType> workItemActionsDef = schemaRegistry.findContainerDefinitionByElementName(SchemaConstants.MODEL_EXTENSION_WORK_ITEM_ACTIONS); PrismContainer<WorkItemActionsType> workItemActionsCont = workItemActionsDef.instantiate(); workItemActionsCont.add(actions.asPrismContainerValue().clone()); extension.asPrismContainerValue().add(workItemActionsCont); @NotNull PrismContainerDefinition<AbstractWorkItemActionType> workItemActionDef = schemaRegistry.findContainerDefinitionByElementName(SchemaConstants.MODEL_EXTENSION_WORK_ITEM_ACTION); PrismContainer<AbstractWorkItemActionType> workItemActionCont = workItemActionDef.instantiate(); workItemActionCont.add(notifyInfo.getValue().asPrismContainerValue().clone()); extension.asPrismContainerValue().add(workItemActionCont);
@Test public void testContainerSimpleDiffModificationsNoChange() throws Exception { System.out.println("\n\n===[ testContainerSimpleDiffModificationsNoChange ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismContainerDefinition<AssignmentType> assignmentContDef = userDef.findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> ass1 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass1cval = ass1.createNewValue(); ass1cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "blah blah", PrismTestUtil.getPrismContext()); PrismContainer<AssignmentType> ass2 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass2cval = ass2.createNewValue(); ass2cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "blah blah", PrismTestUtil.getPrismContext()); // WHEN Collection<? extends ItemDelta> modifications = ass1.diffModifications(ass2); // THEN assertNotNull(modifications); System.out.println(DebugUtil.debugDump(modifications)); assertEquals("Unexpected number of midifications", 0, modifications.size()); ItemDeltaCollectionsUtil.checkConsistence(modifications); }
public <V extends PrismValue, D extends ItemDefinition, AH extends AssignmentHolderType> Source<V,D> constructDefaultSource(ObjectDeltaObject<AH> focusOdo) throws SchemaException { if (objectTemplateMappingType != null) { return null; } PrismObject<AH> focus = focusOdo.getAnyObject(); assignmentDef = focus.getDefinition().findContainerDefinition(FocusType.F_ASSIGNMENT); PrismContainer<AssignmentType> assignment = assignmentDef.instantiate(); assignmentType = assignment.createNewValue().asContainerable(); QName relation = null; AssignmentPropertiesSpecificationType assignmentProperties = autoassignMappingType.getAssignmentProperties(); if (assignmentProperties != null) { relation = assignmentProperties.getRelation(); assignmentType.getSubtype().addAll(assignmentProperties.getSubtype()); } assignmentType.targetRef(role.getOid(), role.asPrismObject().getDefinition().getTypeName(), relation); Source<PrismContainerValue<AssignmentType>, PrismContainerDefinition<AssignmentType>> source = new Source<>(assignment, null, assignment, FocusType.F_ASSIGNMENT); return (Source<V, D>) source; }
@Test public void testContainerValueDiffDesciptionNoPath() throws Exception { System.out.println("\n\n===[ testContainerValueDiffDesciptionNoPath ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismContainerDefinition<AssignmentType> assignmentContDef = userDef.findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> ass1 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass1cval = ass1.createNewValue(); ass1cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "blah blah", PrismTestUtil.getPrismContext()); PrismContainer<AssignmentType> ass2 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass2cval = ass2.createNewValue(); ass2cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "chamalalia patlama paprtala", PrismTestUtil.getPrismContext()); // WHEN Collection<? extends ItemDelta> modifications = ass1cval.diff(ass2cval); // THEN assertNotNull(modifications); System.out.println(DebugUtil.debugDump(modifications)); assertEquals("Unexpected number of midifications", 1, modifications.size()); PrismAsserts.assertPropertyReplace( modifications, ItemPath.create(UserType.F_ASSIGNMENT, AssignmentType.F_DESCRIPTION), "chamalalia patlama paprtala"); ItemDeltaCollectionsUtil.checkConsistence(modifications); }
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 testContainerDiffModificationsDesciption() throws Exception { System.out.println("\n\n===[ testContainerDiffModificationsDesciption ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismContainerDefinition<AssignmentType> assignmentContDef = userDef.findContainerDefinition(UserType.F_ASSIGNMENT); PrismContainer<AssignmentType> ass1 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass1cval = ass1.createNewValue(); ass1cval.setId(1L); ass1cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "blah blah", PrismTestUtil.getPrismContext()); PrismContainer<AssignmentType> ass2 = assignmentContDef.instantiate(); PrismContainerValue<AssignmentType> ass2cval = ass2.createNewValue(); ass2cval.setId(1L); ass2cval.setPropertyRealValue(AssignmentType.F_DESCRIPTION, "chamalalia patlama paprtala", PrismTestUtil.getPrismContext()); // WHEN Collection<? extends ItemDelta> modifications = ass1.diffModifications(ass2); // THEN assertNotNull(modifications); System.out.println(DebugUtil.debugDump(modifications)); assertEquals("Unexpected number of midifications", 1, modifications.size()); PrismAsserts.assertPropertyReplace( modifications, ItemPath.create(UserType.F_ASSIGNMENT, 1L, AssignmentType.F_DESCRIPTION), "chamalalia patlama paprtala"); ItemDeltaCollectionsUtil.checkConsistence(modifications); }
@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()); }
@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); } }
ValidationResult validationResult = resourceValidator.validate(resourceTypePrismObject, Scope.THOROUGH, null, context.getTask(), result); PrismContainer pc = prismContext.getSchemaRegistry().findContainerDefinitionByElementName(SchemaConstantsGenerated.C_VALIDATION_RESULT).instantiate(); pc.add(validationResult.toValidationResultType().asPrismContainerValue());
.findContainerDefinitionByCompileTimeClass(AssignmentType.class).clone(); assignmentDef.toMutable().setMaxOccurs(1); PrismContainer<AssignmentType> assignmentContainer = assignmentDef.instantiate();
PrismContainer<ShadowAssociationType> associationContainer = associationDef.instantiate();
PrismContainer<PasswordHistoryEntryType> historyEntry = historyEntryDefinition.instantiate();
PrismContainer<ActivationType> activationContainer = activationDefinition.instantiate(); PrismPropertyDefinition enabledDef = activationDefinition.findPropertyDefinition(ActivationType.F_ENABLED); PrismProperty<Boolean> enabledProperty = enabledDef.instantiate();