public static ObjectQuery createAllShadowsQuery(ResourceType resourceType, PrismContext prismContext) throws SchemaException { return prismContext.queryFor(ShadowType.class) .item(ShadowType.F_RESOURCE_REF).ref(resourceType.getOid()) .build(); }
public static ObjectQuery createNormNameQuery(PolyString name, PrismContext prismContext) throws SchemaException { PolyStringNormalizer normalizer = new AlphanumericPolyStringNormalizer(); name.recompute(normalizer); return prismContext.queryFor(ObjectType.class) .item(ObjectType.F_NAME).eq(name).matchingNorm() .build(); }
@Test public void test120Undefined() throws Exception { final String TEST_NAME = "test120Undefined"; displayTestTitle(TEST_NAME); ObjectQuery q = getPrismContext().queryFor(UserType.class).undefined().build(); checkQueryRoundtripFile(UserType.class, q, TEST_NAME); }
@Test public void test420OrgFilterDirect() throws Exception { final String TEST_NAME = "test420OrgFilterDirect"; displayTestTitle(TEST_NAME); ObjectQuery q = getPrismContext().queryFor(OrgType.class).isDirectChildOf("222").build(); checkQueryRoundtripFile(OrgType.class, q, TEST_NAME); }
@Test public void testMultivaluedExtensionPropertySubstringUnqualified() throws SchemaException { ObjectQuery query = prismContext.queryFor(GenericObjectType.class) .item(ObjectType.F_EXTENSION, new QName("multivalued")).contains("slava") .build(); OperationResult result = new OperationResult("search"); List<PrismObject<GenericObjectType>> resources = repositoryService.searchObjects(GenericObjectType.class, query, null, result); result.recomputeStatus(); assertTrue(result.isSuccess()); assertEquals("Should find one object", 1, resources.size()); }
@Test public void testSearchTasksByArchetypeRef() throws SchemaException { ObjectQuery query = prismContext.queryFor(TaskType.class) .item(AssignmentHolderType.F_ARCHETYPE_REF).ref(ARCHETYPE1_OID) .build(); OperationResult result = new OperationResult("search"); List<PrismObject<TaskType>> objects = repositoryService.searchObjects(TaskType.class, query, null, result); result.recomputeStatus(); assertTrue(result.isSuccess()); System.out.println("Tasks found: " + objects); assertEquals("Should find 1 object", 1, objects.size()); }
@Test public void test300Greater() throws Exception { final String TEST_NAME = "test300Greater"; displayTestTitle(TEST_NAME); ObjectQuery q = getPrismContext().queryFor(UserType.class) .item(UserType.F_COST_CENTER).gt("100000") .build(); checkQueryRoundtripFile(UserType.class, q, TEST_NAME); }
@Test public void test200OrderByName() throws Exception{ ObjectQuery actual = getPrismContext().queryFor(UserType.class) .asc(UserType.F_NAME) .build(); ObjectQuery expected = ObjectQueryImpl.createObjectQuery( ObjectPagingImpl.createPaging(UserType.F_NAME, OrderDirection.ASCENDING) ); compare(actual, expected); }
@Test public void test600Type() throws Exception { final String TEST_NAME = "test600Type"; displayTestTitle(TEST_NAME); ObjectQuery q = getPrismContext().queryFor(ObjectType.class) .type(UserType.class) .item(UserType.F_NAME).eqPoly("somename", "somename") .build(); checkQueryRoundtripFile(ObjectType.class, q, TEST_NAME); }
@Test public void testDontMatchEqualFilter() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_GIVEN_NAME).eq("Jackie") .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertFalse("filter matches object, but it should not", match); }
@Test public void testMatchEqualEmptyAgainstNonEmptyItem() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); // jack has no locality ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_NAME).isNull() .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertFalse("filter matches object, but it should not", match); }
@Test // MID-4217 public void testRefPositive() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_ACCOUNT_REF).ref("c0c010c0-d34d-b33f-f00d-aaaaaaaa1113") .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertTrue("filter does not match object, but it should", match); }
public List<PrismObject<TaskType>> listPrerequisiteTasksRaw(OperationResult parentResult) throws SchemaException { OperationResult result = parentResult.createMinorSubresult(DOT_INTERFACE + "listPrerequisiteTasksRaw"); result.addContext(OperationResult.CONTEXT_OID, getOid()); result.addContext(OperationResult.CONTEXT_IMPLEMENTATION_CLASS, TaskQuartzImpl.class); ObjectQuery query = getPrismContext().queryFor(TaskType.class) .item(TaskType.F_DEPENDENT).eq(getTaskIdentifier()) .build(); List<PrismObject<TaskType>> list = taskManager.getRepositoryService().searchObjects(TaskType.class, query, null, result); result.recordSuccessIfUnknown(); return list; }
@Test public void testFunctionLibrary() throws SchemaException { ObjectQuery query = prismContext.queryFor(FunctionLibraryType.class) .item(ObjectType.F_NAME).eqPoly("fl1", "fl1").matchingOrig() .build(); OperationResult result = new OperationResult("search"); List<PrismObject<FunctionLibraryType>> collections = repositoryService.searchObjects(FunctionLibraryType.class, query, null, result); result.recomputeStatus(); assertTrue(result.isSuccess()); assertEquals("Should find 1 object", 1, collections.size()); }
@Test public void testPolystringMatchEqualFilter() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); PolyString name = new PolyString("jack", "jack"); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_NAME).eq(name) .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertTrue("filter does not match object", match); }
@Test public void test0331InOidEmptyTest() throws Exception { ObjectQuery query = prismContext.queryFor(ObjectType.class) .id(new String[0]).build(); query.setFilter(ObjectQueryUtil.simplify(query.getFilter(), prismContext)); assertTrue("Wrongly reduced InOid filter: " + query.getFilter(), query.getFilter() instanceof NoneFilter); }
protected ObjectQuery createShadowQueryByAttribute(ObjectClassComplexTypeDefinition rAccount, String attributeName, String attributeValue, PrismObject<ResourceType> resource) throws SchemaException { ResourceAttributeDefinition<Object> attrDef = rAccount.findAttributeDefinition(attributeName); return prismContext.queryFor(ShadowType.class) .itemWithDef(attrDef, ShadowType.F_ATTRIBUTES, attrDef.getName()).eq(attributeValue) .and().item(ShadowType.F_OBJECT_CLASS).eq(rAccount.getTypeName()) .and().item(ShadowType.F_RESOURCE_REF).ref(resource.getOid()) .build(); }
@Test public void testMatchOrFilter() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_GIVEN_NAME).eq("Jack") .or().item(UserType.F_GIVEN_NAME).eq("Jackie") .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertTrue("filter does not match object", match); }
@Test public void test305GreaterLesserMatchingNorm() throws Exception { final String TEST_NAME = "test305GreaterLesserMatchingNorm"; displayTestTitle(TEST_NAME); ObjectQuery q = getPrismContext().queryFor(UserType.class) .item(UserType.F_NAME).ge(new PolyString("00", "00")).matchingNorm() .and().item(UserType.F_NAME).lt(new PolyString("0a", "0a")).matchingNorm() .build(); checkQueryRoundtripFile(UserType.class, q, TEST_NAME); }
protected void waitForCampaignTasks(String campaignOid, int timeout, OperationResult result) throws CommonException { ObjectQuery query = prismContext.queryFor(TaskType.class) .item(TaskType.F_OBJECT_REF).ref(campaignOid) .build(); SearchResultList<PrismObject<TaskType>> campaignTasks = repositoryService.searchObjects(TaskType.class, query, null, result); for (PrismObject<TaskType> campaignTask : campaignTasks) { if (campaignTask.asObjectable().getExecutionStatus() != TaskExecutionStatusType.CLOSED && campaignTask.asObjectable().getExecutionStatus() != TaskExecutionStatusType.SUSPENDED) { waitForTaskFinish(campaignTask.getOid(), false, timeout); } } }