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

Example 96 with SelectorOptions

use of com.evolveum.midpoint.schema.SelectorOptions 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 97 with SelectorOptions

use of com.evolveum.midpoint.schema.SelectorOptions 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);
    }
}

Example 98 with SelectorOptions

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

the class ContextLoader method loadProjectionContextsSync.

private <F extends ObjectType> void loadProjectionContextsSync(LensContext<F> context, Task task, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException {
    for (LensProjectionContext projCtx : context.getProjectionContexts()) {
        if (projCtx.isFresh() && projCtx.getObjectCurrent() != null) {
            // already loaded
            continue;
        }
        ObjectDelta<ShadowType> syncDelta = projCtx.getSyncDelta();
        if (syncDelta != null) {
            if (projCtx.isDoReconciliation()) {
                // Do not load old account now. It will get loaded later in the
                // reconciliation step. Just mark it as fresh.
                projCtx.setFresh(true);
                continue;
            }
            String oid = syncDelta.getOid();
            PrismObject<ShadowType> shadow = null;
            if (syncDelta.getChangeType() == ChangeType.ADD) {
                shadow = syncDelta.getObjectToAdd().clone();
                projCtx.setLoadedObject(shadow);
                projCtx.setExists(true);
            } else {
                if (oid == null) {
                    throw new IllegalArgumentException("No OID in sync delta in " + projCtx);
                }
                // 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 option = GetOperationOptions.createNoFetch();
                option.setDoNotDiscovery(true);
                option.setPointInTimeType(PointInTimeType.FUTURE);
                Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(option);
                try {
                    shadow = provisioningService.getObject(ShadowType.class, oid, options, task, result);
                } catch (ObjectNotFoundException e) {
                    LOGGER.trace("Loading shadow {} from sync delta failed: not found", oid);
                    projCtx.setExists(false);
                    projCtx.setObjectCurrent(null);
                }
                // shadow)
                if (syncDelta.getChangeType() == ChangeType.DELETE) {
                    projCtx.setExists(false);
                    projCtx.getResourceShadowDiscriminator().setThombstone(true);
                } else if (shadow != null) {
                    syncDelta.applyTo(shadow);
                    projCtx.setLoadedObject(shadow);
                    projCtx.setExists(true);
                }
            }
            // Make sure OID is set correctly
            projCtx.setOid(oid);
            // Make sure that resource is also resolved
            if (projCtx.getResource() == null && shadow != null) {
                String resourceOid = ShadowUtil.getResourceOid(shadow.asObjectable());
                if (resourceOid == null) {
                    throw new IllegalArgumentException("No resource OID in " + shadow);
                }
                ResourceType resourceType = LensUtil.getResourceReadOnly(context, resourceOid, provisioningService, task, result);
                projCtx.setResource(resourceType);
            }
            projCtx.setFresh(true);
        }
    }
}

Example 99 with SelectorOptions

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

the class TestEditSchema method test140LookupLanguagesGetByIdExisting.

/**
     * This test is disabled because id-based searching is not available yet (and it's unclear if it would be eventually necessary).
     */
@Test(enabled = false)
public void test140LookupLanguagesGetByIdExisting() throws Exception {
    final String TEST_NAME = "test140LookupLanguagesGetByIdExisting";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN
    Task task = taskManager.createTaskInstance(TestEditSchema.class.getName() + "." + TEST_NAME);
    OperationResult result = task.getResult();
    // WHEN
    TestUtil.displayWhen(TEST_NAME);
    Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(new ItemPath(new NameItemPathSegment(LookupTableType.F_ROW), new IdItemPathSegment(1L)), GetOperationOptions.createRetrieve(RetrieveOption.INCLUDE));
    PrismObject<LookupTableType> lookup = modelService.getObject(LookupTableType.class, LOOKUP_LANGUAGES_OID, options, task, result);
    // THEN
    TestUtil.displayThen(TEST_NAME);
    result.computeStatus();
    TestUtil.assertSuccess(result);
    checkLookupResult(lookup, new String[] { "en_US", "en", "English (US)" });
}

Example 100 with SelectorOptions

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

the class TestEditSchema method test120LookupLanguagesGetByKeyExact.

@Test
public void test120LookupLanguagesGetByKeyExact() throws Exception {
    final String TEST_NAME = "test120LookupLanguagesGetByKeyExact";
    TestUtil.displayTestTile(this, TEST_NAME);
    // GIVEN
    Task task = taskManager.createTaskInstance(TestEditSchema.class.getName() + "." + TEST_NAME);
    OperationResult result = task.getResult();
    // WHEN
    TestUtil.displayWhen(TEST_NAME);
    RelationalValueSearchQuery query = new RelationalValueSearchQuery(LookupTableRowType.F_KEY, "sk_SK", RelationalValueSearchType.EXACT);
    Collection<SelectorOptions<GetOperationOptions>> options = SelectorOptions.createCollection(LookupTableType.F_ROW, GetOperationOptions.createRetrieve(query));
    PrismObject<LookupTableType> lookup = modelService.getObject(LookupTableType.class, LOOKUP_LANGUAGES_OID, options, task, result);
    // THEN
    TestUtil.displayThen(TEST_NAME);
    result.computeStatus();
    TestUtil.assertSuccess(result);
    checkLookupResult(lookup, new String[] { "sk_SK", "sk", "Slovak" });
}