public void merge(DeltaSetTriple<T> triple) { zeroSet.addAll(triple.getZeroSet()); plusSet.addAll(triple.getPlusSet()); minusSet.addAll(triple.getMinusSet()); }
@Override public void shortDump(StringBuilder sb) { if (target != null) { sb.append(target); } else if (!constructionTriple.isEmpty()) { sb.append("construction("); constructionTriple.shortDump(sb); sb.append(")"); } else if (!personaConstructionTriple.isEmpty()) { sb.append("personaConstruction("); personaConstructionTriple.shortDump(sb); sb.append(")"); } else { sb.append(toString()); return; } if (!isValid()) { sb.append(" invalid "); } }
public void addPersonaConstruction(PersonaConstruction<AH> personaContruction, PlusMinusZero whichSet) { switch (whichSet) { case ZERO: personaConstructionTriple.addToZeroSet(personaContruction); break; case PLUS: personaConstructionTriple.addToPlusSet(personaContruction); break; case MINUS: personaConstructionTriple.addToMinusSet(personaContruction); break; default: throw new IllegalArgumentException("whichSet: " + whichSet); } }
public List<EvaluatedAssignmentTargetImpl> getNonNegativeTargets() { List<EvaluatedAssignmentTargetImpl> rv = new ArrayList<>(); rv.addAll(roles.getZeroSet()); rv.addAll(roles.getPlusSet()); return rv; }
if (LOGGER.isTraceEnabled()) { LOGGER.trace("Inbound mapping for {}\nreturned triple:\n{}", mapping.getDefaultSource().debugDump(), itemValueWithOrigin == null ? "null" : itemValueWithOrigin.debugDump()); allTriples.addAllToMinusSet(itemValueWithOrigin.getMinusSet()); allTriples.addAllToPlusSet(itemValueWithOrigin.getPlusSet()); allTriples.addAllToZeroSet(itemValueWithOrigin.getZeroSet()); DeltaSetTriple<ItemValueWithOrigin<V, D>> consolidatedTriples = consolidateTriples(allTriples, assignmentEnforcement); LOGGER.trace("Consolidated triples {} \nfor mapping for item {}", consolidatedTriples.debugDumpLazily(), mappingEntry.getKey());
LOGGER.trace("evaluatedAssignmentTriple:\n{}", evaluatedAssignmentTriple.debugDump()); LOGGER.trace("re-evaluatedAssignmentTriple:\n{}", evaluatedAssignmentTriple.debugDump()); collectFocusTripleFromMappings(evaluatedAssignmentTriple.getPlusSet(), focusOutputTripleMap, PlusMinusZero.PLUS); collectFocusTripleFromMappings(evaluatedAssignmentTriple.getMinusSet(), focusOutputTripleMap, PlusMinusZero.MINUS); collectFocusTripleFromMappings(evaluatedAssignmentTriple.getZeroSet(), focusOutputTripleMap, PlusMinusZero.ZERO); ObjectDeltaObject<AH> focusOdo = focusContext.getObjectDeltaObject(); Collection<ItemDelta<?,?>> focusDeltas = objectTemplateProcessor.computeItemDeltas(focusOutputTripleMap, null, LOGGER.trace("Projection processing start, evaluatedAssignmentTriple:\n{}", evaluatedAssignmentTriple.debugDump(1));
if (originTriples.hasPlusSet()) { Collection<ItemValueWithOrigin<V, D>> plusSet = originTriples.getPlusSet(); LOGGER.trace("Consolidating plusSet from origin:\n {}", DebugUtil.debugDumpLazily(plusSet)); if (originTriples.hasMinusSet()) { for (ItemValueWithOrigin<V, D> minusValue: originTriples.getMinusSet()) { if (minusValue.getItemValue().equals(plusValue.getItemValue(), EquivalenceStrategy.REAL_VALUE)) { LOGGER.trace( if (originTriples.hasZeroSet()) { for (ItemValueWithOrigin<V, D> zeroValue: originTriples.getZeroSet()) { if (zeroValue.getItemValue().equals(plusValue.getItemValue(), EquivalenceStrategy.REAL_VALUE)) { LOGGER.trace( if (originTriples.hasZeroSet()) { Collection<ItemValueWithOrigin<V, D>> zeroSet = originTriples.getZeroSet(); LOGGER.trace("Consolidating zero set from origin:\n {}", DebugUtil.debugDumpLazily(zeroSet)); if (originTriples.hasMinusSet()) { for (ItemValueWithOrigin<V, D> minusValue : originTriples.getMinusSet()) { if (minusValue.getItemValue().equals(zeroValue.getItemValue(), EquivalenceStrategy.REAL_VALUE)) { LOGGER.trace( if (originTriples.hasPlusSet()) { for (ItemValueWithOrigin<V, D> plusValue : originTriples.getPlusSet()) { if (plusValue.getItemValue().equals(zeroValue.getItemValue(), EquivalenceStrategy.REAL_VALUE)) { LOGGER.trace( if (originTriples.hasMinusSet()) {
itemPath, ivwoTriple.debugDump(1), DebugUtil.debugDump(aprioriItemDelta, 2), DebugUtil.debugDump(itemExisting, 2)); ivwoTriple.simpleAccept(visitor); boolean ignoreNormalMappings = itemHasStrongMutable.booleanValue() && isExclusiveStrong; collectIvwosFromSet(value, ivwoTriple.getZeroSet(), false); Collection<ItemValueWithOrigin<V,D>> plusIvwos = collectIvwosFromSet(value, ivwoTriple.getPlusSet(), false); Collection<ItemValueWithOrigin<V,D>> minusIvwos = collectIvwosFromSet(value, ivwoTriple.getMinusSet(), true); Collection<? extends ItemValueWithOrigin<V,D>> nonNegativePvwos = ivwoTriple.getNonNegativeValues(); Collection<ItemValueWithOrigin<V,D>> valuesToAdd = selectWeakValues(nonNegativePvwos, OriginType.ASSIGNMENTS); if (valuesToAdd.isEmpty()) {
@SuppressWarnings("unchecked") private <F extends FocusType> Collection<EvaluatedAssignmentImpl<F>> assertAssignmentTripleSetSize(LensContext<F> context, int zero, int plus, int minus) { assertEquals("Wrong size of assignment triple zero set", zero, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getZeroSet())); assertEquals("Wrong size of assignment triple plus set", plus, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getPlusSet())); assertEquals("Wrong size of assignment triple minus set", minus, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getMinusSet())); return (Collection) context.getEvaluatedAssignmentTriple().getAllValues(); }
assertNotNull("No evaluatedAssignmentTriple", evaluatedAssignmentTriple); assertTrue("Unexpected evaluatedAssignmentTriple zero set", evaluatedAssignmentTriple.getZeroSet().isEmpty()); assertTrue("Unexpected evaluatedAssignmentTriple minus set", evaluatedAssignmentTriple.getMinusSet().isEmpty()); assertNotNull("No evaluatedAssignmentTriple plus set", evaluatedAssignmentTriple.getPlusSet()); assertEquals("Wrong size of evaluatedAssignmentTriple plus set", 1, evaluatedAssignmentTriple.getPlusSet().size()); EvaluatedAssignmentImpl<UserType> evaluatedAssignment = (EvaluatedAssignmentImpl<UserType>) evaluatedAssignmentTriple.getPlusSet().iterator().next(); display("evaluatedAssignment", evaluatedAssignment); assertNotNull("No evaluatedAssignment", evaluatedAssignment); display("personaConstructionTriple", personaConstructionTriple); assertNotNull("No personaConstructionTriple", personaConstructionTriple); assertFalse("Empty personaConstructionTriple", personaConstructionTriple.isEmpty()); assertTrue("Unexpected personaConstructionTriple plus set", personaConstructionTriple.getPlusSet().isEmpty()); assertTrue("Unexpected personaConstructionTriple minus set", personaConstructionTriple.getMinusSet().isEmpty()); assertNotNull("No personaConstructionTriple zero set", personaConstructionTriple.getZeroSet()); assertEquals("Wrong size of personaConstructionTriple zero set", 1, personaConstructionTriple.getZeroSet().size()); PersonaConstruction<UserType> personaConstruction = personaConstructionTriple.getZeroSet().iterator().next(); assertNotNull("No personaConstruction", personaConstruction); PersonaConstructionType personaConstructionType = personaConstruction.getConstructionType();
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstructionAllToMinus( Map<QName, DeltaSetTriple<ItemValueWithOrigin<V,D>>> squeezedMap, Construction<F> construction, MappingExtractor<V,D,F> extractor, AssignmentPolicyEnforcementType enforcement) { if (enforcement == AssignmentPolicyEnforcementType.NONE) { return; } for (PrismValueDeltaSetTripleProducer<V, D> mapping: extractor.getMappings(construction)) { PrismValueDeltaSetTriple<V> vcTriple = mapping.getOutputTriple(); if (vcTriple == null) { continue; } QName name = mapping.getMappingQName(); DeltaSetTriple<ItemValueWithOrigin<V,D>> squeezeTriple = getSqueezeMapTriple(squeezedMap, name); if (enforcement == AssignmentPolicyEnforcementType.POSITIVE) { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getZeroSet(), mapping, construction); } else { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
if (consolidatedTriples != null) { Collection<ItemValueWithOrigin<V, D>> shouldBeItemValues = consolidatedTriples.getNonNegativeValues(); for (ItemValueWithOrigin<V, D> itemWithOrigin : shouldBeItemValues) { shouldBeItem.add(LensUtil.cloneAndApplyMetadata(itemWithOrigin.getItemValue(), if (consolidatedTriples.hasPlusSet()) { for (ItemValueWithOrigin<V, D> valueWithOrigin : consolidatedTriples.getPlusSet()) { MappingImpl<V,D> originMapping = (MappingImpl) valueWithOrigin.getMapping(); if (targetFocusItem == null) { if (consolidatedTriples.hasMinusSet()) { LOGGER.trace("Checking account sync property delta values to delete"); for (ItemValueWithOrigin<V, D> valueWithOrigin : consolidatedTriples.getMinusSet()) { V value = valueWithOrigin.getItemValue();
outputTriple.addAllToPlusSet(outputTriple.getZeroSet()); outputTriple.clearZeroSet(); outputTriple.clearMinusSet(); } else if (plusMinusZero == PlusMinusZero.MINUS) { outputTriple.addAllToMinusSet(outputTriple.getZeroSet()); outputTriple.clearZeroSet(); outputTriple.clearPlusSet(); outputTripleMap.put(uniformItemPath, outputTriple); } else { mapTriple.merge(outputTriple);
assertEquals(1, evaluatedAssignment.getConstructionTriple().size()); PrismAsserts.assertParentConsistency(userTypeJack.asPrismObject()); Construction<UserType> construction = evaluatedAssignment.getConstructionTriple().getZeroSet().iterator().next(); assertNotNull("No object class definition in construction", construction.getRefinedObjectClassDefinition());
public static void assertTripleNoPlus(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("plus set", triple.getPlusSet()); }
ConfigurationException, SecurityViolationException, ExpressionEvaluationException, PolicyViolationException, PreconditionViolationException { DeltaSetTriple<EvaluatedAssignmentImpl<F>> evaluatedAssignmentTriple = (DeltaSetTriple)context.getEvaluatedAssignmentTriple(); if (evaluatedAssignmentTriple == null || evaluatedAssignmentTriple.isEmpty()) { return HookOperationMode.FOREGROUND; task, result); LOGGER.trace("activePersonaKeyTriple:\n{}", activePersonaKeyTriple.debugDumpLazily()); for (PersonaKey key: activePersonaKeyTriple.getNonNegativeValues()) { FocusType existingPersona = findPersona(existingPersonas, key); LOGGER.trace("existingPersona: {}", existingPersona); for (PersonaKey key: activePersonaKeyTriple.getMinusSet()) { FocusType existingPersona = findPersona(existingPersonas, key); if (existingPersona != null) {
throws PolicyViolationException, SchemaException, ExpressionEvaluationException, ObjectNotFoundException, CommunicationException, ConfigurationException, SecurityViolationException { for (EvaluatedAssignmentImpl<F> evaluatedAssignment : evaluatedAssignmentTriple.union()) { RulesEvaluationContext globalCtx = new RulesEvaluationContext(); boolean inPlus = evaluatedAssignmentTriple.presentInPlusSet(evaluatedAssignment); boolean inMinus = evaluatedAssignmentTriple.presentInMinusSet(evaluatedAssignment); boolean inZero = evaluatedAssignmentTriple.presentInZeroSet(evaluatedAssignment); exclusionConstraintEvaluator.checkExclusionsLegacy(context, evaluatedAssignmentTriple.getPlusSet(), evaluatedAssignmentTriple.getNonNegativeValues());
DeltaSetTriple<ItemValueWithOrigin<V,D>> ivwoTriple = entry.getValue(); boolean hasWeak = false; for (ItemValueWithOrigin<V,D> ivwo: ivwoTriple.getAllValues()) { PrismValueDeltaSetTripleProducer<V,D> mapping = ivwo.getMapping(); if (mapping.getStrength() == MappingStrengthType.WEAK) { if (ivwoTriple.hasMinusSet()) { for (ItemValueWithOrigin<V,D> ivwo: ivwoTriple.getMinusSet()) { PrismValueDeltaSetTripleProducer<V, D> mapping = ivwo.getMapping(); PrismValueDeltaSetTriple<?> outputTriple = mapping.getOutputTriple(); for (ItemValueWithOrigin<V,D> ivwo: ivwoTriple.getNonNegativeValues()) { PrismValueDeltaSetTripleProducer<V, D> mapping = ivwo.getMapping(); PrismValueDeltaSetTriple<?> outputTriple = mapping.getOutputTriple();
public static void assertTripleNoZero(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("zero set", triple.getZeroSet()); }
public static void assertTripleNoMinus(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("minus set", triple.getMinusSet()); }