Examples with ExpressionEvaluationException com.evolveum.midpoint.util.exception.ExpressionEvaluationException used on opensource projects

Example 71 with ExpressionEvaluationException

use of com.evolveum.midpoint.util.exception.ExpressionEvaluationException in project midpoint by Evolveum.

the class ExpressionUtil method createFilterForNoValue.

private static ObjectFilter createFilterForNoValue(ObjectFilter filter, ExpressionType valueExpression) throws ExpressionEvaluationException {
    QueryInterpretationOfNoValueType queryInterpretationOfNoValue = valueExpression.getQueryInterpretationOfNoValue();
    if (queryInterpretationOfNoValue == null) {
        queryInterpretationOfNoValue = QueryInterpretationOfNoValueType.FILTER_EQUAL_NULL;
    }
    switch(queryInterpretationOfNoValue) {
        case FILTER_UNDEFINED:
            return UndefinedFilter.createUndefined();
        case FILTER_NONE:
            return NoneFilter.createNone();
        case FILTER_ALL:
            return AllFilter.createAll();
        case FILTER_EQUAL_NULL:
            if (filter instanceof ValueFilter) {
                ValueFilter evaluatedFilter = (ValueFilter) filter.clone();
                evaluatedFilter.setExpression(null);
                return evaluatedFilter;
            } else if (filter instanceof InOidFilter) {
                return NoneFilter.createNone();
            } else if (filter instanceof FullTextFilter) {
                // because full text search for 'no value' is meaningless
                return NoneFilter.createNone();
            } else {
                throw new IllegalArgumentException("Unknown filter to evaluate: " + filter);
            }
        case ERROR:
            throw new ExpressionEvaluationException("Expression " + valueExpression + " evaluated to no value");
        default:
            throw new IllegalArgumentException("Unknown value " + queryInterpretationOfNoValue + " in queryInterpretationOfNoValue in " + valueExpression);
    }
}

Example 72 with ExpressionEvaluationException

use of com.evolveum.midpoint.util.exception.ExpressionEvaluationException in project midpoint by Evolveum.

the class ExpressionUtil method evaluateFilterExpressionsInternal.

