Examples with PrismValue com.evolveum.midpoint.prism.PrismValue used on opensource projects

Example 21 with PrismValue

use of com.evolveum.midpoint.prism.PrismValue in project midpoint by Evolveum.

the class GeneralNotifier method appendModifications.

protected void appendModifications(StringBuilder body, ObjectDelta<? extends ObjectType> delta, List<ItemPath> hiddenPaths, Boolean showValuesBoolean) {
    boolean showValues = !Boolean.FALSE.equals(showValuesBoolean);
    for (ItemDelta<?, ?> itemDelta : delta.getModifications()) {
        if (NotificationFunctionsImpl.isAmongHiddenPaths(itemDelta.getPath(), hiddenPaths)) {
            continue;
        }
        body.append(" - ");
        body.append(formatPath(itemDelta));
        if (showValues) {
            body.append(":\n");
            if (itemDelta.isAdd()) {
                for (PrismValue prismValue : itemDelta.getValuesToAdd()) {
                    body.append(" --- ADD: ");
                    body.append(prismValue.debugDump(2));
                    body.append("\n");
                }
            }
            if (itemDelta.isDelete()) {
                for (PrismValue prismValue : itemDelta.getValuesToDelete()) {
                    body.append(" --- DELETE: ");
                    body.append(prismValue.debugDump(2));
                    body.append("\n");
                }
            }
            if (itemDelta.isReplace()) {
                for (PrismValue prismValue : itemDelta.getValuesToReplace()) {
                    body.append(" --- REPLACE: ");
                    body.append(prismValue.debugDump(2));
                    body.append("\n");
                }
            }
        } else {
            body.append("\n");
        }
    }
}

Example 22 with PrismValue

use of com.evolveum.midpoint.prism.PrismValue in project midpoint by Evolveum.

the class PrismValueDeltaSetTriple method checkConsistence.

public void checkConsistence() {
    Visitor visitor = visitable -> {
        if (visitable instanceof PrismValue) {
            if (((PrismValue) visitable).isEmpty()) {
                throw new IllegalStateException("Empty value " + visitable + " in triple " + PrismValueDeltaSetTriple.this);
            }
        }
    };
    accept(visitor);
    Processor<V> processor = pval -> {
        if (pval.getParent() != null) {
            throw new IllegalStateException("Value " + pval + " in triple " + PrismValueDeltaSetTriple.this + " has parent, looks like it was not cloned properly");
        }
    };
    foreach(processor);
}

Example 23 with PrismValue

use of com.evolveum.midpoint.prism.PrismValue in project midpoint by Evolveum.

the class WrapperTestUtil method assertPropertyWrapperValues.

public static <C extends Containerable, T> void assertPropertyWrapperValues(String desc, List<ValueWrapper> valueWrappers, T... expectedValues) {
    if (expectedValues == null) {
        expectedValues = (T[]) new Object[] { null };
    }
    assertEquals("Wrong number of values in " + desc + "; was: " + valueWrappers + ", expected: " + Arrays.toString(expectedValues), expectedValues.length, valueWrappers.size());
    if (expectedValues.length == 0) {
        return;
    }
    for (ValueWrapper vw : valueWrappers) {
        PrismValue actualPval = vw.getValue();
        if (actualPval instanceof PrismPropertyValue<?>) {
            T actualValue = ((PrismPropertyValue<T>) actualPval).getValue();
            boolean found = false;
            for (T expectedValue : expectedValues) {
                if (MiscUtil.equals(expectedValue, actualValue)) {
                    found = true;
                }
            }
            if (!found) {
                AssertJUnit.fail("Unexpected value " + actualValue + " in value wrapper in " + desc + "; was: " + valueWrappers + ", expected: " + Arrays.toString(expectedValues));
            }
        } else {
            AssertJUnit.fail("expected PrismPropertyValue in value wrapper in " + desc + ", but got " + actualPval.getClass());
        }
    }
}

Example 24 with PrismValue

use of com.evolveum.midpoint.prism.PrismValue in project midpoint by Evolveum.

the class AbstractValueTransformationExpressionEvaluator method evaluateRelativeExpression.

