Examples with GetOperationOptions com.evolveum.midpoint.schema.GetOperationOptions used on opensource projects

Example 31 with GetOperationOptions

use of com.evolveum.midpoint.schema.GetOperationOptions in project midpoint by Evolveum.

the class ChangeExecutor method deleteProvisioningObject.

private <F extends ObjectType, T extends ObjectType> void deleteProvisioningObject(Class<T> objectTypeClass, String oid, LensContext<F> context, LensElementContext<T> objectContext, ProvisioningOperationOptions options, ResourceType resource, Task task, OperationResult result) throws ObjectNotFoundException, ObjectAlreadyExistsException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    PrismObject<T> shadowToModify = null;
    OperationProvisioningScriptsType scripts = null;
    try {
        GetOperationOptions rootOpts = GetOperationOptions.createNoFetch();
        rootOpts.setPointInTimeType(PointInTimeType.FUTURE);
        shadowToModify = provisioning.getObject(objectTypeClass, oid, SelectorOptions.createCollection(rootOpts), task, result);
    } catch (ObjectNotFoundException ex) {
        // this is almost OK, mute the error and try to delete account (it
        // will fail if something is wrong)
        result.muteLastSubresultError();
    }
    if (ShadowType.class.isAssignableFrom(objectTypeClass)) {
        scripts = prepareScripts(shadowToModify, context, objectContext, ProvisioningOperationTypeType.DELETE, resource, task, result);
    }
    Utils.setRequestee(task, context);
    provisioning.deleteObject(objectTypeClass, oid, options, scripts, task, result);
    Utils.clearRequestee(task);
}

Example 32 with GetOperationOptions

use of com.evolveum.midpoint.schema.GetOperationOptions in project midpoint by Evolveum.

the class ChangeExecutor method updateSituationInShadow.

private <F extends ObjectType> void updateSituationInShadow(Task task, SynchronizationSituationType situation, LensFocusContext<F> focusContext, LensProjectionContext projectionCtx, OperationResult parentResult) throws ObjectNotFoundException, SchemaException {
    String projectionOid = projectionCtx.getOid();
    OperationResult result = new OperationResult(OPERATION_UPDATE_SITUATION_ACCOUNT);
    result.addParam("situation", situation);
    result.addParam("accountRef", projectionOid);
    PrismObject<ShadowType> account = null;
    GetOperationOptions getOptions = GetOperationOptions.createNoFetch();
    getOptions.setAllowNotFound(true);
    try {
        account = provisioning.getObject(ShadowType.class, projectionOid, SelectorOptions.createCollection(getOptions), task, result);
    } catch (Exception ex) {
        LOGGER.trace("Problem with getting account, skipping modifying situation in account.");
        return;
    }
    List<PropertyDelta<?>> syncSituationDeltas = SynchronizationUtils.createSynchronizationSituationAndDescriptionDelta(account, situation, task.getChannel(), projectionCtx.hasFullShadow());
    try {
        Utils.setRequestee(task, focusContext);
        ProvisioningOperationOptions options = ProvisioningOperationOptions.createCompletePostponed(false);
        options.setDoNotDiscovery(true);
        String changedOid = provisioning.modifyObject(ShadowType.class, projectionOid, syncSituationDeltas, null, options, task, result);
        // modifyProvisioningObject(AccountShadowType.class, accountRef,
        // syncSituationDeltas,
        // ProvisioningOperationOptions.createCompletePostponed(false),
        // task, result);
        projectionCtx.setSynchronizationSituationResolved(situation);
        LOGGER.trace("Situation in projection {} was updated to {}.", projectionCtx, situation);
    } catch (ObjectNotFoundException ex) {
        // if the object not found exception is thrown, it's ok..probably
        // the account was deleted by previous execution of changes..just
        // log in the trace the message for the user..
        LOGGER.trace("Situation in account could not be updated. Account not found on the resource. Skipping modifying situation in account");
        return;
    } catch (Exception ex) {
        throw new SystemException(ex.getMessage(), ex);
    } finally {
        Utils.clearRequestee(task);
    }
    // if everything is OK, add result of the situation modification to the
    // parent result
    result.recordSuccess();
    parentResult.addSubresult(result);
}

Example 33 with GetOperationOptions

