public List<EvaluatedAssignmentTargetImpl> getNonNegativeTargets() { List<EvaluatedAssignmentTargetImpl> rv = new ArrayList<>(); rv.addAll(roles.getZeroSet()); rv.addAll(roles.getPlusSet()); return rv; }
public static void assertTripleNoZero(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("zero set", triple.getZeroSet()); }
public void merge(DeltaSetTriple<T> triple) { zeroSet.addAll(triple.getZeroSet()); plusSet.addAll(triple.getPlusSet()); minusSet.addAll(triple.getMinusSet()); }
public static <T> void diff(Collection<T> valuesOld, Collection<T> valuesNew, DeltaSetTriple<T> triple) { if (valuesOld == null && valuesNew == null) { // No values, no change -> empty triple return; } if (valuesOld == null) { triple.getPlusSet().addAll(valuesNew); return; } if (valuesNew == null) { triple.getMinusSet().addAll(valuesOld); return; } for (T val : valuesOld) { if (valuesNew.contains(val)) { triple.getZeroSet().add(val); } else { triple.getMinusSet().add(val); } } for (T val : valuesNew) { if (!valuesOld.contains(val)) { triple.getPlusSet().add(val); } } }
public Collection<Construction<AH>> getConstructionSet(PlusMinusZero whichSet) { switch (whichSet) { case ZERO: return getConstructionTriple().getZeroSet(); case PLUS: return getConstructionTriple().getPlusSet(); case MINUS: return getConstructionTriple().getMinusSet(); default: throw new IllegalArgumentException("whichSet: " + whichSet); } }
private Collection<V> collectAllValues() throws SchemaException { Collection<V> allValues = new HashSet<>(); collectAllValuesFromSet(allValues, ivwoTriple.getZeroSet()); collectAllValuesFromSet(allValues, ivwoTriple.getPlusSet()); collectAllValuesFromSet(allValues, ivwoTriple.getMinusSet()); return allValues; }
public <F extends FocusType, K, T extends AbstractConstruction> void collectToConstructionMaps(LensContext<F> context, DeltaSetTriple<EvaluatedAssignmentImpl<F>> evaluatedAssignmentTriple, DeltaMapTriple<K, ConstructionPack<T>> constructionMapTriple, Function<EvaluatedAssignmentImpl<F>,DeltaSetTriple<T>> constructionTripleExtractor, FailableLensFunction<T,K> keyGenerator, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getZeroSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.ZERO, task, result); collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getPlusSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.PLUS, task, result); collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getMinusSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.MINUS, task, result); }
private <AH extends AssignmentHolderType> void evaluateConstructions(LensContext<AH> context, DeltaSetTriple<EvaluatedAssignmentImpl<AH>> evaluatedAssignmentTriple, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, SecurityViolationException, ConfigurationException, CommunicationException { evaluateConstructions(context, evaluatedAssignmentTriple.getZeroSet(), task, result); evaluateConstructions(context, evaluatedAssignmentTriple.getPlusSet(), task, result); evaluateConstructions(context, evaluatedAssignmentTriple.getMinusSet(), task, result); }
private <F extends FocusType, K, T extends AbstractConstruction> void collectToConstructionMapFromEvaluatedAssignments(LensContext<F> context, Collection<EvaluatedAssignmentImpl<F>> evaluatedAssignments, DeltaMapTriple<K, ConstructionPack<T>> constructionMapTriple, Function<EvaluatedAssignmentImpl<F>,DeltaSetTriple<T>> constructionTripleExtractor, FailableLensFunction<T,K> keyGenerator, PlusMinusZero mode, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { for (EvaluatedAssignmentImpl<F> evaluatedAssignment: evaluatedAssignments) { if (LOGGER.isTraceEnabled()) { LOGGER.trace("Collecting constructions from evaluated assignment:\n{}", evaluatedAssignment.debugDump(1)); } DeltaSetTriple<T> constructionTriple = constructionTripleExtractor.apply(evaluatedAssignment); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getZeroSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.ZERO, task, result); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getPlusSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.PLUS, task, result); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getMinusSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.MINUS, task, result); } }
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); } } }
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstructionNonminusToMinus( 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); } else { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstruction( 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); convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getPlusSet(), mapping, construction); if (enforcement == AssignmentPolicyEnforcementType.POSITIVE) { convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getZeroSet(), mapping, construction); } else { convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
display("evaluatedAssignmentTriple", evaluatedAssignmentTriple); assertEquals("Wrong # of evaluated assignments in zero set", 1, evaluatedAssignmentTriple.getZeroSet().size()); EvaluatedAssignment<?> evaluatedAssignment = evaluatedAssignmentTriple.getZeroSet().iterator().next(); assertNotNull("Target of evaluated assignment is null", evaluatedAssignment.getTarget()); assertEquals("Wrong # of zero-set roles in evaluated assignment", 1, evaluatedAssignment.getRoles().getZeroSet().size());
/** * Check if all the roles are visible in preview changes */ @Test public void test135PreviewChangesEmptyDelta() throws Exception { final String TEST_NAME = "test135PreviewChangesEmptyDelta"; displayTestTitle(TEST_NAME); Task task = createTask(TEST_NAME); OperationResult result = task.getResult(); PrismObject<UserType> user = getUser(USER_JACK_OID); ObjectDelta<UserType> delta = user.createModifyDelta(); // WHEN ModelContext<ObjectType> modelContext = modelInteractionService.previewChanges(MiscSchemaUtil.createCollection(delta), getDefaultOptions(), task, result); // THEN result.computeStatus(); TestUtil.assertSuccess(result); DeltaSetTriple<? extends EvaluatedAssignment> evaluatedAssignmentTriple = modelContext.getEvaluatedAssignmentTriple(); PrismAsserts.assertTripleNoPlus(evaluatedAssignmentTriple); PrismAsserts.assertTripleNoMinus(evaluatedAssignmentTriple); Collection<? extends EvaluatedAssignment> evaluatedAssignments = evaluatedAssignmentTriple.getZeroSet(); assertEquals("Wrong number of evaluated assignments", 1, evaluatedAssignments.size()); EvaluatedAssignment<UserType> evaluatedAssignment = evaluatedAssignments.iterator().next(); DeltaSetTriple<? extends EvaluatedAssignmentTarget> rolesTriple = evaluatedAssignment.getRoles(); PrismAsserts.assertTripleNoPlus(rolesTriple); PrismAsserts.assertTripleNoMinus(rolesTriple); Collection<? extends EvaluatedAssignmentTarget> evaluatedRoles = rolesTriple.getZeroSet(); assertEquals("Wrong number of evaluated role", 2, evaluatedRoles.size()); assertEvaluatedRole(evaluatedRoles, ROLE_ADRIATIC_PIRATE_OID); assertEvaluatedRole(evaluatedRoles, ROLE_PIRATE_OID); }
EvaluatedAssignment<?> evaluatedAssignment = evaluatedAssignmentTriple.getPlusSet().iterator().next(); assertNotNull("Target of evaluated assignment is null", evaluatedAssignment.getTarget()); assertEquals("Wrong # of zero-set roles in evaluated assignment", 1, evaluatedAssignment.getRoles().getZeroSet().size());
@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(); }
PrismAsserts.assertParentConsistency(userTypeJack.asPrismObject()); Construction<UserType> construction = evaluatedAssignment.getConstructionTriple().getZeroSet().iterator().next(); assertNotNull("No object class definition in construction", construction.getRefinedObjectClassDefinition());
private void assertTargets(EvaluatedAssignmentImpl<? extends FocusType> evaluatedAssignment, Boolean evaluateConstructions, List<String> zeroValid, List<String> zeroInvalid, List<String> plusValid, List<String> plusInvalid, List<String> minusValid, List<String> minusInvalid) { assertTargets("zero", evaluatedAssignment.getRoles().getZeroSet(), evaluateConstructions, zeroValid, zeroInvalid); assertTargets("plus", evaluatedAssignment.getRoles().getPlusSet(), evaluateConstructions, plusValid, plusInvalid); assertTargets("minus", evaluatedAssignment.getRoles().getMinusSet(), evaluateConstructions, minusValid, minusInvalid); }
PrismAsserts.assertParentConsistency(userTypeJack.asPrismObject()); Construction<UserType> construction = evaluatedAssignment.getConstructionTriple().getZeroSet().iterator().next(); display("Evaluated construction", construction); assertNotNull("No object class definition in construction", construction.getRefinedObjectClassDefinition());
assertEquals("Wrong # of evaluated assignments zero set", 0, triple.getZeroSet().size()); assertEquals("Wrong # of evaluated assignments plus set", 1, triple.getPlusSet().size()); assertEquals("Wrong # of evaluated assignments minus set", 1, triple.getMinusSet().size());