@Override @Deprecated public <T extends Objectable> PrismObject<T> instantiate(Class<T> compileTimeClass) throws SchemaException { return prismContext.createObject(compileTimeClass); } //endregion
private PrismObject<TaskType> createPrism() { try { return getPrismContext().createObject(TaskType.class); } catch (SchemaException e) { throw new SystemException(e.getMessage(), e); } }
@Test public void testObjectTypeConstruction() throws Exception { System.out.println("\n\n ===[ testObjectTypeConstruction ]===\n"); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); try { // WHEN PrismObject<ObjectType> object = prismContext.createObject(ObjectType.class); fail("unexpected success"); } catch (SchemaException e) { // This is expected, abstract object types cannot be instantiated assertTrue(e.getMessage().contains("abstract")); } }
@Test public void testUserConstruction() throws Exception { System.out.println("\n\n ===[ testUserConstruction ]===\n"); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN PrismObject<UserType> user = prismContext.createObject(UserType.class); // THEN assertNotNull(user); SchemaTestUtil.assertUserDefinition(user.getDefinition()); }
} else { parent = prismContext.createObject(parentObjectType); PrismContainer<C> childContainer = parent.findOrCreateItem(childItemName, PrismContainer.class); childContainer.add(value.asPrismContainerValue());
@NotNull private <T extends ObjectType> List<PrismObject<T>> queryResultToPrismObjects(List<GetObjectResult> objects, Class<T> type, Collection<SelectorOptions<GetOperationOptions>> options, Session session, OperationResult result) throws SchemaException { List<PrismObject<T>> rv = new ArrayList<>(); if (objects != null) { for (GetObjectResult object : objects) { String oid = object.getOid(); Holder<PrismObject<T>> partialValueHolder = new Holder<>(); PrismObject<T> prismObject; try { prismObject = updateLoadedObject(object, type, oid, options, partialValueHolder, session, result); } catch (Throwable t) { if (!partialValueHolder.isEmpty()) { prismObject = partialValueHolder.getValue(); } else { prismObject = prismContext.createObject(type); prismObject.setOid(oid); prismObject.asObjectable().setName(PolyStringType.fromOrig("Unreadable object")); } result.recordFatalError("Couldn't retrieve " + type + " " + oid + ": " + t.getMessage(), t); prismObject.asObjectable().setFetchResult(result.createOperationResultType()); } rv.add(prismObject); } } return rv; }
@Test(enabled = false) public void test300Get() throws Exception { OperationResult result = new OperationResult("test300Get"); PrismObject<UserType> user = prismContext.createObject(UserType.class); user.asObjectable().setName(PolyStringType.fromOrig("user")); String oid = repositoryService.addObject(user, null, result); long time = System.currentTimeMillis(); int COUNT = 100; for (int i = 0; i < COUNT; i++) { LOGGER.info("Get operation {} of {}", i+1, COUNT); repositoryService.getObject(UserType.class, oid, null, result); } long duration = System.currentTimeMillis() - time; LOGGER.info("xxx>> time: {} ms, per get: {} ms", duration, (double) duration/COUNT); }
@Override public PrismObjectDefinition<ShadowType> getEditShadowDefinition(ResourceShadowDiscriminator discr, AuthorizationPhaseType phase, Task task, OperationResult parentResult) throws SchemaException, ConfigurationException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, SecurityViolationException { // HACK hack hack // Make a dummy shadow instance here and evaluate the schema for that. It is not 100% correct. But good enough for now. // TODO: refactor when we add better support for multi-tenancy PrismObject<ShadowType> shadow = prismContext.createObject(ShadowType.class); ShadowType shadowType = shadow.asObjectable(); ObjectReferenceType resourceRef = new ObjectReferenceType(); if (discr != null) { resourceRef.setOid(discr.getResourceOid()); shadowType.setResourceRef(resourceRef); shadowType.setKind(discr.getKind()); shadowType.setIntent(discr.getIntent()); shadowType.setObjectClass(discr.getObjectClass()); } return getEditObjectDefinition(shadow, phase, task, parentResult); }
@Test public void test100UserBasic() throws Exception { final String TEST_NAME = "test100UserBasic"; Task task = createTask(TEST_NAME); PrismObject<UserType> u = prismContext.createObject(UserType.class); u.setOid("123"); u.asObjectable().setName(new PolyStringType("user123")); u.asObjectable().setFullName(new PolyStringType("User User123")); /// WHEN displayWhen(TEST_NAME); final Scene scene = visualizer.visualize(u, task, task.getResult()); // THEN displayThen(TEST_NAME); display("scene", scene); // TODO some asserts }
@Override public PrismObject<ShadowType> createBlankShadow(RefinedObjectClassDefinition definition) { PrismObject<ShadowType> accountShadow; try { accountShadow = getPrismContext().createObject(ShadowType.class); } catch (SchemaException e) { // This should not happen throw new SystemException("Internal error instantiating account shadow: "+e.getMessage(), e); } ShadowType accountShadowType = accountShadow.asObjectable(); accountShadowType .intent(getIntent()) .kind(getKind()) .objectClass(getObjectClassDefinition().getTypeName()) .resourceRef(getResourceOid(), ResourceType.COMPLEX_TYPE); // Setup definition PrismObjectDefinition<ShadowType> newDefinition = accountShadow.getDefinition().cloneWithReplacedDefinition( ShadowType.F_ATTRIBUTES, definition.toResourceAttributeContainerDefinition()); accountShadow.setDefinition(newDefinition); return accountShadow; }
private PrismObject<CaseType> addCase(String description, String resourceOid, String shadowOid, ObjectDeltaType objectDelta, OperationResult result) throws SchemaException, ObjectAlreadyExistsException { PrismObject<CaseType> acase = getPrismContext().createObject(CaseType.class); CaseType caseType = acase.asObjectable();
private <X extends ObjectType> PrismObject<X> resolve(Session session, String oid, String defaultName, RObjectType defaultType) throws SchemaException { if (oid == null) { return null; } Query query = session.getNamedQuery("get.object"); query.setParameter("oid", oid); query.setResultTransformer(GetObjectResult.RESULT_STYLE.getResultTransformer()); GetObjectResult object = (GetObjectResult) query.uniqueResult(); PrismObject result; if (object != null) { String xml = RUtil.getXmlFromByteArray(object.getFullObject(), getConfiguration().isUseZip()); result = getPrismContext().parserFor(xml).language(SqlRepositoryServiceImpl.DATA_LANGUAGE).compat().parse(); } else if (defaultType != null) { result = getPrismContext().createObject(defaultType.getJaxbClass()); result.asObjectable().setName(PolyStringType.fromOrig(defaultName != null ? defaultName : oid)); result.setOid(oid); } else { result = null; } //noinspection unchecked return result; }
PrismObject<ResourceType> resource = prismContext.createObject(ResourceType.class); resource.setOid("oid1"); resource.asObjectable().setName(PolyStringType.fromOrig("resource1"));
@Test public static void testSerializeTask() throws Exception { ObjectQuery query = getPrismContext().queryFor(ShadowType.class) .item(ShadowType.F_KIND).eq(ShadowKindType.ACCOUNT) .build(); QueryType queryType = getPrismContext().getQueryConverter().createQueryType(query); PrismPropertyDefinition queryDef = getPrismContext().definitionFactory().createPropertyDefinition( SchemaConstants.MODEL_EXTENSION_OBJECT_QUERY, QueryType.COMPLEX_TYPE); PrismProperty<QueryType> queryProp = queryDef.instantiate(); queryProp.setRealValue(queryType); TaskType taskType = getPrismContext().createObject(TaskType.class).asObjectable(); taskType.setExtension(new ExtensionType(getPrismContext())); taskType.getExtension().asPrismContainerValue().add(queryProp); taskType.setName(PolyStringType.fromOrig("Test task")); String xml = getPrismContext().xmlSerializer().serialize(taskType.asPrismObject()); System.out.println("Task serialized:\n" + xml); PrismObject<TaskType> taskParsed = getPrismContext().parserFor(xml).parse(); String xmlSerializedAgain = getPrismContext().xmlSerializer().serialize(taskParsed); System.out.println("Task serialized again:\n" + xmlSerializedAgain); }
Task task = createTask(TEST_NAME); PrismObject<UserType> u = prismContext.createObject(UserType.class); UserType ut = u.asObjectable(); u.setOid("456");
@Test public void test600AddUser1() throws Exception { final String TEST_NAME = "test600AddUser1"; displayTestTitle(TEST_NAME); // GIVEN Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismObject<UserType> user1 = prismContext.createObject(UserType.class); prismContext.deltaFor(UserType.class) .item(UserType.F_NAME).replace(new PolyString("user1")) .item(UserType.F_ASSIGNMENT).add(ObjectTypeUtil.createAssignmentTo(resourceDummyCoral, prismContext).asPrismContainerValue()) .item(ACTIVATION_ADMINISTRATIVE_STATUS_PATH).replace(ActivationStatusType.DISABLED) .asObjectDelta(null) .applyTo((PrismObject) user1); ObjectDelta<UserType> addDelta = user1.createAddDelta(); // WHEN displayWhen(TEST_NAME); Collection<ObjectDeltaOperation<? extends ObjectType>> executedChanges = executeChanges(addDelta, null, task, result); // THEN displayThen(TEST_NAME); user1 = getUser(ObjectDeltaOperation.findFocusDeltaOidInCollection(executedChanges)); display("User after change execution", user1); DummyAccount dummyAccount = dummyResourceCoral.getAccountByUsername("user1"); display("Dummy account", dummyAccount); checkSuspendedAttribute(dummyAccount, Boolean.TRUE); String accountOid = getSingleLinkOid(user1); PrismObject<ShadowType> shadow = getShadowModel(accountOid); display("Shadow: ", shadow); // TODO check real state of the account and shadow }
prepareTest(); PrismObject<SecurityPolicyType> securityPolicy = prismContext.createObject(SecurityPolicyType.class); securityPolicy.asObjectable() .name("Ministry security policy")