use of com.evolveum.midpoint.schema.GetOperationOptions in project midpoint by Evolveum.

the class ModelRestService method searchObjectsByType.

@GET
@Path("/{type}")
@Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON, "application/yaml" })
public <T extends ObjectType> Response searchObjectsByType(@PathParam("type") String type, @QueryParam("options") List<String> options, @Context UriInfo uriInfo, @Context MessageContext mc) {
    Task task = RestServiceUtil.initRequest(mc);
    OperationResult parentResult = task.getResult().createSubresult(OPERATION_SEARCH_OBJECTS);
    Class<T> clazz = ObjectTypes.getClassFromRestType(type);
    Response response;
    try {
        Collection<SelectorOptions<GetOperationOptions>> searchOptions = GetOperationOptions.fromRestOptions(options, null, null);
        List<PrismObject<T>> objects = model.searchObjects(clazz, null, searchOptions, task, parentResult);
        ObjectListType listType = new ObjectListType();
        if (objects != null) {
            List<ObjectType> list = objects.stream().map(o -> convert(clazz, o, parentResult.createOperationResultType())).collect(Collectors.toList());
            listType.getObject().addAll(list);
        }
        response = RestServiceUtil.createResponse(Response.Status.OK, listType, parentResult, true);
    //			response = Response.ok().entity(listType).build();
    } catch (Exception ex) {
        response = RestServiceUtil.handleException(parentResult, ex);
    }
    parentResult.computeStatus();
    finishRequest(task);
    return response;
}

Example 34 with GetOperationOptions

use of com.evolveum.midpoint.schema.GetOperationOptions in project midpoint by Evolveum.

the class ContextLoader method loadLinkRefsFromFocus.

/**
	 * Does not overwrite existing account contexts, just adds new ones. 
	 */
private <F extends FocusType> void loadLinkRefsFromFocus(LensContext<F> context, PrismObject<F> focus, Task task, OperationResult result) throws ObjectNotFoundException, CommunicationException, SchemaException, ConfigurationException, SecurityViolationException, PolicyViolationException, ExpressionEvaluationException {
    PrismReference linkRef = focus.findReference(FocusType.F_LINK_REF);
    if (linkRef == null) {
        return;
    }
    for (PrismReferenceValue linkRefVal : linkRef.getValues()) {
        String oid = linkRefVal.getOid();
        if (StringUtils.isBlank(oid)) {
            LOGGER.trace("Null or empty OID in link reference {} in:\n{}", linkRef, focus.debugDump(1));
            throw new SchemaException("Null or empty OID in link reference in " + focus);
        }
        LensProjectionContext existingAccountContext = findAccountContext(oid, context);
        if (!canBeLoaded(context, existingAccountContext)) {
            continue;
        }
        if (existingAccountContext != null) {
            // TODO: do we need to reload the account inside here? yes we need
            existingAccountContext.setFresh(true);
            continue;
        }
        PrismObject<ShadowType> shadow = linkRefVal.getObject();
        if (shadow == null) {
            // Using NO_FETCH so we avoid reading in a full account. This is more efficient as we don't need full account here.
            // We need to fetch from provisioning and not repository so the correct definition will be set.
            GetOperationOptions rootOpts = GetOperationOptions.createNoFetch();
            rootOpts.setPointInTimeType(PointInTimeType.FUTURE);
            Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(rootOpts);
            LOGGER.trace("Loading shadow {} from linkRef, options={}", oid, options);
            try {
                shadow = provisioningService.getObject(ShadowType.class, oid, options, task, result);
            } catch (ObjectNotFoundException e) {
                // Broken accountRef. We need to mark it for deletion
                LensProjectionContext accountContext = getOrCreateEmptyThombstoneProjectionContext(context, oid);
                accountContext.setFresh(true);
                accountContext.setExists(false);
                OperationResult getObjectSubresult = result.getLastSubresult();
                getObjectSubresult.setErrorsHandled();
                continue;
            }
        } else {
            // Make sure it has a proper definition. This may come from outside of the model.
            provisioningService.applyDefinition(shadow, task, result);
        }
        LensProjectionContext accountContext = getOrCreateAccountContext(context, shadow, task, result);
        accountContext.setFresh(true);
        accountContext.setExists(shadow != null);
        if (context.isDoReconciliationForAllProjections()) {
            accountContext.setDoReconciliation(true);
        }
        if (accountContext.isDoReconciliation()) {
            // reconciliation step.				
            continue;
        }
        accountContext.setLoadedObject(shadow);
    }
}

