private QueryConverter getQueryConverter() { return prismContext.getQueryConverter(); } //endregion
public QueryConverter getQueryConverter() { return prismContext.getQueryConverter(); } }
protected QueryConverter getQueryConverter() { return prismContext.getQueryConverter(); }
public QueryConverter getQueryConverter() { return getPrismContext().getQueryConverter(); } }
private QueryConverter getQueryConverter() { return prismContext.getQueryConverter(); }
@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; } }
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; }
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); } }
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); }
private QueryConverter getQueryConverter() { return getPrismContext().getQueryConverter(); }
private ObjectQuery toObjectQuery(Class type, SearchFilterType filterType) throws Exception { ObjectQuery query = getPrismContext().getQueryConverter().createObjectQuery(type, filterType ); return query; }
private ObjectQuery toObjectQuery(Class type, QueryType queryType) throws Exception { ObjectQuery query = getPrismContext().getQueryConverter().createObjectQuery(type, queryType ); return query; }
private QueryType toQueryType(ObjectQuery query) throws Exception { return getPrismContext().getQueryConverter().createQueryType(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; } }
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; }
ObjectFilter objectFilter = prismContext.getQueryConverter().parseFilter(filter, targetClass); virtualAssignmenetSpecification.setFilter(objectFilter);
static boolean oidMatches(ObjectReferenceType targetRef, EvaluatedAssignmentTargetImpl assignmentTarget, PrismContext prismContext, MatchingRuleRegistry matchingRuleRegistry, String context) throws SchemaException { if (targetRef == null) { return true; // this means we rely on comparing relations } if (assignmentTarget.getOid() == null) { return false; // shouldn't occur } if (targetRef.getOid() != null) { return assignmentTarget.getOid().equals(targetRef.getOid()); } if (targetRef.getResolutionTime() == EvaluationTimeType.RUN) { SearchFilterType filterType = targetRef.getFilter(); if (filterType == null) { throw new SchemaException("No filter in " + context); } QName typeQName = targetRef.getType(); @SuppressWarnings("rawtypes") PrismObjectDefinition objDef = prismContext.getSchemaRegistry().findObjectDefinitionByType(typeQName); ObjectFilter filter = prismContext.getQueryConverter().parseFilter(filterType, objDef); PrismObject<? extends AssignmentHolderType> target = assignmentTarget.getTarget(); return filter.match(target.getValue(), matchingRuleRegistry); } else { throw new SchemaException("No OID in " + context); } }
@NotNull private <O extends ObjectType> List<PrismObject<O>> resolveTargetsFromFilter(Class<O> targetClass, SearchFilterType filter, AssignmentPathSegmentImpl segment, EvaluationContext ctx) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException{ ModelExpressionThreadLocalHolder.pushExpressionEnvironment(new ExpressionEnvironment<>(lensContext, null, ctx.task, ctx.result)); try { PrismObject<SystemConfigurationType> systemConfiguration = systemObjectCache.getSystemConfiguration(ctx.result); ExpressionVariables variables = ModelImplUtils.getDefaultExpressionVariables(segment.source, null, null, systemConfiguration.asObjectable()); variables.addVariableDefinition(ExpressionConstants.VAR_SOURCE, segment.getOrderOneObject()); AssignmentPathVariables assignmentPathVariables = LensUtil.computeAssignmentPathVariables(ctx.assignmentPath); if (assignmentPathVariables != null) { ModelImplUtils.addAssignmentPathVariables(assignmentPathVariables, variables); } variables.addVariableDefinitions(getAssignmentEvaluationVariables()); ObjectFilter origFilter = prismContext.getQueryConverter().parseFilter(filter, targetClass); ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(origFilter, variables, getMappingFactory().getExpressionFactory(), prismContext, " evaluating resource filter expression ", ctx.task, ctx.result); if (evaluatedFilter == null) { throw new SchemaException("The OID is null and filter could not be evaluated in assignment targetRef in "+segment.source); } return repository.searchObjects(targetClass, prismContext.queryFactory().createQuery(evaluatedFilter), null, ctx.result); // we don't check for no targets here; as we don't care for referential integrity } finally { ModelExpressionThreadLocalHolder.popExpressionEnvironment(); } }
private UserType searchUserByName(String name) throws Exception { // Document doc = DOMUtil.getDocument(); // Element nameElement = doc.createElementNS(SchemaConstants.C_NAME.getNamespaceURI(), // SchemaConstants.C_NAME.getLocalPart()); // nameElement.setTextContent(name); // Element filter = QueryUtil.createEqualFilter(doc, null, nameElement); // // QueryType query = new QueryType(); // query.setFilter(filter); ObjectQuery q = ObjectQueryUtil.createNameQuery(UserType.class, prismContext, name); QueryType query = prismContext.getQueryConverter().createQueryType(q); OperationResultType resultType = new OperationResultType(); Holder<OperationResultType> resultHolder = new Holder<>(resultType); Holder<ObjectListType> listHolder = new Holder<>(); assertNoRepoCache(); modelWeb.searchObjects(ObjectTypes.USER.getTypeQName(), query, null, listHolder, resultHolder); assertNoRepoCache(); ObjectListType objects = listHolder.value; TestUtil.assertSuccess("searchObjects has failed", resultHolder.value); AssertJUnit.assertEquals("User not found (or found too many)", 1, objects.getObject().size()); UserType user = (UserType) objects.getObject().get(0); AssertJUnit.assertEquals(user.getName(), PrismTestUtil.createPolyStringType(name)); return user; }
@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); }