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

Example 36 with PrismPropertyValue

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

the class PersonaProcessor method processPersonaChangesFocus.

public <F extends FocusType> HookOperationMode processPersonaChangesFocus(LensContext<F> context, Task task, OperationResult result) throws ObjectAlreadyExistsException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException, PolicyViolationException {
    DeltaSetTriple<EvaluatedAssignmentImpl<F>> evaluatedAssignmentTriple = (DeltaSetTriple) context.getEvaluatedAssignmentTriple();
    if (evaluatedAssignmentTriple == null || evaluatedAssignmentTriple.isEmpty()) {
        return HookOperationMode.FOREGROUND;
    }
    DeltaSetTriple<PersonaKey> activePersonaKeyTriple = new DeltaSetTriple<>();
    ComplexConstructionConsumer<PersonaKey, PersonaConstruction<F>> consumer = new ComplexConstructionConsumer<PersonaKey, PersonaConstruction<F>>() {

        @Override
        public boolean before(PersonaKey key) {
            return true;
        }

        @Override
        public void onAssigned(PersonaKey key, String desc) {
            activePersonaKeyTriple.addToPlusSet(key);
        }

        @Override
        public void onUnchangedValid(PersonaKey key, String desc) {
            activePersonaKeyTriple.addToZeroSet(key);
        }

        @Override
        public void onUnchangedInvalid(PersonaKey key, String desc) {
        }

        @Override
        public void onUnassigned(PersonaKey key, String desc) {
            activePersonaKeyTriple.addToMinusSet(key);
        }

        @Override
        public void after(PersonaKey key, String desc, DeltaMapTriple<PersonaKey, ConstructionPack<PersonaConstruction<F>>> constructionMapTriple) {
        }
    };
    DeltaMapTriple<PersonaKey, ConstructionPack<PersonaConstruction<F>>> constructionMapTriple = constructionProcessor.processConstructions(context, evaluatedAssignmentTriple, evaluatedAssignment -> evaluatedAssignment.getPersonaConstructionTriple(), construction -> new PersonaKey(construction.getConstructionType()), consumer, task, result);
    LOGGER.trace("activePersonaKeyTriple:\n{}", activePersonaKeyTriple.debugDumpLazily());
    List<FocusType> existingPersonas = readExistingPersonas(context, task, result);
    LOGGER.trace("existingPersonas:\n{}", existingPersonas);
    for (PersonaKey key : activePersonaKeyTriple.getNonNegativeValues()) {
        FocusType existingPersona = findPersona(existingPersonas, key);
        LOGGER.trace("existingPersona: {}", existingPersona);
        // TODO: add ability to merge several constructions
        ConstructionPack<PersonaConstruction<F>> pack = constructionMapTriple.getPlusMap().get(key);
        if (pack == null) {
            pack = constructionMapTriple.getZeroMap().get(key);
        }
        Collection<PrismPropertyValue<PersonaConstruction<F>>> constructions = pack.getConstructions();
        if (constructions.isEmpty()) {
            continue;
        }
        if (constructions.size() > 1) {
            throw new UnsupportedOperationException("Merging of multiple persona constructions is not supported yet");
        }
        PersonaConstruction<F> construction = constructions.iterator().next().getValue();
        LOGGER.trace("construction:\n{}", construction.debugDumpLazily());
        if (existingPersona == null) {
            personaAdd(context, key, construction, task, result);
        } else {
            personaModify(context, key, construction, existingPersona.asPrismObject(), task, result);
        }
    }
    for (PersonaKey key : activePersonaKeyTriple.getMinusSet()) {
        FocusType existingPersona = findPersona(existingPersonas, key);
        if (existingPersona != null) {
            personaDelete(context, key, existingPersona, task, result);
        }
    }
    return HookOperationMode.FOREGROUND;
}

Example 37 with PrismPropertyValue

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

the class PrismAsserts method assertEqualsFilterValue.

public static <T> void assertEqualsFilterValue(EqualFilter filter, T value) {
    List<? extends PrismValue> values = filter.getValues();
    assertEquals("Wrong number of filter values", 1, values.size());
    assertEquals("Wrong filter value class", PrismPropertyValue.class, values.get(0).getClass());
    PrismPropertyValue val = (PrismPropertyValue) values.get(0);
    assertEquals("Wrong filter value", value, val.getValue());
}