Example 35 with GetOperationOptions

use of com.evolveum.midpoint.schema.GetOperationOptions in project midpoint by Evolveum.

the class ContextLoader method loadLinkRefsFromDelta.

private <F extends FocusType> void loadLinkRefsFromDelta(LensContext<F> context, PrismObject<F> focus, ObjectDelta<F> focusPrimaryDelta, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, PolicyViolationException, ExpressionEvaluationException {
    if (focusPrimaryDelta == null) {
        return;
    }
    ReferenceDelta linkRefDelta;
    if (focusPrimaryDelta.getChangeType() == ChangeType.ADD) {
        PrismReference linkRef = focusPrimaryDelta.getObjectToAdd().findReference(FocusType.F_LINK_REF);
        if (linkRef == null) {
            // Adding new focus with no linkRef -> nothing to do
            return;
        }
        linkRefDelta = linkRef.createDelta(new ItemPath(FocusType.F_LINK_REF));
        linkRefDelta.addValuesToAdd(PrismValue.cloneValues(linkRef.getValues()));
    } else if (focusPrimaryDelta.getChangeType() == ChangeType.MODIFY) {
        linkRefDelta = focusPrimaryDelta.findReferenceModification(FocusType.F_LINK_REF);
        if (linkRefDelta == null) {
            return;
        }
    } else {
        // delete, all existing account are already marked for delete
        return;
    }
    if (linkRefDelta.isReplace()) {
        // process "replace" by distributing values to delete and add
        linkRefDelta = (ReferenceDelta) linkRefDelta.clone();
        PrismReference linkRef = focus.findReference(FocusType.F_LINK_REF);
        linkRefDelta.distributeReplace(linkRef == null ? null : linkRef.getValues());
    }
    if (linkRefDelta.getValuesToAdd() != null) {
        for (PrismReferenceValue refVal : linkRefDelta.getValuesToAdd()) {
            String oid = refVal.getOid();
            LensProjectionContext accountContext = null;
            PrismObject<ShadowType> shadow = null;
            boolean isCombinedAdd = false;
            if (oid == null) {
                // Adding new account
                shadow = refVal.getObject();
                if (shadow == null) {
                    throw new SchemaException("Null or empty OID in account reference " + refVal + " in " + focus);
                }
                provisioningService.applyDefinition(shadow, task, result);
                if (consistencyChecks)
                    ShadowUtil.checkConsistence(shadow, "account from " + linkRefDelta);
                // Check for conflicting change
                accountContext = LensUtil.getProjectionContext(context, shadow, provisioningService, prismContext, task, result);
                if (accountContext != null) {
                    // There is already existing context for the same discriminator. Tolerate this only if
                    // the deltas match. It is an error otherwise.
                    ObjectDelta<ShadowType> primaryDelta = accountContext.getPrimaryDelta();
                    if (primaryDelta == null) {
                        throw new SchemaException("Attempt to add " + shadow + " to a user that already contains " + accountContext.getHumanReadableKind() + " of type '" + accountContext.getResourceShadowDiscriminator().getIntent() + "' on " + accountContext.getResource());
                    }
                    if (!primaryDelta.isAdd()) {
                        throw new SchemaException("Conflicting changes in the context. " + "Add of accountRef in the user delta with embedded object conflicts with explicit delta " + primaryDelta);
                    }
                    if (!shadow.equals(primaryDelta.getObjectToAdd())) {
                        throw new SchemaException("Conflicting changes in the context. " + "Add of accountRef in the user delta with embedded object is not adding the same object as explicit delta " + primaryDelta);
                    }
                } else {
                    // Create account context from embedded object
                    accountContext = createProjectionContext(context, shadow, task, result);
                }
                // This is a new account that is to be added. So it should
                // go to account primary delta
                ObjectDelta<ShadowType> accountPrimaryDelta = shadow.createAddDelta();
                accountContext.setPrimaryDelta(accountPrimaryDelta);
                accountContext.setFullShadow(true);
                accountContext.setExists(false);
                isCombinedAdd = true;
            } else {
                // therefore check for account existence to decide
                try {
                    // Using NO_FETCH so we avoid reading in a full account. This is more efficient as we don't need full account here.
                    // We need to fetch from provisioning and not repository so the correct definition will be set.
                    GetOperationOptions rootOpts = GetOperationOptions.createNoFetch();
                    rootOpts.setPointInTimeType(PointInTimeType.FUTURE);
                    Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(rootOpts);
                    shadow = provisioningService.getObject(ShadowType.class, oid, options, task, result);
                    // Create account context from retrieved object
                    accountContext = getOrCreateAccountContext(context, shadow, task, result);
                    accountContext.setLoadedObject(shadow);
                    accountContext.setExists(true);
                } catch (ObjectNotFoundException e) {
                    if (refVal.getObject() == null) {
                        // ref -> this is really an error
                        throw e;
                    } else {
                        // New account (with OID)
                        result.muteLastSubresultError();
                        shadow = refVal.getObject();
                        if (!shadow.hasCompleteDefinition()) {
                            provisioningService.applyDefinition(shadow, task, result);
                        }
                        // Create account context from embedded object
                        accountContext = createProjectionContext(context, shadow, task, result);
                        ObjectDelta<ShadowType> accountPrimaryDelta = shadow.createAddDelta();
                        accountContext.setPrimaryDelta(accountPrimaryDelta);
                        accountContext.setFullShadow(true);
                        accountContext.setExists(false);
                        isCombinedAdd = true;
                    }
                }
            }
            if (context.isDoReconciliationForAllProjections() && !isCombinedAdd) {
                accountContext.setDoReconciliation(true);
            }
            accountContext.setFresh(true);
        }
    }
    if (linkRefDelta.getValuesToDelete() != null) {
        for (PrismReferenceValue refVal : linkRefDelta.getValuesToDelete()) {
            String oid = refVal.getOid();
            LensProjectionContext accountContext = null;
            PrismObject<ShadowType> account = null;
            if (oid == null) {
                throw new SchemaException("Cannot delete account ref without an oid in " + focus);
            } else {
                try {
                    // Using NO_FETCH so we avoid reading in a full account. This is more efficient as we don't need full account here.
                    // We need to fetch from provisioning and not repository so the correct definition will be set.
                    Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(GetOperationOptions.createNoFetch());
                    account = provisioningService.getObject(ShadowType.class, oid, options, task, result);
                    // Create account context from retrieved object
                    accountContext = getOrCreateAccountContext(context, account, task, result);
                    accountContext.setLoadedObject(account);
                    accountContext.setExists(true);
                } catch (ObjectNotFoundException e) {
                    try {
                        // Broken accountRef. We need to try again with raw options, because the error should be thrown because of non-existent resource
                        Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(GetOperationOptions.createRaw());
                        account = provisioningService.getObject(ShadowType.class, oid, options, task, result);
                        accountContext = getOrCreateEmptyThombstoneProjectionContext(context, oid);
                        accountContext.setFresh(true);
                        accountContext.setExists(false);
                        OperationResult getObjectSubresult = result.getLastSubresult();
                        getObjectSubresult.setErrorsHandled();
                    } catch (ObjectNotFoundException ex) {
                        // This is still OK. It means deleting an accountRef
                        // that points to non-existing object
                        // just log a warning
                        LOGGER.warn("Deleting accountRef of " + focus + " that points to non-existing OID " + oid);
                    }
                }
            }
            if (accountContext != null) {
                if (refVal.getObject() == null) {
                    accountContext.setSynchronizationIntent(SynchronizationIntent.UNLINK);
                } else {
                    accountContext.setSynchronizationIntent(SynchronizationIntent.DELETE);
                    ObjectDelta<ShadowType> accountPrimaryDelta = account.createDeleteDelta();
                    accountContext.setPrimaryDelta(accountPrimaryDelta);
                }
                accountContext.setFresh(true);
            }
        }
    }
    if (focusPrimaryDelta.getChangeType() == ChangeType.ADD) {
        focusPrimaryDelta.getObjectToAdd().removeReference(FocusType.F_LINK_REF);
    } else if (focusPrimaryDelta.getChangeType() == ChangeType.MODIFY) {
        focusPrimaryDelta.removeReferenceModification(FocusType.F_LINK_REF);
    }
}