private ObjectQuery toObjectQuery(Class type, QueryType queryType) throws Exception { return getQueryConverter().createObjectQuery(type, queryType ); }
private ObjectQuery toObjectQuery(Class type, SearchFilterType filterType) throws Exception { return getQueryConverter().createObjectQuery(type, filterType ); }
private Collection<ObjectReferenceType> resolveQuery(Class<? extends ObjectType> type, QueryType queryBean, ExecutionContext context, OperationResult result) throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, SecurityViolationException, ExpressionEvaluationException { ObjectQuery query = context.getQueryConverter().createObjectQuery(type, queryBean); SearchResultList<? extends PrismObject<? extends ObjectType>> objects = context.getModelService() .searchObjects(type, query, null, context.getTask(), result); return objects.stream().map(o -> ObjectTypeUtil.createObjectRef(o, context.getPrismContext())).collect(Collectors.toList()); }
private ObjectQuery toObjectQuery(Class type, QueryType queryType) throws Exception { ObjectQuery query = getPrismContext().getQueryConverter().createObjectQuery(type, queryType ); return query; }
private ObjectQuery toObjectQuery(Class type, SearchFilterType filterType) throws Exception { ObjectQuery query = getPrismContext().getQueryConverter().createObjectQuery(type, filterType ); return query; }
@Nullable private ObjectQuery getQuery(File file, Class type) throws SchemaException, IOException { QueryType queryType = PrismTestUtil.parseAtomicValue(file, QueryType.COMPLEX_TYPE); LOGGER.info("QUERY TYPE TO CONVERT : {}", ObjectQueryUtil.dump(queryType, prismContext)); ObjectQuery query = null; try { query = getQueryConverter().createObjectQuery(type, queryType); // TODO } catch (Exception ex) { LOGGER.info("error while converting query: " + ex.getMessage(), ex); } return query; }
protected ObjectQuery createQueryFromTaskIfExists(H handler, TaskRunResult runResult, Task task, OperationResult opResult) throws SchemaException { Class<? extends ObjectType> objectType = getType(task); LOGGER.trace("Object type = {}", objectType); QueryType queryFromTask = getObjectQueryTypeFromTask(task); if (queryFromTask != null) { ObjectQuery query = prismContext.getQueryConverter().createObjectQuery(objectType, queryFromTask); if (LOGGER.isTraceEnabled()) { LOGGER.trace("Using object query from the task:\n{}", query.debugDump(1)); } return query; } else { return null; } }
@Test public void testUserQuery() throws Exception { displayTestTitle("testUserQuery"); File[] userQueriesToTest = new File[] { new File(TEST_DIR, "filter-user-by-fullName.xml"), new File(TEST_DIR, "filter-user-by-name.xml"), new File(TEST_DIR, "filter-user-substring-fullName.xml"), new File(TEST_DIR, "filter-user-substring-employeeType.xml"), new File(TEST_DIR, "filter-user-substring-expression.xml"), new File(TEST_DIR, "filter-user-substring-anchor-start-end-expression.xml") }; // prismContext.silentMarshalObject(queryTypeNew, LOGGER); for (File file : userQueriesToTest) { SearchFilterType filterType = PrismTestUtil.parseAtomicValue(file, SearchFilterType.COMPLEX_TYPE); LOGGER.info("===[ query type parsed ]==="); ObjectQuery query; try { query = getQueryConverter().createObjectQuery(UserType.class, filterType); LOGGER.info("query converted: "); LOGGER.info("QUERY DUMP: {}", query.debugDump()); LOGGER.info("QUERY Pretty print: {}", query.toString()); System.out.println("QUERY Pretty print: " + query.toString()); QueryType convertedQueryType = getQueryConverter().createQueryType(query); LOGGER.info(DOMUtil.serializeDOMToString(convertedQueryType.getFilter().getFilterClauseAsElement(getPrismContext()))); } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } } }
ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType);
@Override public void searchObjects(QName objectType, QueryType query, SelectorQualifiedGetOptionsType optionsType, Holder<ObjectListType> objectListHolder, Holder<OperationResultType> result) throws FaultMessage { notNullArgument(objectType, "Object type must not be null."); Task task = createTaskInstance(SEARCH_OBJECTS); auditLogin(task); OperationResult operationResult = task.getResult(); try { Class objectClass = ObjectTypes.getObjectTypeFromTypeQName(objectType).getClassDefinition(); Collection<SelectorOptions<GetOperationOptions>> options = MiscSchemaUtil.optionsTypeToOptions(optionsType, prismContext); ObjectQuery q = prismContext.getQueryConverter().createObjectQuery(objectClass, query); List<PrismObject<? extends ObjectType>> list = (List)model.searchObjects(objectClass, q, options, task, operationResult); handleOperationResult(operationResult, result); ObjectListType listType = new ObjectListType(); for (PrismObject<? extends ObjectType> o : list) { listType.getObject().add(o.asObjectable()); } objectListHolder.value = listType; } catch (Exception ex) { LoggingUtils.logException(LOGGER, "# MODEL searchObjects() failed", ex); throwFault(ex, operationResult); } finally { auditLogout(task); } }
@Test public void testConnectorQuery() throws Exception { displayTestTitle("testConnectorQuery"); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(FILTER_CONNECTOR_BY_TYPE_FILE, SearchFilterType.COMPLEX_TYPE); ObjectQuery query; try { query = getQueryConverter().createObjectQuery(ConnectorType.class, filterType); displayQuery(query); assertNotNull(query); ObjectFilter filter = query.getFilter(); PrismAsserts.assertEqualsFilter(query.getFilter(), ConnectorType.F_CONNECTOR_TYPE, DOMUtil.XSD_STRING, ConnectorType.F_CONNECTOR_TYPE); PrismAsserts.assertEqualsFilterValue((EqualFilter) filter, "org.identityconnectors.ldap.LdapConnector"); QueryType convertedQueryType = toQueryType(query); displayQueryType(convertedQueryType); } catch (Exception ex) { LOGGER.error("Error while converting query: {}", ex.getMessage(), ex); throw ex; } }
/** * Account counting is simulated. * For "dumber" resource it is defined in schemaHandling as a object-type-specific capability. */ @Test public void test250CountAccounts() throws Exception { final String TEST_NAME = "test250CountAccounts"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); // WHEN displayWhen(TEST_NAME); Integer count = provisioningService.countObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); assertSuccess(result); display("All accounts count", count); assertEquals("Unexpected number of search results", (Integer)14, count); }
/** * Account counting is simulated. * But "dumber" resource do not have any simulation for this. */ @Test public void test252CountLdapGroups() throws Exception { final String TEST_NAME = "test252CountLdapGroups"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_LDAP_GROUPS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); // WHEN displayWhen(TEST_NAME); Integer count = provisioningService.countObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); assertSuccess(result); display("All LDAP groups count", count); assertEquals("Unexpected number of search results", getExpectedLdapGroupCountTest25x(), count); }
@Test public void test202SearchObjectsCompexFilter() throws Exception { final String TEST_NAME = "test202SearchObjectsCompexFilter"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_COMPLEX_FILTER_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); provisioningService.applyDefinition(ShadowType.class, query, task, result); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); List<PrismObject<ShadowType>> objListType = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); result.computeStatus(); TestUtil.assertSuccess(result); for (PrismObject<ShadowType> objType : objListType) { assertNotNull("Null search result", objType); display("found object", objType); } assertEquals("Unexpected number of objects found", 1, objListType.size()); assertConnectorOperationIncrement(1, 3); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); }
@Test public void test234SearchObjectsPagedOffsetSortSn() throws Exception { final String TEST_NAME = "test234SearchObjectsPagedOffsetSortSn"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); ObjectPaging paging = prismContext.queryFactory().createPaging(2, 4); paging.setOrdering(prismContext.queryFactory().createOrdering( ItemPath.create(ShadowType.F_ATTRIBUTES, new QName(RESOURCE_NS, "sn")), OrderDirection.ASCENDING)); query.setPaging(paging); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); List<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); result.computeStatus(); assertSuccess(result); display("Search resutls", searchResults); assertSearchResults(searchResults, "jbeckett", "jbond", "cook", "drake" ); assertConnectorOperationIncrement(1, 9); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); }
@Test public void test233SearchObjectsPagedNoOffsetSortSn() throws Exception { final String TEST_NAME = "test233SearchObjectsPagedNoOffsetSortSn"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); ObjectPaging paging = prismContext.queryFactory().createPaging(null, 4); paging.setOrdering(prismContext.queryFactory().createOrdering( ItemPath.create(ShadowType.F_ATTRIBUTES, new QName(RESOURCE_NS, "sn")), OrderDirection.ASCENDING)); query.setPaging(paging); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); result.computeStatus(); assertSuccess(result); display("Search resutls", searchResults); assertSearchResults(searchResults, "monk", "hbarbossa", "jbeckett", "jbond" ); assertConnectorOperationIncrement(1, 9); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // null offset means SPR search means no estimate assertApproxNumberOfAllResults(searchResults.getMetadata(), null); }
@Test public void test230SearchObjectsPagedNoOffset() throws Exception { final String TEST_NAME = "test230SearchObjectsPagedNoOffset"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); ObjectPaging paging = prismContext.queryFactory().createPaging(null, 3); query.setPaging(paging); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); assertSuccess(result); display("Search resutls", searchResults); assertSearchResults(searchResults, "cook", "drake", "hbarbossa" ); assertConnectorOperationIncrement(1, 7); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // null offset, SPR, no estimate. assertApproxNumberOfAllResults(searchResults.getMetadata(), null); }
@Test public void test231SearchObjectsPagedOffsetZero() throws Exception { final String TEST_NAME = "test231SearchObjectsPagedOffsetZero"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); ObjectPaging paging = prismContext.queryFactory().createPaging(0, 4); query.setPaging(paging); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); assertSuccess(result); display("Search resutls", searchResults); assertSearchResults(searchResults, "cook", "drake", "hbarbossa", "idm"); assertConnectorOperationIncrement(1, 9); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // VLV search if forced by using offset. So we have result number estimate. assertApproxNumberOfAllResults(searchResults.getMetadata(), 14); }
@Test public void test232SearchObjectsPagedOffset() throws Exception { final String TEST_NAME = "test232SearchObjectsPagedOffset"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); ObjectPaging paging = prismContext.queryFactory().createPaging(2, 5); query.setPaging(paging); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN displayWhen(TEST_NAME); SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN displayThen(TEST_NAME); result.computeStatus(); assertSuccess(result); display("Search resutls", searchResults); // The results should be this: assertSearchResults(searchResults, "hbarbossa", "idm", "jbeckett", "jbond", "jgibbs" ); assertConnectorOperationIncrement(1, 11); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // VLV search if forced by using offset. So we have result number estimate. assertApproxNumberOfAllResults(searchResults.getMetadata(), 14); }
@Test public void test201SearchObjects() throws Exception { final String TEST_NAME = "test201SearchObjects"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); ShadowType object = parseObjectType(ACCOUNT_SEARCH_FILE, ShadowType.class); display("New object", object); String addedObjectOid = provisioningService.addObject(object.asPrismObject(), null, null, taskManager.createTaskInstance(), result); assertEquals(ACCOUNT_SEARCH_OID, addedObjectOid); QueryType queryType = PrismTestUtil.parseAtomicValue(QUERY_ALL_ACCOUNTS_FILE, QueryType.COMPLEX_TYPE); ObjectQuery query = getQueryConverter().createObjectQuery(ShadowType.class, queryType); rememberCounter(InternalCounters.CONNECTOR_OPERATION_COUNT); rememberCounter(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT); // WHEN SearchResultList<PrismObject<ShadowType>> searchResults = provisioningService.searchObjects(ShadowType.class, query, null, task, result); // THEN result.computeStatus(); assertSuccess(result); display("Search resutls", searchResults); assertEquals("Unexpected number of search results", 14, searchResults.size()); assertConnectorOperationIncrement(1, 29); assertCounterIncrement(InternalCounters.CONNECTOR_SIMULATED_PAGING_SEARCH_COUNT, 0); // SPR search. No estimate. assertApproxNumberOfAllResults(searchResults.getMetadata(), null); }