private static ObjectFilter evaluateFilterExpressionsInternal(ObjectFilter filter, ExpressionVariables variables, ExpressionFactory expressionFactory, PrismContext prismContext, String shortDesc, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException {
    if (filter == null) {
        return null;
    }
    if (filter instanceof InOidFilter) {
        ExpressionWrapper expressionWrapper = ((InOidFilter) filter).getExpression();
        if (expressionWrapper == null || expressionWrapper.getExpression() == null) {
            LOGGER.warn("No valueExpression in filter in {}. Returning original filter", shortDesc);
            InOidFilter inOidFilter = (InOidFilter) filter;
            if (inOidFilter.getOids() != null && !inOidFilter.getOids().isEmpty()) {
                return filter.clone();
            }
            return NoneFilter.createNone();
        }
        ExpressionType valueExpression = getExpression(expressionWrapper, shortDesc);
        try {
            Collection<String> expressionResult = evaluateStringExpression(variables, prismContext, valueExpression, expressionFactory, shortDesc, task, result);
            if (expressionResult == null || expressionResult.isEmpty()) {
                LOGGER.debug("Result of search filter expression was null or empty. Expression: {}", valueExpression);
                return createFilterForNoValue(filter, valueExpression);
            }
            // TODO: log more context
            LOGGER.trace("Search filter expression in the rule for {} evaluated to {}.", new Object[] { shortDesc, expressionResult });
            InOidFilter evaluatedFilter = (InOidFilter) filter.clone();
            evaluatedFilter.setOids(expressionResult);
            evaluatedFilter.setExpression(null);
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("Transformed filter to:\n{}", evaluatedFilter.debugDump());
            }
            return evaluatedFilter;
        } catch (Exception ex) {
            throw new ExpressionEvaluationException(ex);
        }
    } else if (filter instanceof FullTextFilter) {
        ExpressionWrapper expressionWrapper = ((FullTextFilter) filter).getExpression();
        if (expressionMissing(expressionWrapper, shortDesc)) {
            return filter.clone();
        }
        ExpressionType valueExpression = getExpression(expressionWrapper, shortDesc);
        try {
            Collection<String> expressionResult = evaluateStringExpression(variables, prismContext, valueExpression, expressionFactory, shortDesc, task, result);
            if (expressionResult == null || expressionResult.isEmpty()) {
                LOGGER.debug("Result of search filter expression was null or empty. Expression: {}", valueExpression);
                return createFilterForNoValue(filter, valueExpression);
            }
            // TODO: log more context
            LOGGER.trace("Search filter expression in the rule for {} evaluated to {}.", shortDesc, expressionResult);
            FullTextFilter evaluatedFilter = (FullTextFilter) filter.clone();
            evaluatedFilter.setValues(expressionResult);
            evaluatedFilter.setExpression(null);
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("Transformed filter to:\n{}", evaluatedFilter.debugDump());
            }
            return evaluatedFilter;
        } catch (Exception ex) {
            throw new ExpressionEvaluationException(ex);
        }
    } else if (filter instanceof LogicalFilter) {
        List<ObjectFilter> conditions = ((LogicalFilter) filter).getConditions();
        LogicalFilter evaluatedFilter = ((LogicalFilter) filter).cloneEmpty();
        for (ObjectFilter condition : conditions) {
            ObjectFilter evaluatedSubFilter = evaluateFilterExpressionsInternal(condition, variables, expressionFactory, prismContext, shortDesc, task, result);
            evaluatedFilter.addCondition(evaluatedSubFilter);
        }
        return evaluatedFilter;
    } else if (filter instanceof ValueFilter) {
        ValueFilter valueFilter = (ValueFilter) filter;
        if (valueFilter.getValues() != null && !valueFilter.getValues().isEmpty()) {
            // We have value. Nothing to evaluate.
            return valueFilter.clone();
        }
        ExpressionWrapper expressionWrapper = valueFilter.getExpression();
        if (expressionMissing(expressionWrapper, shortDesc)) {
            return valueFilter.clone();
        }
        ExpressionType valueExpression = getExpression(expressionWrapper, shortDesc);
        try {
            PrismValue expressionResult = evaluateExpression(variables, prismContext, valueExpression, filter, expressionFactory, shortDesc, task, result);
            if (expressionResult == null || expressionResult.isEmpty()) {
                LOGGER.debug("Result of search filter expression was null or empty. Expression: {}", valueExpression);
                return createFilterForNoValue(valueFilter, valueExpression);
            }
            // TODO: log more context
            LOGGER.trace("Search filter expression in the rule for {} evaluated to {}.", new Object[] { shortDesc, expressionResult });
            ValueFilter evaluatedFilter = valueFilter.clone();
            evaluatedFilter.setValue(expressionResult);
            evaluatedFilter.setExpression(null);
            // }
            if (LOGGER.isTraceEnabled()) {
                LOGGER.trace("Transformed filter to:\n{}", evaluatedFilter.debugDump());
            }
            return evaluatedFilter;
        } catch (RuntimeException ex) {
            LoggingUtils.logException(LOGGER, "Couldn't evaluate expression " + valueExpression + ".", ex);
            throw new SystemException("Couldn't evaluate expression" + valueExpression + ": " + ex.getMessage(), ex);
        } catch (SchemaException ex) {
            LoggingUtils.logException(LOGGER, "Couldn't evaluate expression " + valueExpression + ".", ex);
            throw new SchemaException("Couldn't evaluate expression" + valueExpression + ": " + ex.getMessage(), ex);
        } catch (ObjectNotFoundException ex) {
            LoggingUtils.logException(LOGGER, "Couldn't evaluate expression " + valueExpression + ".", ex);
            throw new ObjectNotFoundException("Couldn't evaluate expression" + valueExpression + ": " + ex.getMessage(), ex);
        } catch (ExpressionEvaluationException ex) {
            LoggingUtils.logException(LOGGER, "Couldn't evaluate expression " + valueExpression + ".", ex);
            throw new ExpressionEvaluationException("Couldn't evaluate expression" + valueExpression + ": " + ex.getMessage(), ex);
        }
    } else if (filter instanceof ExistsFilter) {
        ExistsFilter evaluatedFilter = ((ExistsFilter) filter).cloneEmpty();
        ObjectFilter evaluatedSubFilter = evaluateFilterExpressionsInternal(((ExistsFilter) filter).getFilter(), variables, expressionFactory, prismContext, shortDesc, task, result);
        evaluatedFilter.setFilter(evaluatedSubFilter);
        return evaluatedFilter;
    } else if (filter instanceof TypeFilter) {
        TypeFilter evaluatedFilter = ((TypeFilter) filter).cloneEmpty();
        ObjectFilter evaluatedSubFilter = evaluateFilterExpressionsInternal(((TypeFilter) filter).getFilter(), variables, expressionFactory, prismContext, shortDesc, task, result);
        evaluatedFilter.setFilter(evaluatedSubFilter);
        return evaluatedFilter;
    } else if (filter instanceof OrgFilter) {
        return filter;
    } else if (filter instanceof AllFilter || filter instanceof NoneFilter || filter instanceof UndefinedFilter) {
        return filter;
    } else {
        throw new IllegalStateException("Unsupported filter type: " + filter.getClass());
    }
}

