/** * Create an instance of {@link OrderConstraintsType } * */ public OrderConstraintsType createOrderConstraintsType() { return new OrderConstraintsType(); }
private List<OrderConstraintsType> defaultOrderConstraints() { return Collections.singletonList(new OrderConstraintsType(prismContext).order(1)); }
public OrderConstraintsType order(Integer value) { setOrder(value); return this; }
@Override protected OrderConstraintsType createItem(PrismContainerValue value) { OrderConstraintsType targetOrderConstraint = new OrderConstraintsType(); targetOrderConstraint.setupContainerValue(value); return targetOrderConstraint; }
public OrderConstraintsType clone() { OrderConstraintsType object = new OrderConstraintsType(); PrismContainerValue value = asPrismContainerValue().clone(); object.setupContainerValue(value); return object; }
private static boolean isMatchingConstraint(OrderConstraintsType orderConstraint, EvaluationOrder evaluationOrder) { int evaluationOrderInt = evaluationOrder.getMatchingRelationOrder(orderConstraint.getRelation()); if (orderConstraint.getOrder() != null) { return orderConstraint.getOrder() == evaluationOrderInt; } else { int orderMin = 1; int orderMax = 1; if (orderConstraint.getOrderMin() != null) { orderMin = XsdTypeMapper.multiplicityToInteger(orderConstraint.getOrderMin()); } if (orderConstraint.getOrderMax() != null) { orderMax = XsdTypeMapper.multiplicityToInteger(orderConstraint.getOrderMax()); } return XsdTypeMapper.isMatchingMultiplicity(evaluationOrderInt, orderMin, orderMax); } }
constraints = Collections.singletonList(new OrderConstraintsType(prismContext) .order(order) .resetOrder(newOrder)); Integer resetSummaryTo = summaryConstraints != null && summaryConstraints.getResetOrder() != null ? summaryConstraints.getResetOrder() : null; if (constraint.getResetOrder() != null && constraint.getRelation() != null) { LOGGER.debug("Going back {}: an inducement with non-summary resetting constraint found" + " in the chain (at position -{}): {} in {}", summaryBackwards, assignmentPath.size()-i, if (constraint.getRelation() != null && constraint.getResetOrder() != null) { LOGGER.warn("Ignoring resetOrder (with a value of {} for {}) because summary order was already moved backwards by {} to {}: {}", constraint.getResetOrder(), constraint.getRelation(), summaryBackwards, evaluationOrderHolder.getValue().getSummaryOrder(), constraint); EvaluationOrder beforeChange = evaluationOrderHolder.getValue().clone(); for (OrderConstraintsType constraint : constraints) { if (constraint.getResetOrder() != null) { assert constraint.getRelation() != null; // already processed above int currentOrder = evaluationOrderHolder.getValue().getMatchingRelationOrder(constraint.getRelation()); int newOrder = constraint.getResetOrder(); if (newOrder > currentOrder) { LOGGER.warn("Cannot increase evaluation order for {} from {} to {}: {}", constraint.getRelation(), currentOrder, newOrder, constraint); } else if (newOrder < currentOrder) { evaluationOrderHolder.setValue(evaluationOrderHolder.getValue().resetOrder(constraint.getRelation(), newOrder)); LOGGER.trace("Reset order for {} from {} to {} -> {}", constraint.getRelation(), currentOrder, newOrder, evaluationOrderHolder.getValue()); } else {
private List<OrderConstraintsType> deterimneOrderConstraints(QName assignmentElementQName, AssignmentType changedAssignment) { OrderConstraintsType orderConstraints = new OrderConstraintsType(); if (FocusType.F_ASSIGNMENT.equals(assignmentElementQName)) { orderConstraints.setOrder(0); } else { List<OrderConstraintsType> assignmentOrderConstraints = changedAssignment.getOrderConstraint(); if (!assignmentOrderConstraints.isEmpty()) { return assignmentOrderConstraints; } Integer assignmentOrder = changedAssignment.getOrder(); if (assignmentOrder == null) { orderConstraints.setOrder(1); } else { orderConstraints.setOrder(assignmentOrder); } } List<OrderConstraintsType> orderConstraintsList = new ArrayList<>(1); orderConstraintsList.add(orderConstraints); return orderConstraintsList; }
.orderMin("1") .orderMax("unbounded") .resetOrder(1) .end(); org1.getInducement().add(inducement); .order(1) .relation(SchemaConstants.ORG_MANAGER) .<AssignmentType>end() .beginOrderConstraint() .resetOrder(0) .relation(SchemaConstants.ORG_DEFAULT) .end(); org2.getInducement().add(inducement2); AssignmentType inducement4 = ObjectTypeUtil.createAssignmentTo(roleAdmin.asPrismObject(), prismContext) .beginOrderConstraint() .orderMin("0") .orderMax("unbounded") .resetOrder(0) .relation(SchemaConstants.ORG_APPROVER) .<AssignmentType>end() .beginOrderConstraint() .orderMin("0") .orderMax("unbounded") .resetOrder(1) .relation(SchemaConstants.ORG_DEFAULT) .<AssignmentType>end() .focusType(UserType.COMPLEX_TYPE);
public static OrderConstraintsType getConstraintFor(List<OrderConstraintsType> constraints, QName relation) { return CollectionUtils.emptyIfNull(constraints).stream() .filter(c -> QNameUtil.match(c.getRelation(), relation)) // intentionally not using default/null equivalence here .findFirst().orElse(null); }
public static void shortDump(StringBuilder sb, OrderConstraintsType constraints) { if (constraints == null) { sb.append("null"); return; } Integer order = constraints.getOrder(); if (order != null) { sb.append(order); } String orderMin = constraints.getOrderMin(); String orderMax = constraints.getOrderMax(); if (orderMin != null || orderMax != null) { sb.append("<").append(orderMin).append(",").append(orderMax).append(">"); } QName relation = constraints.getRelation(); if (relation != null) { sb.append(",relation=").append(prettyPrint(relation)); } Integer resetOrder = constraints.getResetOrder(); if (resetOrder != null) { sb.append(",resetOrder=").append(resetOrder); } }
@Override protected OrderConstraintsType createItem(PrismContainerValue value) { OrderConstraintsType orderConstraint = new OrderConstraintsType(); orderConstraint.setupContainerValue(value); return orderConstraint; }
OrderConstraintsType orderConstraints = new OrderConstraintsType(); orderConstraints.setOrder(assignmentOrder); List<OrderConstraintsType> orderConstraintsList = new ArrayList<>(1); orderConstraintsList.add(orderConstraints);
static boolean computeMatchingOrder(EvaluationOrder evaluationOrder, Integer assignmentOrder, List<OrderConstraintsType> assignmentOrderConstraint) { boolean rv; List<QName> extraRelations = new ArrayList<>(evaluationOrder.getExtraRelations()); if (assignmentOrder == null && assignmentOrderConstraint.isEmpty()) { // compatibility rv = evaluationOrder.getSummaryOrder() == 1; } else { rv = true; if (assignmentOrder != null) { if (evaluationOrder.getSummaryOrder() != assignmentOrder) { rv = false; } } for (OrderConstraintsType orderConstraint : assignmentOrderConstraint) { if (!isMatchingConstraint(orderConstraint, evaluationOrder)) { rv = false; break; } extraRelations.removeIf(r -> QNameUtil.match(r, orderConstraint.getRelation())); } } // TODO this is to be reconsidered -- why do we consider assignment of relation e.g. approver non-matching? if (!extraRelations.isEmpty()) { rv = false; } LOGGER.trace("computeMatchingOrder => {}, for assignment.order={}, assignment.orderConstraint={}, evaluationOrder={}, remainingExtraRelations={}", rv, assignmentOrder, assignmentOrderConstraint, evaluationOrder, extraRelations); return rv; }
public static String dumpInducementConstraints(AssignmentType assignmentType) { if (assignmentType.getOrder() != null) { return assignmentType.getOrder().toString(); } if (assignmentType.getOrderConstraint().isEmpty()) { return "1"; } StringBuilder sb = new StringBuilder(); for (OrderConstraintsType orderConstraint: assignmentType.getOrderConstraint()) { if (orderConstraint.getRelation() != null) { sb.append(orderConstraint.getRelation().getLocalPart()); } else { sb.append("null"); } sb.append(":"); if (orderConstraint.getOrder() != null) { sb.append(orderConstraint.getOrder()); } else { sb.append(orderConstraint.getOrderMin()); sb.append("-"); sb.append(orderConstraint.getOrderMax()); } sb.append(","); } sb.setLength(sb.length() - 1); return sb.toString(); }
/** * Create an instance of {@link OrderConstraintsType } * */ public OrderConstraintsType createOrderConstraintsType() { return new OrderConstraintsType(); }
@Override protected OrderConstraintsType createItem(PrismContainerValue value) { OrderConstraintsType orderConstraint = new OrderConstraintsType(); orderConstraint.setupContainerValue(value); return orderConstraint; }
autzOrderMax = 0; } else { if (autzOrderConstraints.getRelation() != null) { throw new UnsupportedOperationException("Complex order constaints with relation not supported in authorizations"); if (autzOrderConstraints.getResetOrder() != null) { throw new UnsupportedOperationException("Complex order constaints with resetOrder not supported in authorizations"); Integer autzOrder = autzOrderConstraints.getOrder(); autzOrderMin = XsdTypeMapper.multiplicityToInteger(autzOrderConstraints.getOrderMin()); if (autzOrderMin == null) { if (autzOrder == null) { autzOrderMax = XsdTypeMapper.multiplicityToInteger(autzOrderConstraints.getOrderMax()); if (autzOrderMax == null) { if (autzOrder == null) { Integer paramOrder = paramOrderConstraint.getOrder(); Integer paramOrderMin = XsdTypeMapper.multiplicityToInteger(paramOrderConstraint.getOrderMin()); if (paramOrderMin == null) { paramOrderMin = paramOrder; Integer paramOrderMax = XsdTypeMapper.multiplicityToInteger(paramOrderConstraint.getOrderMax()); if (paramOrderMax == null) { paramOrderMax = paramOrder;
/** * Create an instance of {@link OrderConstraintsType } * */ public OrderConstraintsType createOrderConstraintsType() { return new OrderConstraintsType(); }
public OrderConstraintsType beginOrderConstraints() { OrderConstraintsType value = new OrderConstraintsType(); orderConstraints(value); return value; }