Example 38 with PrismPropertyValue

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

the class PrismAsserts method assertPropertyValueDesc.

public static <T> void assertPropertyValueDesc(PrismProperty<T> property, MatchingRule<T> matchingRule, String contextDescrition, T... expectedPropValues) throws SchemaException {
    Collection<PrismPropertyValue<T>> pvals = property.getValues();
    QName propQName = property.getElementName();
    assert pvals != null && !pvals.isEmpty() : "Empty property " + propQName;
    assertSet("property " + propQName + (contextDescrition == null ? "" : " in " + contextDescrition), "value", matchingRule, pvals, expectedPropValues);
}

Example 39 with PrismPropertyValue

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

the class ProjectionCredentialsProcessor method processProjectionPasswordMapping.

private <F extends FocusType> void processProjectionPasswordMapping(LensContext<F> context, final LensProjectionContext projCtx, final ValuePolicyType passwordPolicy, XMLGregorianCalendar now, Task task, OperationResult result) throws ExpressionEvaluationException, ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException {
    LensFocusContext<F> focusContext = context.getFocusContext();
    PrismObject<F> userNew = focusContext.getObjectNew();
    if (userNew == null) {
        // This must be a user delete or something similar. No point in proceeding
        LOGGER.trace("userNew is null, skipping credentials processing");
        return;
    }
    PrismObjectDefinition<ShadowType> accountDefinition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(ShadowType.class);
    PrismPropertyDefinition<ProtectedStringType> projPasswordPropertyDefinition = accountDefinition.findPropertyDefinition(SchemaConstants.PATH_PASSWORD_VALUE);
    ResourceShadowDiscriminator rsd = projCtx.getResourceShadowDiscriminator();
    RefinedObjectClassDefinition refinedProjDef = projCtx.getStructuralObjectClassDefinition();
    if (refinedProjDef == null) {
        LOGGER.trace("No RefinedObjectClassDefinition, therefore also no password outbound definition, skipping credentials processing for projection {}", rsd);
        return;
    }
    List<MappingType> outboundMappingTypes = refinedProjDef.getPasswordOutbound();
    if (outboundMappingTypes == null || outboundMappingTypes.isEmpty()) {
        LOGGER.trace("No outbound password mapping for {}, skipping credentials processing", rsd);
        return;
    }
    // HACK
    if (!projCtx.isDoReconciliation() && !projCtx.isAdd() && !isActivated(outboundMappingTypes, focusContext.getDelta())) {
        LOGGER.trace("Outbound password mappings not activated for type {}, skipping credentials processing", rsd);
        return;
    }
    final ObjectDelta<ShadowType> projDelta = projCtx.getDelta();
    final PropertyDelta<ProtectedStringType> projPasswordDelta;
    if (projDelta != null && projDelta.getChangeType() == MODIFY) {
        projPasswordDelta = projDelta.findPropertyDelta(SchemaConstants.PATH_PASSWORD_VALUE);
    } else {
        projPasswordDelta = null;
    }
    checkExistingDeltaSanity(projCtx, projPasswordDelta);
    boolean evaluateWeak = getEvaluateWeak(projCtx);
    final ItemDeltaItem<PrismPropertyValue<PasswordType>, PrismPropertyDefinition<ProtectedStringType>> userPasswordIdi = focusContext.getObjectDeltaObject().findIdi(SchemaConstants.PATH_PASSWORD_VALUE);
    StringPolicyResolver stringPolicyResolver = new StringPolicyResolver() {

        @Override
        public void setOutputPath(ItemPath outputPath) {
        }

        @Override
        public void setOutputDefinition(ItemDefinition outputDefinition) {
        }

        @Override
        public StringPolicyType resolve() {
            if (passwordPolicy == null) {
                return null;
            }
            return passwordPolicy.getStringPolicy();
        }
    };
    MappingInitializer<PrismPropertyValue<ProtectedStringType>, PrismPropertyDefinition<ProtectedStringType>> initializer = (builder) -> {
        builder.defaultTargetDefinition(projPasswordPropertyDefinition);
        builder.defaultSource(new Source<>(userPasswordIdi, ExpressionConstants.VAR_INPUT));
        builder.stringPolicyResolver(stringPolicyResolver);
        return builder;
    };
    MappingOutputProcessor<PrismPropertyValue<ProtectedStringType>> processor = (mappingOutputPath, outputStruct) -> {
        PrismValueDeltaSetTriple<PrismPropertyValue<ProtectedStringType>> outputTriple = outputStruct.getOutputTriple();
        if (outputTriple == null) {
            LOGGER.trace("Credentials 'password' expression resulted in null output triple, skipping credentials processing for {}", rsd);
            return false;
        }
        boolean projectionIsNew = projDelta != null && (projDelta.getChangeType() == ChangeType.ADD || projCtx.getSynchronizationPolicyDecision() == SynchronizationPolicyDecision.ADD);
        Collection<PrismPropertyValue<ProtectedStringType>> newValues = outputTriple.getPlusSet();
        if (projectionIsNew) {
            newValues = outputTriple.getNonNegativeValues();
        } else {
            newValues = outputTriple.getPlusSet();
        }
        if (!canGetCleartext(newValues)) {
            ObjectDelta<ShadowType> projectionPrimaryDelta = projCtx.getPrimaryDelta();
            if (projectionPrimaryDelta != null) {
                PropertyDelta<ProtectedStringType> passwordPrimaryDelta = projectionPrimaryDelta.findPropertyDelta(SchemaConstants.PATH_PASSWORD_VALUE);
                if (passwordPrimaryDelta != null) {
                    // We have only hashed value coming from the mapping. There are not very useful
                    // for provisioning. But we have primary projection delta - and that is very likely
                    // to be better.
                    // Skip all password mappings in this case. Primary delta trumps everything. 
                    // No weak, normal or even strong mapping can change that.
                    // We need to disregard even strong mapping in this case. If we would heed the strong
                    // mapping then account initialization won't be possible.
                    LOGGER.trace("We have primary password delta in projection, skipping credentials processing");
                    return false;
                }
            }
        }
        return true;
    };
    mappingEvaluator.evaluateOutboundMapping(context, projCtx, outboundMappingTypes, SchemaConstants.PATH_PASSWORD_VALUE, SchemaConstants.PATH_PASSWORD_VALUE, initializer, processor, now, true, evaluateWeak, "password mapping", task, result);
}