Example 73 with ExpressionEvaluationException

use of com.evolveum.midpoint.util.exception.ExpressionEvaluationException in project midpoint by Evolveum.

the class AbstractLdapHierarchyTest method reconcileAllUsers.

protected void reconcileAllUsers() throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    final Task task = createTask("reconcileAllUsers");
    OperationResult result = task.getResult();
    ResultHandler<UserType> handler = new ResultHandler<UserType>() {

        @Override
        public boolean handle(PrismObject<UserType> object, OperationResult parentResult) {
            try {
                display("reconciling " + object);
                reconcileUser(object.getOid(), task, parentResult);
            } catch (SchemaException | PolicyViolationException | ExpressionEvaluationException | ObjectNotFoundException | ObjectAlreadyExistsException | CommunicationException | ConfigurationException | SecurityViolationException e) {
                throw new SystemException(e.getMessage(), e);
            }
            return true;
        }
    };
    display("Reconciling all users");
    modelService.searchObjectsIterative(UserType.class, null, handler, null, task, result);
}

Example 74 with ExpressionEvaluationException

use of com.evolveum.midpoint.util.exception.ExpressionEvaluationException in project midpoint by Evolveum.

the class Construction method resolveTarget.

private ResourceType resolveTarget(String sourceDescription, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, SecurityViolationException {
    // SearchFilterType filter = targetRef.getFilter();
    ExpressionVariables variables = Utils.getDefaultExpressionVariables(getFocusOdo().getNewObject().asObjectable(), null, null, null);
    if (assignmentPathVariables == null) {
        assignmentPathVariables = LensUtil.computeAssignmentPathVariables(getAssignmentPath());
    }
    Utils.addAssignmentPathVariables(assignmentPathVariables, variables);
    LOGGER.info("Expression variables for filter evaluation: {}", variables);
    ObjectFilter origFilter = QueryConvertor.parseFilter(getConstructionType().getResourceRef().getFilter(), ResourceType.class, getPrismContext());
    LOGGER.info("Orig filter {}", origFilter);
    ObjectFilter evaluatedFilter = ExpressionUtil.evaluateFilterExpressions(origFilter, variables, getMappingFactory().getExpressionFactory(), getPrismContext(), " evaluating resource filter expression ", task, result);
    LOGGER.info("evaluatedFilter filter {}", evaluatedFilter);
    if (evaluatedFilter == null) {
        throw new SchemaException("The OID is null and filter could not be evaluated in assignment targetRef in " + getSource());
    }
    final Collection<PrismObject<ResourceType>> results = new ArrayList<>();
    ResultHandler<ResourceType> handler = (object, parentResult) -> {
        LOGGER.info("Found object {}", object);
        return results.add(object);
    };
    getObjectResolver().searchIterative(ResourceType.class, ObjectQuery.createObjectQuery(evaluatedFilter), null, handler, task, result);
    if (org.apache.commons.collections.CollectionUtils.isEmpty(results)) {
        throw new IllegalArgumentException("Got no target from repository, filter:" + evaluatedFilter + ", class:" + ResourceType.class + " in " + sourceDescription);
    }
    if (results.size() > 1) {
        throw new IllegalArgumentException("Got more than one target from repository, filter:" + evaluatedFilter + ", class:" + ResourceType.class + " in " + sourceDescription);
    }
    PrismObject<ResourceType> target = results.iterator().next();
    // assignmentType.getTargetRef().setOid(target.getOid());
    return target.asObjectable();
}

Example 75 with ExpressionEvaluationException

use of com.evolveum.midpoint.util.exception.ExpressionEvaluationException in project midpoint by Evolveum.

the class Clockwork method click.

public <F extends ObjectType> HookOperationMode click(LensContext<F> context, Task task, OperationResult result) throws SchemaException, PolicyViolationException, ExpressionEvaluationException, ObjectNotFoundException, ObjectAlreadyExistsException, CommunicationException, ConfigurationException, SecurityViolationException {
    if (context.getDebugListener() == null) {
        context.setDebugListener(debugListener);
    }
    try {
        XMLGregorianCalendar now = clock.currentTimeXMLGregorianCalendar();
        // We need to determine focus before auditing. Otherwise we will not know user
        // for the accounts (unless there is a specific delta for it).
        // This is ugly, but it is the easiest way now (TODO: cleanup).
        contextLoader.determineFocusContext((LensContext<? extends FocusType>) context, result);
        ModelState state = context.getState();
        if (state == ModelState.INITIAL) {
            if (debugListener != null) {
                debugListener.beforeSync(context);
            }
            metadataManager.applyRequestMetadata(context, now, task, result);
            context.getStats().setRequestTimestamp(now);
            // We need to do this BEFORE projection. If we would do that after projection
            // there will be secondary changes that are not part of the request.
            audit(context, AuditEventStage.REQUEST, task, result);
        }
        boolean recompute = false;
        if (!context.isFresh()) {
            LOGGER.trace("Context is not fresh -- forcing cleanup and recomputation");
            recompute = true;
        } else if (context.getExecutionWave() > context.getProjectionWave()) {
            // should not occur
            LOGGER.warn("Execution wave is greater than projection wave -- forcing cleanup and recomputation");
            recompute = true;
        }
        if (recompute) {
            context.cleanup();
            projector.project(context, "PROJECTOR (" + state + ")", task, result);
        } else if (context.getExecutionWave() == context.getProjectionWave()) {
            LOGGER.trace("Running projector for current execution wave");
            projector.resume(context, "PROJECTOR (" + state + ")", task, result);
        } else {
            LOGGER.trace("Skipping projection because the context is fresh and projection for current wave has already run");
        }
        if (!context.isRequestAuthorized()) {
            authorizeContextRequest(context, task, result);
        }
        LensUtil.traceContext(LOGGER, "CLOCKWORK (" + state + ")", "before processing", true, context, false);
        if (InternalsConfig.consistencyChecks) {
            try {
                context.checkConsistence();
            } catch (IllegalStateException e) {
                throw new IllegalStateException(e.getMessage() + " in clockwork, state=" + state, e);
            }
        }
        if (InternalsConfig.encryptionChecks && !ModelExecuteOptions.isNoCrypt(context.getOptions())) {
            context.checkEncrypted();
        }
        switch(state) {
            case INITIAL:
                processInitialToPrimary(context, task, result);
                break;
            case PRIMARY:
                processPrimaryToSecondary(context, task, result);
                break;
            case SECONDARY:
                processSecondary(context, task, result);
                break;
            case FINAL:
                HookOperationMode mode = processFinal(context, task, result);
                if (debugListener != null) {
                    debugListener.afterSync(context);
                }
                return mode;
        }
        result.recomputeStatus();
        result.cleanupResult();
        return invokeHooks(context, task, result);
    } catch (CommunicationException | ConfigurationException | ExpressionEvaluationException | ObjectNotFoundException | PolicyViolationException | SchemaException | SecurityViolationException | RuntimeException | ObjectAlreadyExistsException e) {
        processClockworkException(context, e, task, result);
        throw e;
    }
}