private ObjectQuery toObjectQuery(Class type, QueryType queryType) throws Exception { return getQueryConverter().createObjectQuery(type, queryType ); }
ObjectQuery query = prismContext.queryFactory().createQuery(); if (searchFilter != null) { query.setFilter(getQueryConverter().parseFilter(searchFilter, objectClass));
@NotNull @Override public List<ObjectFilter> createSpecificFilters(@NotNull WorkBucketType bucket, AbstractWorkSegmentationType configuration, Class<? extends ObjectType> type, Function<ItemPath, ItemDefinition<?>> itemDefinitionProvider) throws SchemaException { FilterWorkBucketContentType content = (FilterWorkBucketContentType) bucket.getContent(); List<ObjectFilter> rv = new ArrayList<>(); for (SearchFilterType filter : content.getFilter()) { rv.add(prismContext.getQueryConverter().createObjectFilter(type, filter)); } return rv; } }
@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; } } }
if (searchExpression.getQuery() != null) { try { unresolvedObjectQuery = context.getQueryConverter().createObjectQuery(objectClass, searchExpression.getQuery()); } catch (SchemaException e) { throw new ScriptExecutionException("Couldn't parse object query due to schema exception", e); unresolvedObjectQuery = prismContext.queryFactory().createQuery(); try { ObjectFilter filter = prismContext.getQueryConverter().parseFilter(searchExpression.getSearchFilter(), objectClass); unresolvedObjectQuery.setFilter(filter); } catch (SchemaException e) {
public <T extends ObjectType> QueryKey(Class<T> type, ObjectQuery query, ObjectSearchStrategyType searchStrategy, PrismContext prismContext) { this.type = type; try { this.query = query != null ? prismContext.getQueryConverter().createQueryType(query) : null; } catch (SchemaException e) { throw new SystemException(e); } this.searchStrategy = searchStrategy; }
.item(UserType.F_COST_CENTER).eq("100") .buildFilter(); SearchFilterType filterBean = prismContext.getQueryConverter().createSearchFilterType(filter); ObjectFilter filterFromRepoParsed = prismContext.getQueryConverter().createObjectFilter(UserType.class, filterFromRepo); ObjectFilter filterExpectedParsed = prismContext.getQueryConverter().createObjectFilter(UserType.class, filterExpected);
/** * Asynchronously executes simple scripting expressions, consisting of one search command and one action. * * @param objectType Object type to search (e.g. c:UserType) * @param filter Filter to be applied (ObjectFilter) * @param actionName Action to be executed on objects found (e.g. "disable", "delete", "recompute", etc). * @param task Task in context of which the script should execute. The task should be "clean", i.e. * (1) transient, (2) without any handler. This method puts the task into background, * and assigns ScriptExecutionTaskHandler to it, to execute the script. */ @Deprecated public void evaluateExpressionInBackground(QName objectType, ObjectFilter filter, String actionName, Task task, OperationResult parentResult) throws SchemaException { Validate.notNull(objectType); Validate.notNull(actionName); Validate.notNull(task); SearchExpressionType search = new SearchExpressionType(); search.setType(objectType); if (filter != null) { search.setSearchFilter(prismContext.getQueryConverter().createSearchFilterType(filter)); } ActionExpressionType action = new ActionExpressionType(); action.setType(actionName); search.setScriptingExpression(objectFactory.createAction(action)); evaluateExpressionInBackground(search, task, parentResult); }
public <T extends ObjectType> QueryKey(Class<T> type, ObjectQuery query, PrismContext prismContext) { this.type = type; try { this.query = query != null ? prismContext.getQueryConverter().createQueryType(query) : null; } catch (SchemaException e) { throw new SystemException(e); } }
<O extends ObjectType> AccessCertificationCampaignType createAdHocCampaignObject( AccessCertificationDefinitionType definition, PrismObject<O> focus, Task task, OperationResult result) throws SecurityViolationException, SchemaException { definition.setName(PolyStringType.fromOrig(PolyString.getOrig(definition.getName()) + " " + PolyString.getOrig(focus.getName()))); definition.setLastCampaignIdUsed(null); AccessCertificationCampaignType campaign = createCampaignObject(definition, task, result); AccessCertificationObjectBasedScopeType scope; if ((campaign.getScopeDefinition() instanceof AccessCertificationObjectBasedScopeType)) { scope = (AccessCertificationObjectBasedScopeType) campaign.getScopeDefinition(); } else { // TODO! scope = new AccessCertificationAssignmentReviewScopeType(prismContext); campaign.setScopeDefinition(scope); } Class<? extends ObjectType> focusClass = focus.asObjectable().getClass(); scope.setObjectType(ObjectTypes.getObjectType(focusClass).getTypeQName()); ObjectFilter objectFilter = prismContext.queryFor(focusClass).id(focus.getOid()).buildFilter(); scope.setSearchFilter(getQueryConverter().createSearchFilterType(objectFilter)); return campaign; }
private ObjectQuery toObjectQuery(Class type, SearchFilterType filterType) throws Exception { return getQueryConverter().createObjectQuery(type, filterType ); }
public static ObjectQuery createObjectQuery(FileReference ref, NinjaContext context, Class<? extends ObjectType> objectClass) throws IOException, SchemaException { if (ref == null) { return null; } String filterStr = ref.getValue(); if (ref.getReference() != null) { File file = ref.getReference(); filterStr = FileUtils.readFileToString(file, context.getCharset()); } PrismContext prismContext = context.getPrismContext(); PrismParserNoIO parser = prismContext.parserFor(filterStr); RootXNode root = parser.parseToXNode(); ObjectFilter filter = context.getQueryConverter().parseFilter(root.toMapXNode(), objectClass); return prismContext.queryFactory().createQuery(filter); }
private QueryType toQueryType(ObjectQuery query) throws Exception { return getQueryConverter().createQueryType(query); }
private <O extends ObjectType> ObjectFilter parseAndEvaluateFilter(MidPointPrincipal principal, PrismObjectDefinition<O> objectDefinition, SearchFilterType specFilterType, String objectTargetDesc, String autzHumanReadableDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { ObjectFilter specFilter = prismContext.getQueryConverter().createObjectFilter(objectDefinition, specFilterType); if (specFilter == null) { return null; } ObjectFilterExpressionEvaluator filterEvaluator = createFilterEvaluator(principal, objectTargetDesc, autzHumanReadableDesc, task, result); return filterEvaluator.evaluate(specFilter); }
.item(FocusType.F_ASSIGNMENT, AssignmentType.F_TARGET_REF).ref(referenceValue) .buildFilter(); SearchFilterType filterType = prismContext.getQueryConverter().createSearchFilterType(refFilter); QueryType queryType = new QueryType(); queryType.setFilter(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()); }
LOGGER.info("Expression variables for filter evaluation: {}", variables); ObjectFilter origFilter = getPrismContext().getQueryConverter().parseFilter(getConstructionType().getResourceRef().getFilter(), ResourceType.class); LOGGER.info("Orig filter {}", origFilter);
private QueryType toQueryType(ObjectQuery query) throws Exception { return getPrismContext().getQueryConverter().createQueryType(query); }
private ObjectFilter evaluateExpressionAssertFilter(String filename, String input, Class<? extends ObjectFilter> expectedType, Task task, OperationResult result) throws SchemaException, IOException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException { PrismContext prismContext = PrismTestUtil.getPrismContext(); SearchFilterType filterType = PrismTestUtil.parseAtomicValue(new File(TEST_DIR, filename), SearchFilterType.COMPLEX_TYPE); ObjectFilter filter = prismContext.getQueryConverter().createObjectFilter(UserType.class, filterType); Map<QName, Object> params = new HashMap<>(); PrismPropertyValue<String> pval = null; if (input != null) { pval = prismContext.itemFactory().createPropertyValue(input); } params.put(ExpressionConstants.VAR_INPUT, pval); ExpressionVariables variables = new ExpressionVariables(); variables.addVariableDefinitions(params); // WHEN ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(filter, variables, expressionFactory, prismContext, "evaluating filter with null value not allowed", task, result); // THEN display("Evaluated filter", evaluatedFilter); AssertJUnit.assertTrue("Expression should be evaluated to "+expectedType+", but was "+evaluatedFilter, expectedType.isAssignableFrom(evaluatedFilter.getClass())); return evaluatedFilter; }
.targetSelector(new ObjectSelectorType(prismContext) .type(RoleType.COMPLEX_TYPE) .filter(prismContext.getQueryConverter().createSearchFilterType(studentFilter))) .beginPolicyConstraints() .beginHasAssignment()