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

Example 56 with FocusType

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

the class PersonaProcessor method personaAdd.

public <F extends FocusType, T extends FocusType> void personaAdd(LensContext<F> context, PersonaKey key, PersonaConstruction<F> construction, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, ExpressionEvaluationException, PolicyViolationException, ObjectAlreadyExistsException, CommunicationException, ConfigurationException, SecurityViolationException {
    PrismObject<F> focus = context.getFocusContext().getObjectNew();
    LOGGER.debug("Adding persona {} for {} using construction {}", key, focus, construction);
    PersonaConstructionType constructionType = construction.getConstructionType();
    ObjectReferenceType objectMappingRef = constructionType.getObjectMappingRef();
    ObjectTemplateType objectMappingType = objectResolver.resolve(objectMappingRef, ObjectTemplateType.class, null, "object mapping in persona construction in " + focus, task, result);
    QName targetType = constructionType.getTargetType();
    PrismObjectDefinition<T> objectDef = prismContext.getSchemaRegistry().findObjectDefinitionByType(targetType);
    PrismObject<T> target = objectDef.instantiate();
    FocusTypeUtil.setSubtype(target, constructionType.getTargetSubtype());
    // pretend ADD focusOdo. We need to push all the items through the object template
    ObjectDeltaObject<F> focusOdo = new ObjectDeltaObject<>(null, focus.createAddDelta(), focus);
    ObjectDelta<T> targetDelta = target.createAddDelta();
    String contextDesc = "object mapping " + objectMappingType + " for persona construction for " + focus;
    XMLGregorianCalendar now = clock.currentTimeXMLGregorianCalendar();
    Collection<ItemDelta<?, ?>> itemDeltas = objectTemplateProcessor.processObjectMapping(context, objectMappingType, focusOdo, target, targetDelta, contextDesc, now, task, result);
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("itemDeltas:\n{}", DebugUtil.debugDump(itemDeltas));
    }
    for (ItemDelta itemDelta : itemDeltas) {
        itemDelta.applyTo(target);
    }
    LOGGER.trace("Creating persona:\n{}", target.debugDumpLazily());
    executePersonaDelta(targetDelta, task, result);
    link(context, target.asObjectable(), result);
}

Example 57 with FocusType

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

the class PersonaProcessor method personaModify.