private PrismValueDeltaSetTriple<V> evaluateRelativeExpression(final List<SourceTriple<?, ?>> sourceTriples, final ExpressionVariables variables, final boolean skipEvaluationMinus, final boolean skipEvaluationPlus, final Boolean includeNulls, final ExpressionEvaluationContext evaluationContext, final String contextDescription, final Task task, final OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException {
    List<Collection<? extends PrismValue>> valueCollections = new ArrayList<>(sourceTriples.size());
    for (SourceTriple<?, ?> sourceTriple : sourceTriples) {
        Collection<? extends PrismValue> values = sourceTriple.union();
        if (values.isEmpty()) {
            // No values for this source. Add null instead. It will make sure that the expression will
            // be evaluate at least once.
            values.add(null);
        }
        valueCollections.add(values);
    }
    final PrismValueDeltaSetTriple<V> outputTriple = new PrismValueDeltaSetTriple<>();
    Processor<Collection<? extends PrismValue>> processor = pvalues -> {
        if (includeNulls != null && !includeNulls && MiscUtil.isAllNull(pvalues)) {
            return;
        }
        Map<QName, Object> sourceVariables = new HashMap<>();
        Iterator<SourceTriple<PrismValue, ?>> sourceTriplesIterator = (Iterator) sourceTriples.iterator();
        boolean hasMinus = false;
        boolean hasZero = false;
        boolean hasPlus = false;
        for (PrismValue pval : pvalues) {
            SourceTriple<PrismValue, ?> sourceTriple = sourceTriplesIterator.next();
            QName name = sourceTriple.getName();
            sourceVariables.put(name, getRealContent(pval, sourceTriple.getResidualPath()));
            if (sourceTriple.presentInPlusSet(pval)) {
                hasPlus = true;
            } else if (sourceTriple.presentInZeroSet(pval)) {
                hasZero = true;
            } else if (sourceTriple.presentInMinusSet(pval)) {
                hasMinus = true;
            }
        }
        if (!hasPlus && !hasMinus && !hasZero && !MiscUtil.isAllNull(pvalues)) {
            throw new IllegalStateException("Internal error! The impossible has happened! pvalues=" + pvalues + "; source triples: " + sourceTriples + "; in " + contextDescription);
        }
        if (hasPlus && hasMinus) {
            return;
        }
        if (hasPlus && skipEvaluationPlus) {
            return;
        } else if (hasMinus && skipEvaluationMinus) {
            return;
        }
        ExpressionVariables scriptVariables = new ExpressionVariables();
        scriptVariables.addVariableDefinitions(sourceVariables);
        PlusMinusZero valueDestination = null;
        boolean useNew = false;
        if (hasPlus) {
            scriptVariables.addVariableDefinitionsNew(variables);
            valueDestination = PlusMinusZero.PLUS;
            useNew = true;
        } else if (hasMinus) {
            scriptVariables.addVariableDefinitionsOld(variables);
            valueDestination = PlusMinusZero.MINUS;
        } else {
            scriptVariables.addVariableDefinitionsNew(variables);
            valueDestination = PlusMinusZero.ZERO;
            useNew = true;
        }
        List<V> scriptResults;
        try {
            scriptResults = transformSingleValue(scriptVariables, valueDestination, useNew, evaluationContext, contextDescription, task, result);
        } catch (ExpressionEvaluationException e) {
            throw new TunnelException(new ExpressionEvaluationException(e.getMessage() + "(" + dumpSourceValues(sourceVariables) + ") in " + contextDescription, e));
        } catch (ObjectNotFoundException e) {
            throw new TunnelException(new ObjectNotFoundException(e.getMessage() + "(" + dumpSourceValues(sourceVariables) + ") in " + contextDescription, e));
        } catch (SchemaException e) {
            throw new TunnelException(new SchemaException(e.getMessage() + "(" + dumpSourceValues(sourceVariables) + ") in " + contextDescription, e));
        } catch (RuntimeException e) {
            throw new TunnelException(new RuntimeException(e.getMessage() + "(" + dumpSourceValues(sourceVariables) + ") in " + contextDescription, e));
        }
        outputTriple.addAllToSet(valueDestination, scriptResults);
    };
    try {
        MiscUtil.carthesian((Collection) valueCollections, (Processor) processor);
    } catch (TunnelException e) {
        Throwable originalException = e.getCause();
        if (originalException instanceof ExpressionEvaluationException) {
            throw (ExpressionEvaluationException) originalException;
        } else if (originalException instanceof ObjectNotFoundException) {
            throw (ObjectNotFoundException) originalException;
        } else if (originalException instanceof SchemaException) {
            throw (SchemaException) originalException;
        } else if (originalException instanceof RuntimeException) {
            throw (RuntimeException) originalException;
        } else {
            throw new IllegalStateException("Unexpected exception: " + e + ": " + e.getMessage(), e);
        }
    }
    cleanupTriple(outputTriple);
    return outputTriple;
}

Example 25 with PrismValue

use of com.evolveum.midpoint.prism.PrismValue in project midpoint by Evolveum.

the class ObjectMerger method mergeItem.

private <O extends ObjectType, I extends Item> ItemDelta mergeItem(PrismObject<O> objectLeft, PrismObject<O> objectRight, String mergeConfigurationName, ItemMergeConfigurationType itemMergeConfig, ItemPath itemPath, Task task, OperationResult result) throws SchemaException, ConfigurationException, ExpressionEvaluationException, ObjectNotFoundException {
    I itemLeft = (I) objectLeft.findItem(itemPath);
    I itemRight = (I) objectRight.findItem(itemPath);
    if (itemLeft == null && itemRight == null) {
        return null;
    }
    ItemDefinition itemDefinition = null;
    if (itemLeft != null) {
        itemDefinition = itemLeft.getDefinition();
    } else {
        itemDefinition = itemRight.getDefinition();
    }
    if (itemDefinition.isOperational()) {
        // we do not want to modify them explicitly.
        return null;
    }
    Expression<PrismValue, ItemDefinition> valueExpression = null;
    if (itemMergeConfig.getValueExpression() != null) {
        ExpressionType expressionType = itemMergeConfig.getValueExpression();
        valueExpression = expressionFactory.makeExpression(expressionType, itemDefinition, "value expression for item " + itemPath + " in merge configuration " + mergeConfigurationName, task, result);
    }
    ItemDelta itemDelta = itemDefinition.createEmptyDelta(itemPath);
    MergeStategyType leftStrategy = itemMergeConfig.getLeft();
    MergeStategyType rightStrategy = itemMergeConfig.getRight();
    if (leftStrategy == null || leftStrategy == MergeStategyType.IGNORE) {
        if (rightStrategy == null || rightStrategy == MergeStategyType.IGNORE) {
            // IGNORE both
            if (itemLeft == null) {
                return null;
            } else {
                itemDelta.setValueToReplace();
                return itemDelta;
            }
        } else {
            // IGNORE left, TAKE/EXPRESSION right
            if (itemRight == null) {
                itemDelta.setValueToReplace();
            } else {
                Collection<PrismValue> valuesToTake = getValuesToTake(objectLeft, objectRight, SIDE_RIGHT, itemRight, rightStrategy, valueExpression, task, result);
                itemDelta.setValuesToReplace(valuesToTake);
            }
            return itemDelta;
        }
    } else {
        if (rightStrategy == null || rightStrategy == MergeStategyType.IGNORE) {
            if (leftStrategy == MergeStategyType.TAKE) {
                // TAKE left, IGNORE right
                return null;
            } else {
                // EXPRESSION left, IGNORE right
                Collection<PrismValue> valuesToLeave = getValuesToTake(objectLeft, objectRight, SIDE_LEFT, itemLeft, leftStrategy, valueExpression, task, result);
                List<PrismValue> currentLeftValues = itemLeft.getValues();
                Collection<PrismValue> leftValuesToRemove = diffValues(currentLeftValues, valuesToLeave);
                if (leftValuesToRemove != null && !leftValuesToRemove.isEmpty()) {
                    itemDelta.addValuesToDelete(leftValuesToRemove);
                    return itemDelta;
                } else {
                    return null;
                }
            }
        } else {
            // TAKE/EXPRESSION left, TAKE/EXPRESSION right
            if (itemLeft == null) {
                Collection<PrismValue> valuesToTake = getValuesToTake(objectLeft, objectRight, SIDE_RIGHT, itemRight, rightStrategy, valueExpression, task, result);
                itemDelta.addValuesToAdd(valuesToTake);
                return itemDelta;
            } else {
                // We want to add only those values that are not yet there.
                // E.g. adding assignments that are there can cause unnecessary churn
                Collection<PrismValue> leftValuesToLeave = getValuesToTake(objectLeft, objectRight, SIDE_LEFT, itemLeft, leftStrategy, valueExpression, task, result);
                Collection<PrismValue> rightValuesToTake = getValuesToTake(objectLeft, objectRight, SIDE_RIGHT, itemRight, rightStrategy, valueExpression, task, result);
                for (PrismValue rightValueToTake : rightValuesToTake) {
                    if (!PrismValue.collectionContainsEquivalentValue(leftValuesToLeave, rightValueToTake)) {
                        itemDelta.addValueToAdd(rightValueToTake);
                    }
                }
                List<PrismValue> currentLeftValues = itemLeft.getValues();
                Collection<PrismValue> leftValuesToRemove = diffValues(currentLeftValues, leftValuesToLeave);
                if (leftValuesToRemove != null && !leftValuesToRemove.isEmpty()) {
                    itemDelta.addValuesToDelete(leftValuesToRemove);
                }
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace("Merging item {} T/T case:\n  leftValuesToLeave: {}\n  rightValuesToTake: {}\n  leftValuesToRemove: {}\n itemDelta:\n{}", new Object[] { itemPath, leftValuesToLeave, rightValuesToTake, leftValuesToRemove, itemDelta.debugDump(2) });
                }
                return itemDelta;
            }
        }
    }
}