private List<PrismContainerValue<T>> getValues() { return container.getValues(); }
private boolean isContainerSingleValued(PrismContainerDefinition<?> def, PrismContainer<?> pc) { if (def == null) { return pc.getValues().size() <= 1; } else { return def.isSingleValue(); } }
private void collectAssignments(PrismContainer<AssignmentType> assignmentContainer, Mode mode) throws SchemaException { if (assignmentContainer == null) { return; } for (PrismContainerValue<AssignmentType> assignmentCVal: assignmentContainer.getValues()) { collectAssignment(assignmentCVal, mode, false); } }
private <C extends Containerable, O extends ObjectType> Collection<PrismContainerValue<C>> determineContainerValuesFromCurrentObject( ItemPath path, PrismObject<O> currentObject) { PrismContainer<C> container = currentObject.findContainer(path); if (container == null) { return null; } return container.getValues(); }
public void mergeValues(PrismContainer<C> other) throws SchemaException { mergeValues(other.getValues()); }
private void collectUsedIds(List<PrismContainer<?>> containers) { for (PrismContainer<?> c : containers) { for (PrismContainerValue<?> val : c.getValues()) { if (val.getId() != null) { usedIds.add(val.getId()); } } } }
public PrismContainerValue<?> getExtensionContainerValue() { PrismContainer<?> extension = getExtension(); if (extension == null || extension.getValues().isEmpty()) { return null; } else { return extension.getValue(); } }
public static void assertItems(PrismContainer<?> object, int expectedNumberOfItems) { List<PrismContainerValue> values = (List)object.getValues(); if (expectedNumberOfItems == 0) { if (values.isEmpty()) { return; } } if (values.size() > 1) { fail("More than one value in "+object); } PrismContainerValue cval = values.get(0); assertEquals("Wrong number of items in "+object, expectedNumberOfItems, cval.getItems().size()); }
private <F extends FocusType, T extends ObjectType> void applyAssignmentMetadataObject(LensContext<F> context, PrismObject<T> objectToAdd, XMLGregorianCalendar now, Task task, OperationResult result) throws SchemaException { PrismContainer<AssignmentType> assignmentContainer = objectToAdd.findContainer(FocusType.F_ASSIGNMENT); if (assignmentContainer != null) { for (PrismContainerValue<AssignmentType> assignmentContainerValue: assignmentContainer.getValues()) { applyAssignmentValueMetadataAdd(context, assignmentContainerValue, "ADD", now, task, result); } } }
private void formatPrismContainer(StringBuilder sb, String prefix, Item item, boolean mightBeRemoved, List<ItemPath> hiddenPaths, boolean showOperationalAttributes) { for (PrismContainerValue subContainerValue : ((PrismContainer<? extends Containerable>) item).getValues()) { String prefixSubContainer = prefix + " "; StringBuilder valueSb = new StringBuilder(); formatContainerValue(valueSb, prefixSubContainer, subContainerValue, mightBeRemoved, hiddenPaths, showOperationalAttributes); if (valueSb.length() > 0) { sb.append(prefix); sb.append(" - "); sb.append(getItemLabel(item)); if (subContainerValue.getId() != null) { sb.append(" #").append(subContainerValue.getId()); } sb.append(":\n"); sb.append(valueSb.toString()); } } }
public static<C extends Containerable> void assertValueId(Long expectedId, PrismContainer<C> container) { List<Long> ids = new ArrayList<>(); for (PrismContainerValue<C> value: container.getValues()) { if (MiscUtil.equals(expectedId, value.getId())) { return; } ids.add(value.getId()); } assert false : "Expected that container "+container+" will have value id '"+expectedId+"' but it has not; existing IDs: "+ids; }
public void removePaths(List<? extends ItemPath> remove) { if (items != null) { for (Iterator<Item<?, ?>> iterator = items.iterator(); iterator.hasNext(); ) { Item<?, ?> item = iterator.next(); ItemPath itemPath = item.getPath().removeIds(); if (ItemPathCollectionsUtil.containsEquivalent(remove, itemPath)) { iterator.remove(); } else if (ItemPathCollectionsUtil.containsSuperpath(remove, itemPath)) { if (item instanceof PrismContainer) { ((PrismContainer<?>) item).getValues().forEach(v -> v.removePaths(remove)); } } } } }
public void processEntitlementsAdd(ProvisioningContext ctx, PrismObject<ShadowType> shadow) throws SchemaException, ConfigurationException, ObjectNotFoundException, CommunicationException, ExpressionEvaluationException { PrismContainer<ShadowAssociationType> associationContainer = shadow.findContainer(ShadowType.F_ASSOCIATION); if (associationContainer == null || associationContainer.isEmpty()) { return; } Map<QName, PropertyModificationOperation> operationMap = new HashMap<>(); collectEntitlementToAttrsDelta(ctx, operationMap, associationContainer.getValues(), ModificationType.ADD); for (PropertyModificationOperation operation : operationMap.values()) { operation.getPropertyDelta().applyTo(shadow); } }
public <T> PrismObject<ShadowType> collectEntitlementsAsObjectOperationInShadowAdd(ProvisioningContext ctx, Map<ResourceObjectDiscriminator, ResourceObjectOperations> roMap, PrismObject<ShadowType> shadow, OperationResult result) throws SchemaException, ObjectNotFoundException, CommunicationException, SecurityViolationException, ConfigurationException, ExpressionEvaluationException { PrismContainer<ShadowAssociationType> associationContainer = shadow.findContainer(ShadowType.F_ASSOCIATION); if (associationContainer == null || associationContainer.isEmpty()) { return shadow; } return collectEntitlementsAsObjectOperation(ctx, roMap, associationContainer.getValues(), null, shadow, ModificationType.ADD, result); }
private boolean containsItem(PrismContainer container, ItemPath itemPath) { if (container.size() == 0) { return false; // there is a container, but no values } if (itemPath.isEmpty()) { return true; } for (Object o : container.getValues()) { if (containsItem((PrismContainerValue) o, itemPath)) { return true; } } return false; }
private static void mergeExtensionContainers(Item<PrismContainerValue<AssignmentType>,PrismContainerDefinition<AssignmentType>> dstItem, PrismContainer<Containerable> srcExtension) throws SchemaException { if (dstItem == null) { return; } PrismContainer<AssignmentType> dstContainer = (PrismContainer<AssignmentType>) dstItem; if (srcExtension != null && !srcExtension.isEmpty()) { PrismContainer<?> dstExtensionContainer = dstContainer.findOrCreateContainer(AssignmentType.F_EXTENSION); PrismContainerValue<?> dstExtensionContainerValue = dstExtensionContainer.getValues().isEmpty() ? dstExtensionContainer.createNewValue() : dstExtensionContainer.getValue(); ObjectTypeUtil.mergeExtension(dstExtensionContainerValue, srcExtension.getValue()); } }
@Override public <C extends Containerable> void setExtensionContainer(PrismContainer<C> container) throws SchemaException { processModificationBatched(setExtensionContainerAndPrepareDelta(container.getElementName(), container.getDefinition(), PrismValueCollectionsUtil.cloneCollection(container.getValues()))); }
public static Long getAssignmentIdFromDeltaPath(PrismContainer<AssignmentType> assignmentsOld, ItemPath path) throws SchemaException { assert path.size() > 1; Object idSegment = path.getSegment(1); if (ItemPath.isId(idSegment)) { return ItemPath.toId(idSegment); } // id-less path, e.g. assignment/validFrom -- we try to determine ID from the objectOld. if (assignmentsOld.size() == 0) { return null; } else if (assignmentsOld.size() == 1) { return assignmentsOld.getValues().get(0).getId(); } else { throw new SchemaException("Illegal path " + path + ": cannot determine which assignment to modify"); } }
protected void assertAssignmentsWithTargets(PrismObject<UserType> user, int expectedNumber) { PrismContainer<AssignmentType> assignmentContainer = user.findContainer(UserType.F_ASSIGNMENT); assertEquals("Unexpected number of assignments in "+user, expectedNumber, assignmentContainer.size()); for (PrismContainerValue<AssignmentType> cval: assignmentContainer.getValues()) { assertNotNull("No targetRef in assignment in "+user, cval.asContainerable().getTargetRef()); } }
private void assertLookupRow(PrismContainer<LookupTableRowType> tableContainer, String key, String value, String label) { for (PrismContainerValue<LookupTableRowType> row: tableContainer.getValues()) { LookupTableRowType rowType = row.asContainerable(); if (key.equals(rowType.getKey())) { assertEquals("Wrong value for key "+key, value, rowType.getValue()); if (label == null) { assertNull("Unexpected label for key "+key+": "+rowType.getLabel(), rowType.getLabel()); } else { assertEquals("Wrong label for key "+key, PrismTestUtil.createPolyStringType(label), rowType.getLabel()); } return; } } AssertJUnit.fail("Row with key '"+key+"' was not found in lookup table"); }