Examples with ObjectDelta com.evolveum.midpoint.prism.delta.ObjectDelta used on opensource projects

Example 11 with ObjectDelta

use of com.evolveum.midpoint.prism.delta.ObjectDelta in project midpoint by Evolveum.

the class PageTaskController method savePerformed.

void savePerformed(AjaxRequestTarget target) {
    LOGGER.debug("Saving new task.");
    OperationResult result = new OperationResult(PageTaskEdit.OPERATION_SAVE_TASK);
    TaskDto dto = parentPage.getTaskDto();
    Task operationTask = parentPage.createSimpleTask(PageTaskEdit.OPERATION_SAVE_TASK);
    try {
        List<ItemDelta<?, ?>> itemDeltas = getDeltasToExecute(dto);
        ObjectDelta<TaskType> delta = ObjectDelta.createModifyDelta(dto.getOid(), itemDeltas, TaskType.class, parentPage.getPrismContext());
        final Collection<ObjectDelta<? extends ObjectType>> deltas = Collections.<ObjectDelta<? extends ObjectType>>singletonList(delta);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("Saving task modifications:\n{}", DebugUtil.debugDump(deltas));
        }
        parentPage.getModelService().executeChanges(deltas, null, operationTask, result);
        result.recomputeStatus();
    } catch (Exception ex) {
        result.recomputeStatus();
        result.recordFatalError("Couldn't save task.", ex);
        LoggingUtils.logUnexpectedException(LOGGER, "Couldn't save task modifications", ex);
    }
    afterSave(target, result);
}

Example 12 with ObjectDelta

use of com.evolveum.midpoint.prism.delta.ObjectDelta in project midpoint by Evolveum.

the class PageTasks method deleteNodesPerformed.

private void deleteNodesPerformed(AjaxRequestTarget target, List<NodeDto> nodes) {
    OperationResult result = new OperationResult(OPERATION_DELETE_NODES);
    Task task = createSimpleTask(OPERATION_DELETE_NODES);
    for (NodeDto nodeDto : nodes) {
        Collection<ObjectDelta<? extends ObjectType>> deltas = new ArrayList<>();
        deltas.add(ObjectDelta.createDeleteDelta(NodeType.class, nodeDto.getOid(), getPrismContext()));
        try {
            getModelService().executeChanges(deltas, null, task, result);
        } catch (Exception e) {
            // until java 7 we do it in this way
            result.recordFatalError("Couldn't delete the node " + nodeDto.getNodeIdentifier(), e);
        }
    }
    result.computeStatus();
    if (result.isSuccess()) {
        result.recordStatus(OperationResultStatus.SUCCESS, "Selected node(s) have been successfully deleted.");
    }
    showResult(result);
    NodeDtoProvider provider = (NodeDtoProvider) getNodeTable().getDataTable().getDataProvider();
    provider.clearCache();
    //refresh feedback and table
    refreshTables(target);
}

Example 13 with ObjectDelta

use of com.evolveum.midpoint.prism.delta.ObjectDelta in project midpoint by Evolveum.

the class PrismAsserts method assertEquals.

public static <O extends Objectable> void assertEquals(String message, PrismObject<O> expected, PrismObject<O> actual) {
    if (expected == null && actual == null) {
        return;
    }
    if (expected == null) {
        fail(message + ": expected null, was " + actual);
    }
    if (actual == null) {
        fail(message + ": expected " + expected + ", was null");
    }
    if (expected.equals(actual)) {
        return;
    }
    if (message == null) {
        message = "Prism object not equal";
    }
    ObjectDelta delta = expected.diff(actual);
    String suffix = "the difference: " + delta;
    if (delta.isEmpty()) {
        suffix += ": Empty delta. The difference is most likely in meta-data";
    }
    LOGGER.error("ASSERT: {}: {} and {} not equals, delta:\n{}", message, expected, actual, delta.debugDump());
    assert false : message + ": " + suffix;
}

Example 14 with ObjectDelta

use of com.evolveum.midpoint.prism.delta.ObjectDelta in project midpoint by Evolveum.

the class BaseCertificationHandler method revokeAssignmentCase.

//	@NotNull
//	protected <F extends FocusType> FocusType castToFocus(PrismObject<F> objectPrism) {
//		ObjectType object = objectPrism.asObjectable();
//		if (!(object instanceof FocusType)) {
//			throw new IllegalStateException(ExclusionCertificationHandler.class.getSimpleName() + " cannot be run against non-focal object: " + ObjectTypeUtil
//					.toShortString(object));
//		}
//		return (FocusType) object;
//	}
// TODO move to some helper?
protected void revokeAssignmentCase(AccessCertificationAssignmentCaseType assignmentCase, AccessCertificationCampaignType campaign, OperationResult caseResult, Task task) throws SchemaException, ObjectAlreadyExistsException, ObjectNotFoundException, ExpressionEvaluationException, CommunicationException, ConfigurationException, PolicyViolationException, SecurityViolationException {
    String objectOid = assignmentCase.getObjectRef().getOid();
    Class<? extends Objectable> clazz = ObjectTypes.getObjectTypeFromTypeQName(assignmentCase.getObjectRef().getType()).getClassDefinition();
    PrismContainerValue<AssignmentType> cval = assignmentCase.getAssignment().asPrismContainerValue().clone();
    ContainerDelta assignmentDelta;
    if (Boolean.TRUE.equals(assignmentCase.isIsInducement())) {
        assignmentDelta = ContainerDelta.createModificationDelete(AbstractRoleType.F_INDUCEMENT, clazz, prismContext, cval);
    } else {
        assignmentDelta = ContainerDelta.createModificationDelete(FocusType.F_ASSIGNMENT, clazz, prismContext, cval);
    }
    @SuppressWarnings({ "unchecked", "raw" }) ObjectDelta<? extends ObjectType> objectDelta = (ObjectDelta<? extends ObjectType>) ObjectDelta.createModifyDelta(objectOid, Collections.singletonList(assignmentDelta), clazz, prismContext);
    LOGGER.info("Going to execute delta: {}", objectDelta.debugDump());
    modelService.executeChanges(Collections.singletonList(objectDelta), null, task, caseResult);
    LOGGER.info("Case {} in {} ({} {} of {}) was successfully revoked", assignmentCase.asPrismContainerValue().getId(), ObjectTypeUtil.toShortString(campaign), Boolean.TRUE.equals(assignmentCase.isIsInducement()) ? "inducement" : "assignment", cval.getId(), objectOid);
}

Example 15 with ObjectDelta

use of com.evolveum.midpoint.prism.delta.ObjectDelta 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);
}