public <F extends FocusType, T extends FocusType> void personaModify(LensContext<F> context, PersonaKey key, PersonaConstruction<F> construction, PrismObject<T> existingPersona, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, ExpressionEvaluationException, PolicyViolationException, ObjectAlreadyExistsException, CommunicationException, ConfigurationException, SecurityViolationException {
    PrismObject<F> focus = context.getFocusContext().getObjectNew();
    LOGGER.debug("Modifying persona {} for {} using construction {}", key, focus, construction);
    PersonaConstructionType constructionType = construction.getConstructionType();
    ObjectReferenceType objectMappingRef = constructionType.getObjectMappingRef();
    ObjectTemplateType objectMappingType = objectResolver.resolve(objectMappingRef, ObjectTemplateType.class, null, "object mapping in persona construction in " + focus, task, result);
    ObjectDeltaObject<F> focusOdo = context.getFocusContext().getObjectDeltaObject();
    String contextDesc = "object mapping " + objectMappingType + " for persona construction for " + focus;
    XMLGregorianCalendar now = clock.currentTimeXMLGregorianCalendar();
    Collection<ItemDelta<?, ?>> itemDeltas = objectTemplateProcessor.processObjectMapping(context, objectMappingType, focusOdo, existingPersona, null, contextDesc, now, task, result);
    if (LOGGER.isTraceEnabled()) {
        LOGGER.trace("itemDeltas:\n{}", DebugUtil.debugDump(itemDeltas));
    }
    ObjectDelta<T> targetDelta = existingPersona.createModifyDelta();
    for (ItemDelta itemDelta : itemDeltas) {
        targetDelta.addModification(itemDelta);
    }
    executePersonaDelta(targetDelta, task, result);
}

Example 58 with FocusType

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

the class SynchronizationServiceImpl method executeActions.

private <F extends FocusType> void executeActions(SynchronizationReactionType reactionDef, LensContext<F> context, SynchronizationSituation<F> situation, BeforeAfterType order, ResourceType resource, boolean logDebug, Task task, OperationResult parentResult) throws ConfigurationException, SchemaException {
    for (SynchronizationActionType actionDef : reactionDef.getAction()) {
        if ((actionDef.getOrder() == null && order == BeforeAfterType.BEFORE) || (actionDef.getOrder() != null && actionDef.getOrder() == order)) {
            String handlerUri = actionDef.getHandlerUri();
            if (handlerUri == null) {
                handlerUri = actionDef.getRef();
            }
            if (handlerUri == null) {
                LOGGER.error("Action definition in resource {} doesn't contain handler URI", resource);
                throw new ConfigurationException("Action definition in resource " + resource + " doesn't contain handler URI");
            }
            Action action = actionManager.getActionInstance(handlerUri);
            if (action == null) {
                LOGGER.warn("Couldn't create action with uri '{}' in resource {}, skipping action.", new Object[] { handlerUri, resource });
                continue;
            }
            // TODO: legacy userTemplate
            Map<QName, Object> parameters = null;
            if (actionDef.getParameters() != null) {
            // TODO: process parameters
            // parameters = actionDef.getParameters().getAny();
            }
            if (logDebug) {
                LOGGER.debug("SYNCHRONIZATION: ACTION: Executing: {}.", new Object[] { action.getClass() });
            } else {
                LOGGER.trace("SYNCHRONIZATION: ACTION: Executing: {}.", new Object[] { action.getClass() });
            }
            action.handle(context, situation, parameters, task, parentResult);
        }
    }
}

Example 59 with FocusType

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

the class SynchronizationServiceImpl method determineSituation.

/**
	 * XXX: in situation when one account belongs to two different idm users
	 * (repository returns only first user, method
	 * {@link com.evolveum.midpoint.model.api.ModelService#findShadowOwner(String, Task, OperationResult)}
	 * (String, com.evolveum.midpoint.schema.result.OperationResult)} ). It
	 * should be changed because otherwise we can't find
	 * {@link SynchronizationSituationType#DISPUTED} situation
	 */
private <F extends FocusType> SynchronizationSituation determineSituation(Class<F> focusType, ResourceObjectShadowChangeDescription change, ObjectSynchronizationType synchronizationPolicy, SystemConfigurationType configurationType, Task task, OperationResult result) {
    OperationResult subResult = result.createSubresult(CHECK_SITUATION);
    LOGGER.trace("Determining situation for resource object shadow.");
    SynchronizationSituation situation = null;
    try {
        String shadowOid = getOidFromChange(change);
        Validate.notEmpty(shadowOid, "Couldn't get resource object shadow oid from change.");
        PrismObject<F> owner = repositoryService.searchShadowOwner(shadowOid, SelectorOptions.createCollection(GetOperationOptions.createAllowNotFound()), subResult);
        if (owner != null) {
            F ownerType = owner.asObjectable();
            LOGGER.trace("Shadow OID {} does have owner: {}", shadowOid, ownerType.getName());
            SynchronizationSituationType state = null;
            switch(getModificationType(change)) {
                case ADD:
                case MODIFY:
                    // if user is found it means account/group is linked to
                    // resource
                    state = SynchronizationSituationType.LINKED;
                    break;
                case DELETE:
                    state = SynchronizationSituationType.DELETED;
            }
            situation = new SynchronizationSituation<>(ownerType, null, state);
        } else {
            LOGGER.trace("Resource object shadow doesn't have owner.");
            situation = determineSituationWithCorrelation(focusType, change, synchronizationPolicy, owner, configurationType, task, result);
        }
    } catch (Exception ex) {
        LOGGER.error("Error occurred during resource object shadow owner lookup.");
        throw new SystemException("Error occurred during resource object shadow owner lookup, reason: " + ex.getMessage(), ex);
    } finally {
        subResult.computeStatus();
    }
    return situation;
}

Example 60 with FocusType

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

the class SynchronizationServiceImpl method reactToChange.

private <F extends FocusType> SynchronizationSituationType reactToChange(Class<F> focusClass, ResourceObjectShadowChangeDescription change, ObjectSynchronizationType synchronizationPolicy, SynchronizationSituation<F> situation, ResourceType resource, boolean logDebug, PrismObject<SystemConfigurationType> configuration, Task task, OperationResult parentResult) throws ConfigurationException, ObjectNotFoundException, SchemaException, PolicyViolationException, ExpressionEvaluationException, ObjectAlreadyExistsException, CommunicationException, SecurityViolationException {
    SynchronizationSituationType newSituation = situation.getSituation();
    SynchronizationReactionType reactionDefinition = findReactionDefinition(synchronizationPolicy, situation, change.getSourceChannel(), resource);
    if (reactionDefinition == null) {
        LOGGER.trace("No reaction is defined for situation {} in {}", situation.getSituation(), resource);
        return newSituation;
    }
    // seems to be unused so commented it out [med]
    // PrismObject<? extends ObjectType> shadow = null;
    // if (change.getCurrentShadow() != null) {
    // shadow = change.getCurrentShadow();
    // } else if (change.getOldShadow() != null) {
    // shadow = change.getOldShadow();
    // }
    Boolean doReconciliation = determineReconciliation(synchronizationPolicy, reactionDefinition);
    if (doReconciliation == null) {
        // shadow.
        if (change.getObjectDelta() == null) {
            doReconciliation = true;
        }
    }
    Boolean limitPropagation = determinePropagationLimitation(synchronizationPolicy, reactionDefinition, change.getSourceChannel());
    ModelExecuteOptions options = new ModelExecuteOptions();
    options.setReconcile(doReconciliation);
    options.setLimitPropagation(limitPropagation);
    final boolean willSynchronize = isSynchronize(reactionDefinition);
    LensContext<F> lensContext = null;
    if (willSynchronize) {
        lensContext = createLensContext(focusClass, change, reactionDefinition, synchronizationPolicy, situation, options, configuration, parentResult);
    }
    if (LOGGER.isTraceEnabled() && lensContext != null) {
        LOGGER.trace("---[ SYNCHRONIZATION context before action execution ]-------------------------\n" + "{}\n------------------------------------------", lensContext.debugDump());
    }
    if (willSynchronize) {
        // there's no point in calling executeAction without context - so
        // the actions are executed only if synchronize == true
        executeActions(reactionDefinition, lensContext, situation, BeforeAfterType.BEFORE, resource, logDebug, task, parentResult);
        Iterator<LensProjectionContext> iterator = lensContext.getProjectionContextsIterator();
        LensProjectionContext originalProjectionContext = iterator.hasNext() ? iterator.next() : null;
        try {
            clockwork.run(lensContext, task, parentResult);
        } catch (ConfigurationException | ObjectNotFoundException | SchemaException | PolicyViolationException | ExpressionEvaluationException | ObjectAlreadyExistsException | CommunicationException | SecurityViolationException e) {
            LOGGER.error("SYNCHRONIZATION: Error in synchronization on {} for situation {}: {}: {}. Change was {}", new Object[] { resource, situation.getSituation(), e.getClass().getSimpleName(), e.getMessage(), change, e });
        // what to do here? We cannot throw the error back. All that the notifyChange method
        // could do is to convert it to SystemException. But that indicates an internal error and it will
        // break whatever code called the notifyChange in the first place. We do not want that.
        // If the clockwork could not do anything with the exception then perhaps nothing can be done at all.
        // So just log the error (the error should be remembered in the result and task already)
        // and then just go on.
        }
        // note: actions "AFTER" seem to be useless here (basically they
        // modify lens context - which is relevant only if followed by
        // clockwork run)
        executeActions(reactionDefinition, lensContext, situation, BeforeAfterType.AFTER, resource, logDebug, task, parentResult);
        if (originalProjectionContext != null) {
            newSituation = originalProjectionContext.getSynchronizationSituationResolved();
        }
    } else {
        LOGGER.trace("Skipping clockwork run on {} for situation {}, synchronize is set to false.", new Object[] { resource, situation.getSituation() });
    }
    return newSituation;
}