@NotNull @Override public <T extends Objectable> PrismObject<T> createObject(@NotNull Class<T> clazz) throws SchemaException { PrismObjectDefinition<T> definition = schemaRegistry.findObjectDefinitionByCompileTimeClass(clazz); if (definition == null) { throw new SchemaException("Definition for prism object holding " + clazz + " couldn't be found"); } return definition.instantiate(); }
protected <O extends ObjectType> PrismObject<O> instantiateObject(Class<O> type) throws SchemaException { return prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type).instantiate(); }
@Override public <T extends ObjectType> T createEmptyObject(Class<T> type) throws SchemaException { PrismObjectDefinition<T> objectDefinition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); PrismObject<T> object = objectDefinition.instantiate(); return object.asObjectable(); }
protected <O extends ObjectType> PrismObject<O> instantiateObject(Class<O> type) throws SchemaException { return getPrismContext().getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type).instantiate(); }
@Override public <O extends Objectable> ObjectDelta<O> createEmptyAddDelta(Class<O> type, String oid) throws SchemaException { ObjectDelta<O> objectDelta = this.createEmptyDelta(type, oid, ChangeType.ADD); PrismObjectDefinition<O> objDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(type); PrismObject<O> objectToAdd = objDef.instantiate(); objectDelta.setObjectToAdd(objectToAdd); return objectDelta; }
protected <O extends ObjectType> PrismObject<O> createObject(Class<O> type, String name) throws SchemaException { PrismObject<O> object = getObjectDefinition(type).instantiate(); object.asObjectable().setName(createPolyStringType(name)); return object; }
@Override public <F extends FocusType> void handle(LensContext<F> context, SynchronizationSituation<F> situation, Map<QName, Object> parameters, Task task, OperationResult parentResult) throws SchemaException { if (context == null) { throw new UnsupportedOperationException("addFocus action is not supported with synchronize=false"); } PrismContext prismContext = context.getPrismContext(); LensFocusContext<F> focusContext = context.createFocusContext(); Class<F> focusClass = focusContext.getObjectTypeClass(); LOGGER.trace("addFocus action: add delta for {}", focusClass); PrismObjectDefinition<F> focusDefinition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(focusClass); PrismObject<F> emptyFocus = focusDefinition.instantiate(); ObjectDelta<F> delta = emptyFocus.createAddDelta(); delta.setObjectToAdd(emptyFocus); focusContext.setPrimaryDelta(delta); }
private ObjectType convert(Class clazz, PrismObject<? extends ObjectType> o, OperationResultType result) { ObjectType objType = null; try { objType = (ObjectType) prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(clazz).instantiate().asObjectable(); objType.setOid(o.getOid()); objType.setName(o.asObjectable().getName()); return objType; } catch (SchemaException e) { // TODO Auto-generated catch block return objType; } }
private PrismObject<ResourceType> wrapInResource(Element xsdElement) throws SchemaException { PrismObjectDefinition<ResourceType> resourceDefinition = PrismTestUtil.getPrismContext().getSchemaRegistry().findObjectDefinitionByCompileTimeClass(ResourceType.class); PrismObject<ResourceType> resource = resourceDefinition.instantiate(); ResourceTypeUtil.setResourceXsdSchema(resource, xsdElement); return resource; }
private <T extends ShadowType> PrismObject<T> wrapInShadow(Class<T> type, ResourceAttributeContainer resourceObject) throws SchemaException { PrismObjectDefinition<T> shadowDefinition = getShadowDefinition(type); PrismObject<T> shadow = shadowDefinition.instantiate(); resourceObject.setElementName(ShadowType.F_ATTRIBUTES); shadow.getValue().add(resourceObject); return shadow; }
@Test public void testPropertyUserSimpleDiffMultiAddStaticNull1() throws Exception { System.out.println("\n\n===[ testPropertyUserSimpleDiffMultiAddStaticNull1 ]===\n"); // GIVEN PrismObjectDefinition<UserType> userDef = getUserTypeDefinition(); PrismObject<UserType> user2 = userDef.instantiate(); user2.setOid(USER_JACK_OID); PrismProperty<String> additionalNamesProp2 = user2.findOrCreateProperty(UserType.F_ADDITIONAL_NAMES); additionalNamesProp2.addRealValue("foo"); additionalNamesProp2.addRealValue("bar"); // WHEN PropertyDelta<String> delta = ItemUtil.diff(null, additionalNamesProp2); // THEN assertNotNull(delta); System.out.println(delta.debugDump()); PrismAsserts.assertAdd(delta, "foo", "bar"); delta.checkConsistence(); }
@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)); }
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; }
private void assertDeprecatedProtectedAccount(String message, ResourceObjectPattern protectedPattern, String identifierValue, RefinedObjectClassDefinition rAccount) throws SchemaException { Collection<ResourceAttribute<?>> identifiers = protectedPattern.getIdentifiers(); assertNotNull("Null identifiers in "+message, identifiers); assertEquals("Wrong number identifiers in "+message, 1, identifiers.size()); ResourceAttribute<?> identifier = identifiers.iterator().next(); assertNotNull("Null identifier in "+message, identifier); assertEquals("Wrong identifier value in "+message, identifier.getRealValue(), identifierValue); // Try matching PrismObject<ShadowType> shadow = rAccount.getObjectDefinition().instantiate(); ResourceAttributeContainer attributesContainer = ShadowUtil.getOrCreateAttributesContainer(shadow, rAccount); ResourceAttribute<String> confusingAttr1 = createStringAttribute(new QName("http://whatever.com","confuseMe"), "HowMuchWoodWouldWoodchuckChuckIfWoodchuckCouldChudkWood"); attributesContainer.add(confusingAttr1); ResourceAttribute<String> nameAttr = createStringAttribute(SchemaTestConstants.ICFS_NAME, identifierValue); attributesContainer.add(nameAttr); ResourceAttribute<String> confusingAttr2 = createStringAttribute(new QName("http://whatever.com","confuseMeAgain"), "WoodchuckWouldChuckNoWoodAsWoodchuckCannotChuckWood"); attributesContainer.add(confusingAttr2); assertTrue("Test attr not matched in "+message, protectedPattern.matches(shadow, null, relationRegistry)); nameAttr.setRealValue("huhulumululul"); assertFalse("Test attr nonsense was matched in "+message, protectedPattern.matches(shadow, null, relationRegistry)); }
private void createObjects() throws com.evolveum.midpoint.util.exception.ObjectAlreadyExistsException, com.evolveum.midpoint.util.exception.SchemaException { OperationResult result = new OperationResult("add objects"); for (int i = BASE; i < BASE + COUNT; i++) { UserType user = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(UserType.class).instantiate().asObjectable(); user.setOid("user-" + i + "-00"); user.setName(new PolyStringType(new PolyString("user-"+i))); user.setCostCenter(String.valueOf(i)); repositoryService.addObject(user.asPrismObject(), null, result); } result.recomputeStatus(); assertTrue(result.isSuccess()); }
protected ObjectDelta<UserType> createModifyUserAddAccount(String userOid, PrismObject<ResourceType> resource) throws SchemaException { PrismObject<ShadowType> account = getAccountShadowDefinition().instantiate(); ObjectReferenceType resourceRef = new ObjectReferenceType(); resourceRef.setOid(resource.getOid()); account.asObjectable().setResourceRef(resourceRef); RefinedResourceSchema refinedSchema = RefinedResourceSchemaImpl.getRefinedSchema(resource); account.asObjectable().setObjectClass(refinedSchema.getDefaultRefinedDefinition(ShadowKindType.ACCOUNT).getObjectClassDefinition().getTypeName()); ObjectDelta<UserType> userDelta = prismContext.deltaFactory().object().createEmptyModifyDelta(UserType.class, userOid ); PrismReferenceValue accountRefVal = itemFactory().createReferenceValue(); accountRefVal.setObject(account); ReferenceDelta accountDelta = prismContext.deltaFactory().reference().createModificationAdd(UserType.F_LINK_REF, getUserDefinition(), accountRefVal); userDelta.addModification(accountDelta); return userDelta; }
private void addTask(String oid, String name, String ownerOid, String handlerUri, Task execTask, OperationResult result) throws SchemaException, ObjectAlreadyExistsException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException { PrismObject<TaskType> task = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(TaskType.class).instantiate(); task.setOid(oid); TaskType taskType = task.asObjectable(); taskType.setName(createPolyStringType(name)); if (ownerOid != null) { ObjectReferenceType ownerRef = new ObjectReferenceType(); ownerRef.setOid(ownerOid); taskType.setOwnerRef(ownerRef); } taskType.setHandlerUri(handlerUri); modelService.executeChanges(MiscSchemaUtil.createCollection(task.createAddDelta()), null, execTask, result); }
private String testIterationToken(String token) throws Exception { PrismObjectDefinition accDef = prismContext.getSchemaRegistry() .findObjectDefinitionByCompileTimeClass(ShadowType.class); PrismObject<ShadowType> shadow = accDef.instantiate(); ShadowType shadowType = shadow.asObjectable(); shadowType.setName(new PolyStringType("testIterationToken")); shadowType.setIterationToken(token); OperationResult result = new OperationResult("sync desc test"); final String oid = repositoryService.addObject(shadowType.asPrismObject(), null, result); shadow = repositoryService.getObject(ShadowType.class, oid, null, result); shadowType = shadow.asObjectable(); token = shadowType.getIterationToken(); repositoryService.deleteObject(ShadowType.class, oid, result); return token; }
private PrismObject<UserType> createUserWill() throws SchemaException { PrismObject<UserType> user = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(UserType.class).instantiate(); user.asObjectable() .name(USER_WILL_NAME) .givenName(USER_WILL_GIVEN_NAME) .familyName(USER_WILL_FAMILY_NAME) .fullName(USER_WILL_FULL_NAME) .beginActivation().administrativeStatus(ActivationStatusType.ENABLED).<UserType>end() .beginCredentials().beginPassword().beginValue().setClearValue(USER_WILL_PASSWORD_OLD); return user; }
@Test public void testInboundMapping() throws Exception{ final String TEST_NAME = "testInboundMapping"; TestUtil.displayTestTitle(TEST_NAME); PrismContext prismContext = evaluator.getPrismContext(); PrismObject<ShadowType> account = PrismTestUtil.parseObject(new File(MappingTestEvaluator.TEST_DIR + "/account-inbound-mapping.xml")); Item oldItem = account.findItem(ItemPath.create(ShadowType.F_ATTRIBUTES, SchemaTestConstants.ICFS_NAME)); ItemDelta delta = prismContext.deltaFactory().property().createModificationAddProperty(SchemaTestConstants.ICFS_NAME_PATH_PARTS, (PrismPropertyDefinition) oldItem.getDefinition(), ((PrismPropertyValue) oldItem.getAnyValue()).getValue()); PrismObject<UserType> user = evaluator.getUserDefinition().instantiate(); MappingImpl<PrismPropertyValue<PolyString>,PrismPropertyDefinition<PolyString>> mapping = evaluator.createInboudMapping("mapping-inbound.xml", TEST_NAME, delta, user.asObjectable(), account.asObjectable(), null, null); OperationResult opResult = new OperationResult(TEST_NAME); mapping.evaluate(null, opResult); PrismValueDeltaSetTriple<PrismPropertyValue<PolyString>> outputTriple = mapping.getOutputTriple(); outputTriple.checkConsistence(); assertTripleZero(outputTriple, PrismTestUtil.createPolyString("pavolr")); PrismAsserts.assertTripleNoPlus(outputTriple); assertTripleNoMinus(outputTriple); }