Example 40 with PrismPropertyValue

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

the class ExpressionHelper method getSingleArgumentValue.

public <T> T getSingleArgumentValue(List<ActionParameterValueType> arguments, String parameterName, boolean required, boolean requiredNonNull, String context, PipelineData input, ExecutionContext executionContext, Class<T> clazz, OperationResult result) throws ScriptExecutionException {
    ActionParameterValueType paramValue = getArgument(arguments, parameterName, required, requiredNonNull, context);
    if (paramValue == null) {
        return null;
    }
    PipelineData paramData = evaluateParameter(paramValue, clazz, input, executionContext, result);
    if (paramData.getData().size() != 1) {
        throw new ScriptExecutionException("Exactly one item was expected in '" + parameterName + "' parameter. Got " + paramData.getData().size());
    }
    PrismValue prismValue = paramData.getData().get(0).getValue();
    if (prismValue == null) {
        if (requiredNonNull) {
            throw new ScriptExecutionException("A non-null value was expected in '" + parameterName + "' parameter");
        }
        return null;
    }
    if (!(prismValue instanceof PrismPropertyValue)) {
        throw new ScriptExecutionException("A prism property value was expected in '" + parameterName + "' parameter. Got " + prismValue.getClass().getName() + " instead.");
    }
    Object value = ((PrismPropertyValue) prismValue).getValue();
    try {
        return JavaTypeConverter.convert(clazz, value);
    } catch (Throwable t) {
        throw new ScriptExecutionException("Couldn't retrieve value of parameter '" + parameterName + "': " + t.getMessage(), t);
    }
}