public static ObjectQuery createResourceQuery(String resourceOid, PrismContext prismContext) throws SchemaException { Validate.notNull(resourceOid, "Resource where to search must not be null."); Validate.notNull(prismContext, "Prism context must not be null."); return prismContext.queryFactory().createQuery(createResourceFilter(resourceOid, prismContext)); }
private ObjectQuery addFilter(ObjectQuery query, ObjectFilter additionalFilter) { ObjectQuery newQuery; QueryFactory queryFactory = prismContext.queryFactory(); if (query == null) { newQuery = queryFactory.createQuery(additionalFilter); } else { newQuery = query.clone(); if (query.getFilter() == null) { newQuery.setFilter(additionalFilter); } else { newQuery.setFilter(queryFactory.createAnd(query.getFilter(), additionalFilter)); } } return newQuery; }
@Test(expectedExceptions = IllegalArgumentException.class) public void nullResult() throws Exception { ObjectPaging paging = prismContext.queryFactory().createPaging(0, Integer.MAX_VALUE, (ItemPath) null, null); ObjectQuery query = prismContext.queryFactory().createQuery(paging); controller.searchObjects(null, query, null, null, null); } }
public AccessCertificationCaseType getCase(String campaignOid, long caseId, @SuppressWarnings("unused") Task task, OperationResult result) throws SchemaException { QueryFactory queryFactory = prismContext.queryFactory(); ObjectFilter filter = queryFactory.createAnd( queryFactory.createOwnerHasOidIn(campaignOid), queryFactory.createInOid(String.valueOf(caseId)) ); ObjectQuery query = queryFactory.createQuery(filter); List<AccessCertificationCaseType> caseList = repositoryService.searchContainers(AccessCertificationCaseType.class, query, null, result); if (caseList.isEmpty()) { return null; } else if (caseList.size() == 1) { return caseList.get(0); } else { throw new IllegalStateException("More than one certification case with ID " + caseId + " in campaign " + campaignOid); } }
private void deleteByOid() throws SchemaException, IOException { QueryFactory queryFactory = context.getPrismContext().queryFactory(); InOidFilter filter = queryFactory.createInOid(options.getOid()); ObjectQuery query = queryFactory.createQuery(filter); deleteByFilter(query); }
/** * Both ObjectType and AssignmentHolderType are mapped to RObject. So when searching for AssignmentHolderType it is not sufficient to * query this table. This method hacks this situation a bit by introducing explicit type filter for AssignmentHolderType. */ private ObjectQuery refineAssignmentHolderQuery(Class<? extends Containerable> type, ObjectQuery query) { if (!type.equals(AssignmentHolderType.class)) { return query; } if (query == null) { query = prismContext.queryFactory().createQuery(); } query.setFilter(prismContext.queryFactory().createType(AssignmentHolderType.COMPLEX_TYPE, query.getFilter())); return query; } }
queryFactory.createQuery((ObjectFilter) null), opts, result); fullFilter = queryFactory.createAnd(fullFilter, filter); existingResourceRefs.forEach(f -> notFilters.add(queryFactory.createNot(f))); ObjectFilter fullFilter = queryFactory.createOr( queryFactory.createAnd(notFilters), createResourceRefFilter(null) ); if (filter != null) { fullFilter = queryFactory.createAnd(fullFilter, filter);
@Test(expectedExceptions = IllegalArgumentException.class) public void nullResult() throws Exception { ObjectPaging paging = prismContext.queryFactory().createPaging(0, Integer.MAX_VALUE, (ItemPath) null, null); controller.listResourceObjects("1", new QName("local name"), paging, null, null); } }
public static ObjectFilter createResourceAndObjectClassFilter(String resourceOid, QName objectClass, PrismContext prismContext) throws SchemaException { Validate.notNull(resourceOid, "Resource where to search must not be null."); Validate.notNull(objectClass, "Object class to search must not be null."); Validate.notNull(prismContext, "Prism context must not be null."); AndFilter and = prismContext.queryFactory().createAnd( createResourceFilter(resourceOid, prismContext), createObjectClassFilter(objectClass, prismContext)); return and; }
@Test public void test0710QueryCertCaseOwner() throws Exception { Session session = open(); try { InOidFilter filter = prismContext.queryFactory().createOwnerHasOidIn("123456"); ObjectQuery query = prismContext.queryFactory().createQuery(filter); String real = getInterpretedQuery2(session, AccessCertificationCaseType.class, query, false); String expected = "select\n" + " a.ownerOid, a.id, a.fullObject\n" + "from\n" + " RAccessCertificationCase a\n" + "where\n" + " a.ownerOid in :ownerOid"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
@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); }
private <C extends Containerable, O extends ObjectType> ObjectQuery preProcessSubobjectQuerySecurity(Class<C> containerType, Class<O> objectType, ObjectQuery origQuery, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { // Search containers is an operation on one object. Therefore even if it works with a search filter, it requires GET authorizations ObjectFilter secParentFilter = securityEnforcer.preProcessObjectFilter(ModelAuthorizationAction.AUTZ_ACTIONS_URLS_GET, null, objectType, null, null, null, null, task, result); if (secParentFilter == null || secParentFilter instanceof AllFilter) { return origQuery; // no need to update the query } ObjectFilter secChildFilter; if (secParentFilter instanceof NoneFilter) { secChildFilter = FilterCreationUtil.createNone(prismContext); } else { ObjectFilter origChildFilter = origQuery != null ? origQuery.getFilter() : null; ObjectFilter secChildFilterParentPart = prismContext.queryFactory().createExists(ItemName.fromQName(PrismConstants.T_PARENT), // fixme containerType, prismContext, secParentFilter); if (origChildFilter == null) { secChildFilter = secChildFilterParentPart; } else { secChildFilter = prismContext.queryFactory().createAnd(origChildFilter, secChildFilterParentPart); } } return updateObjectQuery(origQuery, secChildFilter); }
return Collections.singletonList(prismContext.queryFactory().createOr(prefixFilters)); } else { return prefixFilters;
objSpecTypeFilter = prismContext.queryFactory().createType(specTypeQName, null); if (special == SpecialObjectSpecificationType.SELF) { String principalOid = principal.getOid(); specialFilter = ObjectQueryUtil.filterOr(specialFilter, prismContext.queryFactory().createInOid(principalOid), prismContext); } else { prismContext.queryFactory().createType(specTypeQName, specialFilter) : specialFilter; } else { LOGGER.trace(" specials empty: {}", specSpecial); return securityFilterAllow; } else { ObjectFilter secFilter = ObjectQueryUtil.filterAnd(securityFilterAllow, prismContext.queryFactory().createNot(securityFilterDeny), prismContext); if (LOGGER.isTraceEnabled()) {
@Test public void test170OrLevel1Undefined() throws Exception { System.out.println("===[ test170OrLevel1Undefined ]==="); // GIVEN PrismContext prismContext = PrismTestUtil.getPrismContext(); // WHEN ObjectFilter filter = prismContext.queryFactory().createOr(prismContext.queryFactory().createUndefined()); System.out.println("Original filter:\n" + filter.debugDump()); // THEN ObjectFilter simplified = ObjectQueryUtil.simplify(filter, prismContext); System.out.println("Simplified filter:\n" + DebugUtil.debugDump(simplified)); assertTrue("Wrong simplified filter: " + simplified, simplified instanceof NoneFilter); }
@Override public void execute() throws Exception { OperationResult result = new OperationResult(OPERATION_IMPORT); OperationStatus progress = new OperationStatus(context, result); BlockingQueue<PrismObject> queue = new LinkedBlockingQueue<>(QUEUE_CAPACITY_PER_THREAD * options.getMultiThread()); // "+ 2" will be used for producer and progress reporter ExecutorService executor = Executors.newFixedThreadPool(options.getMultiThread() + 2); ImportProducerWorker producer; if (options.getOid() != null) { InOidFilter filter = context.getPrismContext().queryFactory().createInOid(options.getOid()); producer = importByFilter(filter, true, queue, progress); } else { ObjectFilter filter = NinjaUtils.createObjectFilter(options.getFilter(), context, ObjectType.class); // todo ok? (ObjectType) producer = importByFilter(filter, false, queue, progress); } executor.execute(producer); Thread.sleep(CONSUMERS_WAIT_FOR_START); executor.execute(new ProgressReporterWorker(context, options, queue, progress)); List<ImportConsumerWorker> consumers = createConsumers(queue, progress); consumers.stream().forEach(c -> executor.execute(c)); executor.shutdown(); executor.awaitTermination(NinjaUtils.WAIT_FOR_EXECUTOR_FINISH, TimeUnit.DAYS); handleResultOnFinish(progress, "Import finished"); }
private ObjectPaging getOrCreatePaging() { checkRelationalValueSearchQuery(); if (relationalValueSearchQuery.getPaging() == null) { relationalValueSearchQuery.setPaging(prismContext.queryFactory().createPaging()); } return relationalValueSearchQuery.getPaging(); }
@Test public void test0540queryObjectClassTypeUser() throws Exception { Session session = open(); try { TypeFilter type = prismContext.queryFactory().createType(UserType.COMPLEX_TYPE, null); String real = getInterpretedQuery2(session, ObjectType.class, prismContext.queryFactory().createQuery(type)); String expected = "select\n" + " o.oid, o.fullObject,\n" + " o.stringsCount,\n" + " o.longsCount,\n" + " o.datesCount,\n" + " o.referencesCount,\n" + " o.polysCount,\n" + " o.booleansCount\n" + "from\n" + " RObject o\n" + "where\n" + " o.objectTypeClass = :objectTypeClass\n"; assertEqualsIgnoreWhitespace(expected, real); } finally { close(session); } }
private <C extends Containerable> AndFilter parseAndFilter(MapXNodeImpl clauseXMap, PrismContainerDefinition<C> pcd, boolean preliminaryParsingOnly, ParsingContext pc) throws SchemaException { List<ObjectFilter> subfilters = parseLogicalFilter(clauseXMap, pcd, preliminaryParsingOnly, pc); if (preliminaryParsingOnly) { return null; } else { return prismContext.queryFactory().createAnd(subfilters); } }