Examples with MappingType com.evolveum.midpoint.xml.ns._public.common.common_3.MappingType used on opensource projects

Example 21 with MappingType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.MappingType in project midpoint by Evolveum.

the class MappingEvaluator method evaluateMappingSetProjection.

public <V extends PrismValue, D extends ItemDefinition, T extends ObjectType, F extends FocusType> void evaluateMappingSetProjection(MappingEvaluatorParams<V, D, T, F> params, Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException {
    String mappingDesc = params.getMappingDesc();
    LensElementContext<T> targetContext = params.getTargetContext();
    PrismObjectDefinition<T> targetObjectDefinition = targetContext.getObjectDefinition();
    ItemPath defaultTargetItemPath = params.getDefaultTargetItemPath();
    Map<ItemPath, MappingOutputStruct<V>> outputTripleMap = new HashMap<>();
    XMLGregorianCalendar nextRecomputeTime = null;
    Collection<MappingType> mappingTypes = params.getMappingTypes();
    Collection<Mapping<V, D>> mappings = new ArrayList<>(mappingTypes.size());
    for (MappingType mappingType : mappingTypes) {
        Mapping.Builder<V, D> mappingBuilder = mappingFactory.createMappingBuilder(mappingType, mappingDesc);
        String mappingName = null;
        if (mappingType.getName() != null) {
            mappingName = mappingType.getName();
        }
        if (!mappingBuilder.isApplicableToChannel(params.getContext().getChannel())) {
            LOGGER.trace("Mapping {} not applicable to channel, skipping {}", mappingName, params.getContext().getChannel());
            continue;
        }
        mappingBuilder.now(params.getNow());
        if (defaultTargetItemPath != null && targetObjectDefinition != null) {
            D defaultTargetItemDef = targetObjectDefinition.findItemDefinition(defaultTargetItemPath);
            mappingBuilder.defaultTargetDefinition(defaultTargetItemDef);
            mappingBuilder.defaultTargetPath(defaultTargetItemPath);
        } else {
            mappingBuilder.defaultTargetDefinition(params.getTargetItemDefinition());
            mappingBuilder.defaultTargetPath(defaultTargetItemPath);
        }
        mappingBuilder.targetContext(targetObjectDefinition);
        if (params.getSourceContext() != null) {
            mappingBuilder.sourceContext(params.getSourceContext());
        }
        // Initialize mapping (using Inversion of Control)
        mappingBuilder = params.getInitializer().initialize(mappingBuilder);
        Mapping<V, D> mapping = mappingBuilder.build();
        Boolean timeConstraintValid = mapping.evaluateTimeConstraintValid(task, result);
        if (params.getEvaluateCurrent() != null) {
            if (params.getEvaluateCurrent() && !timeConstraintValid) {
                LOGGER.trace("Mapping {} is non-current, but evulating current mappings, skipping {}", mappingName, params.getContext().getChannel());
                continue;
            }
            if (!params.getEvaluateCurrent() && timeConstraintValid) {
                LOGGER.trace("Mapping {} is current, but evulating non-current mappings, skipping {}", mappingName, params.getContext().getChannel());
                continue;
            }
        }
        mappings.add(mapping);
    }
    boolean hasFullTargetObject = params.hasFullTargetObject();
    PrismObject<T> aPrioriTargetObject = params.getAPrioriTargetObject();
    LOGGER.trace("Going to process {} mappings for {}", mappings.size(), mappingDesc);
    for (Mapping<V, D> mapping : mappings) {
        if (mapping.getStrength() == MappingStrengthType.WEAK) {
            // Evaluate weak mappings in a second run.
            continue;
        }
        ItemPath mappingOutputPath = mapping.getOutputPath();
        if (params.isFixTarget() && mappingOutputPath != null && defaultTargetItemPath != null && !mappingOutputPath.equivalent(defaultTargetItemPath)) {
            throw new ExpressionEvaluationException("Target cannot be overridden in " + mappingDesc);
        }
        if (params.getAPrioriTargetDelta() != null && mappingOutputPath != null) {
            ItemDelta<?, ?> aPrioriItemDelta = params.getAPrioriTargetDelta().findItemDelta(mappingOutputPath);
            if (mapping.getStrength() != MappingStrengthType.STRONG) {
                if (aPrioriItemDelta != null && !aPrioriItemDelta.isEmpty()) {
                    continue;
                }
            }
        }
        evaluateMapping(mapping, params.getContext(), task, result);
        PrismValueDeltaSetTriple<V> mappingOutputTriple = mapping.getOutputTriple();
        if (LOGGER.isTraceEnabled()) {
            LOGGER.trace("Output triple of mapping {}\n{}", mapping.getContextDescription(), mappingOutputTriple == null ? null : mappingOutputTriple.debugDump(1));
        }
        if (mappingOutputTriple != null) {
            MappingOutputStruct<V> mappingOutputStruct = outputTripleMap.get(mappingOutputPath);
            if (mappingOutputStruct == null) {
                mappingOutputStruct = new MappingOutputStruct<>();
                outputTripleMap.put(mappingOutputPath, mappingOutputStruct);
            }
            if (mapping.getStrength() == MappingStrengthType.STRONG) {
                mappingOutputStruct.setStrongMappingWasUsed(true);
            //                	if (!hasFullTargetObject && params.getTargetLoader() != null) {
            //    					if (!params.getTargetLoader().isLoaded()) {
            //    						aPrioriTargetObject = params.getTargetLoader().load(task, result);
            //    						LOGGER.trace("Loaded object because of strong mapping: {}", aPrioriTargetObject);
            //    						hasFullTargetObject = true;
            //    					}
            //    				}
            }
            PrismValueDeltaSetTriple<V> outputTriple = mappingOutputStruct.getOutputTriple();
            if (outputTriple == null) {
                mappingOutputStruct.setOutputTriple(mappingOutputTriple);
            } else {
                outputTriple.merge(mappingOutputTriple);
            }
        }
    }
    if (params.isEvaluateWeak()) {
        // Second pass, evaluate only weak mappings
        for (Mapping<V, D> mapping : mappings) {
            if (mapping.getStrength() != MappingStrengthType.WEAK) {
                continue;
            }
            ItemPath mappingOutputPath = mapping.getOutputPath();
            if (params.isFixTarget() && mappingOutputPath != null && defaultTargetItemPath != null && !mappingOutputPath.equivalent(defaultTargetItemPath)) {
                throw new ExpressionEvaluationException("Target cannot be overridden in " + mappingDesc);
            }
            MappingOutputStruct<V> mappingOutputStruct = outputTripleMap.get(mappingOutputPath);
            if (mappingOutputStruct == null) {
                mappingOutputStruct = new MappingOutputStruct<>();
                outputTripleMap.put(mappingOutputPath, mappingOutputStruct);
            }
            PrismValueDeltaSetTriple<V> outputTriple = mappingOutputStruct.getOutputTriple();
            if (outputTriple != null) {
                // MID-3847
                continue;
            }
            Item<V, D> aPrioriTargetItem = null;
            if (aPrioriTargetObject != null && mappingOutputPath != null) {
                aPrioriTargetItem = aPrioriTargetObject.findItem(mappingOutputPath);
            }
            if (hasNoValue(aPrioriTargetItem)) {
                mappingOutputStruct.setWeakMappingWasUsed(true);
                evaluateMapping(mapping, params.getContext(), task, result);
                PrismValueDeltaSetTriple<V> mappingOutputTriple = mapping.getOutputTriple();
                if (mappingOutputTriple != null) {
                    // This is all not right. See MID-3847
                    if (!hasFullTargetObject && params.getTargetLoader() != null) {
                        if (!params.getTargetLoader().isLoaded()) {
                            aPrioriTargetObject = params.getTargetLoader().load("weak mapping", task, result);
                            LOGGER.trace("Loaded object because of weak mapping: {}", aPrioriTargetObject);
                            hasFullTargetObject = true;
                        }
                    }
                    if (aPrioriTargetObject != null && mappingOutputPath != null) {
                        aPrioriTargetItem = aPrioriTargetObject.findItem(mappingOutputPath);
                    }
                    if (!hasNoValue(aPrioriTargetItem)) {
                        continue;
                    }
                    if (outputTriple == null) {
                        mappingOutputStruct.setOutputTriple(mappingOutputTriple);
                    } else {
                        outputTriple.merge(mappingOutputTriple);
                    }
                }
            }
        }
    }
    MappingOutputProcessor<V> processor = params.getProcessor();
    for (Entry<ItemPath, MappingOutputStruct<V>> outputTripleMapEntry : outputTripleMap.entrySet()) {
        ItemPath mappingOutputPath = outputTripleMapEntry.getKey();
        MappingOutputStruct<V> mappingOutputStruct = outputTripleMapEntry.getValue();
        PrismValueDeltaSetTriple<V> outputTriple = mappingOutputStruct.getOutputTriple();
        boolean defaultProcessing = true;
        if (processor != null) {
            LOGGER.trace("Executing processor to process mapping evaluation results: {}", processor);
            defaultProcessing = processor.process(mappingOutputPath, mappingOutputStruct);
        }
        if (defaultProcessing) {
            if (outputTriple == null) {
                LOGGER.trace("{} expression resulted in null triple for {}, skipping", mappingDesc, targetContext);
                continue;
            }
            ItemDefinition targetItemDefinition = null;
            if (mappingOutputPath != null) {
                targetItemDefinition = targetObjectDefinition.findItemDefinition(mappingOutputPath);
                if (targetItemDefinition == null) {
                    throw new SchemaException("No definition for item " + mappingOutputPath + " in " + targetObjectDefinition);
                }
            } else {
                targetItemDefinition = params.getTargetItemDefinition();
            }
            ItemDelta<V, D> targetItemDelta = targetItemDefinition.createEmptyDelta(mappingOutputPath);
            Item<V, D> aPrioriTargetItem = null;
            if (aPrioriTargetObject != null) {
                aPrioriTargetItem = aPrioriTargetObject.findItem(mappingOutputPath);
            }
            if (targetContext.isAdd()) {
                Collection<V> nonNegativeValues = outputTriple.getNonNegativeValues();
                if (nonNegativeValues == null || nonNegativeValues.isEmpty()) {
                    LOGGER.trace("{} resulted in null or empty value for {}, skipping", mappingDesc, targetContext);
                    continue;
                }
                targetItemDelta.setValuesToReplace(PrismValue.cloneCollection(nonNegativeValues));
            } else {
                // if we have fresh information (full shadow) AND the mapping used to derive the information was strong,
                // we will consider all values (zero & plus sets) -- otherwise, we take only the "plus" (i.e. changed) set
                // the first case is necessary, because in some situations (e.g. when mapping is changed)
                // the evaluator sees no differences w.r.t. real state, even if there is a difference
                // - and we must have a way to push new information onto the resource
                Collection<V> valuesToReplace;
                if (hasFullTargetObject && mappingOutputStruct.isStrongMappingWasUsed()) {
                    valuesToReplace = outputTriple.getNonNegativeValues();
                } else {
                    valuesToReplace = outputTriple.getPlusSet();
                }
                if (LOGGER.isTraceEnabled()) {
                    LOGGER.trace("{}: hasFullTargetObject={}, isStrongMappingWasUsed={}, valuesToReplace={}", new Object[] { mappingDesc, hasFullTargetObject, mappingOutputStruct.isStrongMappingWasUsed(), valuesToReplace });
                }
                if (valuesToReplace != null && !valuesToReplace.isEmpty()) {
                    if (hasFullTargetObject && targetContext.isFresh() && aPrioriTargetItem != null) {
                        Collection<V> valuesPresent = aPrioriTargetItem.getValues();
                        if (PrismValue.equalsRealValues(valuesPresent, valuesToReplace)) {
                            LOGGER.trace("{} resulted in existing values for {}, skipping creation of a delta", mappingDesc, targetContext);
                            continue;
                        }
                    }
                    targetItemDelta.setValuesToReplace(PrismValue.cloneCollection(valuesToReplace));
                } else if (outputTriple.hasMinusSet()) {
                    LOGGER.trace("{} resulted in null or empty value for {} and there is a minus set, resetting it (replace with empty)", mappingDesc, targetContext);
                    targetItemDelta.setValueToReplace();
                } else {
                    LOGGER.trace("{} resulted in null or empty value for {}, skipping", mappingDesc, targetContext);
                }
            }
            if (targetItemDelta.isEmpty()) {
                continue;
            }
            LOGGER.trace("{} adding new delta for {}: {}", mappingDesc, targetContext, targetItemDelta);
            targetContext.swallowToSecondaryDelta(targetItemDelta);
        }
    }
    for (Mapping<V, D> mapping : mappings) {
        XMLGregorianCalendar mappingNextRecomputeTime = mapping.getNextRecomputeTime();
        if (mappingNextRecomputeTime != null) {
            if (nextRecomputeTime == null || nextRecomputeTime.compare(mappingNextRecomputeTime) == DatatypeConstants.GREATER) {
                nextRecomputeTime = mappingNextRecomputeTime;
            }
        }
    }
    if (nextRecomputeTime != null) {
        boolean alreadyHasTrigger = false;
        if (params.getAPrioriTargetObject() != null) {
            for (TriggerType trigger : params.getAPrioriTargetObject().asObjectable().getTrigger()) {
                if (RecomputeTriggerHandler.HANDLER_URI.equals(trigger.getHandlerUri()) && nextRecomputeTime.equals(trigger.getTimestamp())) {
                    alreadyHasTrigger = true;
                    break;
                }
            }
        }
        if (!alreadyHasTrigger) {
            PrismContainerDefinition<TriggerType> triggerContDef = targetObjectDefinition.findContainerDefinition(ObjectType.F_TRIGGER);
            ContainerDelta<TriggerType> triggerDelta = triggerContDef.createEmptyDelta(new ItemPath(ObjectType.F_TRIGGER));
            PrismContainerValue<TriggerType> triggerCVal = triggerContDef.createValue();
            triggerDelta.addValueToAdd(triggerCVal);
            TriggerType triggerType = triggerCVal.asContainerable();
            triggerType.setTimestamp(nextRecomputeTime);
            triggerType.setHandlerUri(RecomputeTriggerHandler.HANDLER_URI);
            targetContext.swallowToSecondaryDelta(triggerDelta);
        }
    }
}

Example 22 with MappingType

use of com.evolveum.midpoint.xml.ns._public.common.common_3.MappingType in project midpoint by Evolveum.

the class MappingEvaluator method createFocusMapping.

public <V extends PrismValue, D extends ItemDefinition, F extends FocusType, T extends FocusType> Mapping<V, D> createFocusMapping(final MappingFactory mappingFactory, final LensContext<F> context, final MappingType mappingType, ObjectType originObject, ObjectDeltaObject<F> focusOdo, PrismObject<T> defaultTargetObject, AssignmentPathVariables assignmentPathVariables, Integer iteration, String iterationToken, PrismObject<SystemConfigurationType> configuration, XMLGregorianCalendar now, String contextDesc, final Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException {
    if (!Mapping.isApplicableToChannel(mappingType, context.getChannel())) {
        LOGGER.trace("Mapping {} not applicable to channel {}, skipping.", mappingType, context.getChannel());
        return null;
    }
    StringPolicyResolver stringPolicyResolver = new StringPolicyResolver() {

        private ItemPath outputPath;

        private ItemDefinition outputDefinition;

        @Override
        public void setOutputPath(ItemPath outputPath) {
            this.outputPath = outputPath;
        }

        @Override
        public void setOutputDefinition(ItemDefinition outputDefinition) {
            this.outputDefinition = outputDefinition;
        }

        @Override
        public StringPolicyType resolve() {
            // TODO need to switch to ObjectValuePolicyEvaluator
            if (outputDefinition.getName().equals(PasswordType.F_VALUE)) {
                ValuePolicyType passwordPolicy = credentialsProcessor.determinePasswordPolicy(context.getFocusContext(), task, result);
                if (passwordPolicy == null) {
                    return null;
                }
                return passwordPolicy.getStringPolicy();
            }
            if (mappingType.getExpression() != null) {
                List<JAXBElement<?>> evaluators = mappingType.getExpression().getExpressionEvaluator();
                if (evaluators != null) {
                    for (JAXBElement jaxbEvaluator : evaluators) {
                        Object object = jaxbEvaluator.getValue();
                        if (object instanceof GenerateExpressionEvaluatorType && ((GenerateExpressionEvaluatorType) object).getValuePolicyRef() != null) {
                            ObjectReferenceType ref = ((GenerateExpressionEvaluatorType) object).getValuePolicyRef();
                            try {
                                ValuePolicyType valuePolicyType = mappingFactory.getObjectResolver().resolve(ref, ValuePolicyType.class, null, "resolving value policy for generate attribute " + outputDefinition.getName() + " value", task, new OperationResult("Resolving value policy"));
                                if (valuePolicyType != null) {
                                    return valuePolicyType.getStringPolicy();
                                }
                            } catch (CommonException ex) {
                                throw new SystemException(ex.getMessage(), ex);
                            }
                        }
                    }
                }
            }
            return null;
        }
    };
    ExpressionVariables variables = new ExpressionVariables();
    FOCUS_VARIABLE_NAMES.forEach(name -> variables.addVariableDefinition(name, focusOdo));
    variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION, iteration);
    variables.addVariableDefinition(ExpressionConstants.VAR_ITERATION_TOKEN, iterationToken);
    variables.addVariableDefinition(ExpressionConstants.VAR_CONFIGURATION, configuration);
    Collection<V> targetValues = computeTargetValues(mappingType.getTarget(), defaultTargetObject, variables, mappingFactory.getObjectResolver(), contextDesc, task, result);
    Mapping.Builder<V, D> mappingBuilder = mappingFactory.<V, D>createMappingBuilder(mappingType, contextDesc).sourceContext(focusOdo).targetContext(defaultTargetObject.getDefinition()).variables(variables).originalTargetValues(targetValues).originType(OriginType.USER_POLICY).originObject(originObject).stringPolicyResolver(stringPolicyResolver).rootNode(focusOdo).now(now);
    mappingBuilder = LensUtil.addAssignmentPathVariables(mappingBuilder, assignmentPathVariables);
    Mapping<V, D> mapping = mappingBuilder.build();
    ItemPath itemPath = mapping.getOutputPath();
    if (itemPath == null) {
        // no output element, i.e. this is a "validation mapping"
        return mapping;
    }
    if (defaultTargetObject != null) {
        Item<V, D> existingTargetItem = (Item<V, D>) defaultTargetObject.findItem(itemPath);
        if (existingTargetItem != null && !existingTargetItem.isEmpty() && mapping.getStrength() == MappingStrengthType.WEAK) {
            LOGGER.trace("Mapping {} is weak and target already has a value {}, skipping.", mapping, existingTargetItem);
            return null;
        }
    }
    return mapping;
}