protected void assertNoPostponedOperation(PrismObject<ShadowType> shadow) { Item<PrismValue, ItemDefinition> objectChangeItem = shadow.findItem(ShadowType.F_OBJECT_CHANGE); if (objectChangeItem != null) { AssertJUnit.fail("Expected no postponed operation in "+shadow+", but found one: "+objectChangeItem); } }
public boolean hasItemDelta(ItemPath propertyPath) { if (changeType == ChangeType.ADD) { Item item = objectToAdd.findItem(propertyPath, Item.class); return item != null; } else if (changeType == ChangeType.MODIFY) { ItemDelta modification = findModification(propertyPath, ItemDelta.class, false); return modification != null; } else { return false; } }
private static boolean subtractFromObject(@NotNull PrismObject<?> object, @NotNull ItemPath itemPath, @NotNull PrismValue value, boolean dryRun) { Item<PrismValue, ItemDefinition> item = object.findItem(itemPath); if (item == null) { return false; } if (dryRun) { return item.contains(value); } else { return item.remove(value); } }
public PrismObjectAsserter<O,RA> assertNoItem(ItemPath itemPath) { Item<PrismValue, ItemDefinition> item = getObject().findItem(itemPath); assertNull("Unexpected item "+itemPath+" in "+desc(), item); return this; }
public boolean hasItemOrSubitemDelta(ItemPath propertyPath) { if (changeType == ChangeType.ADD) { // Easy case. Even if there is a sub-sub-property there must be also a container. Item item = objectToAdd.findItem(propertyPath, Item.class); return item != null; } else if (changeType == ChangeType.MODIFY) { for (ItemDelta<?,?> delta : getModifications()) { CompareResult compare = delta.getPath().compareComplex(propertyPath); if (compare == CompareResult.EQUIVALENT || compare == CompareResult.SUBPATH) { return true; } } } return false; }
public static <O extends Objectable> void setDeltaOldValue(PrismObject<O> oldObject, ItemDelta<?,?> itemDelta) { if (oldObject == null) { return; } Item<PrismValue, ItemDefinition> itemOld = oldObject.findItem(itemDelta.getPath()); if (itemOld != null) { itemDelta.setEstimatedOldValues((Collection) PrismValueCollectionsUtil.cloneCollection(itemOld.getValues())); } }
@Test public void test110FindNameItem() throws Exception { System.out.println("===[ test110FindNameItem ]==="); PrismObject<UserType> jack = getJack(); measure("findItem(name)", () -> jack.findItem(UserType.F_NAME)); }
public <IV extends PrismValue,ID extends ItemDefinition, I extends Item<IV,ID>,DD extends ItemDelta<IV,ID>> DD findItemDelta(ItemPath propertyPath, Class<DD> deltaType, Class<I> itemType, boolean strict) { if (changeType == ChangeType.ADD) { I item = objectToAdd.findItem(propertyPath, itemType); if (item == null) { return null; } DD itemDelta = createEmptyDelta(propertyPath, item.getDefinition(), deltaType, item.getClass()); itemDelta.addValuesToAdd(item.getClonedValues()); return itemDelta; } else if (changeType == ChangeType.MODIFY) { return findModification(propertyPath, deltaType, strict); } else { return null; } }
@Override public List<PrismValue> getNewValuesFor(ItemPath itemPath) { if (isAdd()) { Item<PrismValue, ItemDefinition> item = objectToAdd.findItem(itemPath); return item != null ? item.getValues() : Collections.emptyList(); } else if (isDelete()) { return Collections.emptyList(); } else { ItemDelta itemDelta = ItemDeltaCollectionsUtil.findItemDelta(modifications, itemPath, ItemDelta.class, false); if (itemDelta != null) { if (itemDelta.getValuesToReplace() != null) { return (List<PrismValue>) itemDelta.getValuesToReplace(); } else if (itemDelta.getValuesToAdd() != null) { return (List<PrismValue>) itemDelta.getValuesToAdd(); } else { return Collections.emptyList(); } } else { return Collections.emptyList(); } } }
@Test public void test130FindExtensionItem() throws Exception { System.out.println("===[ test130FindExtensionItem ]==="); PrismObject<UserType> jack = getJack(); ItemPath bar23 = ItemPath.create(UserType.F_EXTENSION, "bar23"); measure("findItem(extension/bar23)", () -> jack.findItem(bar23)); }
private FactorOutResultSingle<O> factorOutForAddDelta(Collection<? extends ItemPath> paths, boolean cloneDelta) { List<Item<?, ?>> itemsFound = new ArrayList<>(); for (ItemPath path : paths) { Item<?, ?> item = objectToAdd.findItem(path); if (item != null && !item.isEmpty()) { itemsFound.add(item); } } if (itemsFound.isEmpty()) { return new FactorOutResultSingle<>(this, null); } ObjectDeltaImpl<O> remainder = cloneIfRequested(cloneDelta); ObjectDeltaImpl<O> offspring = createOffspring(); for (Item<?, ?> item : itemsFound) { remainder.getObjectToAdd().remove(item); offspring.addModification(ItemDeltaUtil.createAddDeltaFor(item)); } return new FactorOutResultSingle<>(remainder, offspring); }
public boolean isRedundant(PrismObject<? extends Objectable> object, Comparator<V> comparator) { Item<V,D> currentItem = (Item<V,D>) object.findItem(getPath()); if (currentItem == null) { if (valuesToReplace != null) { return valuesToReplace.isEmpty(); } return !hasAnyValue(valuesToAdd); } else { if (valuesToReplace != null) { return MiscUtil.unorderedCollectionCompare(valuesToReplace, currentItem.getValues(), comparator); } ItemDeltaImpl<V,D> narrowed = (ItemDeltaImpl<V, D>) narrow(object, comparator); boolean narrowedNotEmpty = narrowed == null || narrowed.hasAnyValue(narrowed.valuesToAdd) || narrowed.hasAnyValue(narrowed.valuesToDelete); return narrowedNotEmpty; } }
public boolean hasChangeInItem(ItemPath itemPath) { if (isAdd()) { PrismObject<O> objectNew = getObjectNew(); if (objectNew == null) { return false; } Item<PrismValue,ItemDefinition> item = objectNew.findItem(itemPath); if (item == null) { return false; } List<PrismValue> values = item.getValues(); if (values == null || values.isEmpty()) { return false; } return true; } else if (isDelete()) { // We do not care any more return false; } else { for (ObjectDelta<O> delta : getAllDeltas()) { if (delta.hasItemDelta(itemPath)) { return true; } } return false; } }
private FactorOutResultMulti<O> factorOutValuesForAddDelta(ItemPath path, boolean cloneDelta) { Item<?, ?> item = objectToAdd.findItem(path); if (item == null || item.isEmpty()) { return new FactorOutResultMulti<>(this); } ObjectDeltaImpl<O> remainder = cloneIfRequested(cloneDelta); remainder.getObjectToAdd().remove(item); FactorOutResultMulti<O> rv = new FactorOutResultMulti<>(remainder); for (PrismValue value : item.getValues()) { ObjectDeltaImpl<O> offspring = createOffspring(); offspring.addModification(ItemDeltaUtil.createAddDeltaFor(item, value)); rv.offsprings.add(offspring); } return rv; }
private <D extends ItemDelta> D findModification(ItemPath propertyPath, Class<D> deltaType, boolean strict) { if (isModify()) { return ItemDeltaCollectionsUtil.findItemDelta(modifications, propertyPath, deltaType, strict); } else if (isAdd()) { Item<PrismValue, ItemDefinition> item = getObjectToAdd().findItem(propertyPath); if (item == null) { return null; } D itemDelta = (D) item.createDelta(); itemDelta.addValuesToAdd(item.getClonedValues()); return itemDelta; } else { return null; } }
public static <O extends ObjectType> void setDeltaOldValue(LensElementContext<O> ctx, ItemDelta<?,?> itemDelta) { if (itemDelta.getEstimatedOldValues() != null) { return; } if (ctx.getObjectOld() == null) { return; } Item<PrismValue, ItemDefinition> itemOld = ctx.getObjectOld().findItem(itemDelta.getPath()); if (itemOld != null) { //noinspection unchecked itemDelta.setEstimatedOldValues((Collection) PrismValueCollectionsUtil.cloneCollection(itemOld.getValues())); return; } // Here we need to distinguish whether the item is missing because it is not filled in (e.g. familyName in MID-4237) // or because it was not loaded (as for attributes or associations). if (!isItemLoadable(ctx.getObjectOld(), itemDelta.getPath())) { itemDelta.setEstimatedOldValues(emptySet()); return; } // get the old data from current object. Still better estimate than nothing if (ctx.getObjectCurrent() != null) { itemOld = ctx.getObjectCurrent().findItem(itemDelta.getPath()); if (itemOld != null) { //noinspection unchecked itemDelta.setEstimatedOldValues((Collection) PrismValueCollectionsUtil.cloneCollection(itemOld.getValues())); } } }
private void handleOneToMany(Collection collection, ItemDelta delta, Attribute attribute, Object bean, PrismObject prismObject, PrismIdentifierGenerator idGenerator) { Class outputType = getRealOutputType(attribute); Item item = prismObject.findItem(delta.getPath()); // handle replace if (delta.isReplace()) { Collection<PrismEntityPair<?>> valuesToReplace = processDeltaValues(delta.getValuesToReplace(), outputType, delta, bean); replaceValues(collection, valuesToReplace, item, idGenerator); return; } // handle add if (delta.isAdd()) { Collection<PrismEntityPair<?>> valuesToAdd = processDeltaValues(delta.getValuesToAdd(), outputType, delta, bean); addValues(collection, valuesToAdd, idGenerator); } // handle delete if (delta.isDelete()) { Collection<PrismEntityPair<?>> valuesToDelete = processDeltaValues(delta.getValuesToDelete(), outputType, delta, bean); valuesToDelete.stream().forEach(pair -> { if (pair.getRepository() instanceof EntityState) { ((EntityState) pair.getRepository()).setTransient(false); } }); deleteValues(collection, valuesToDelete, item); } }
for (ItemDelta itemMod : focusPrimaryDelta.getModifications()) { if (itemMod.getValuesToDelete() != null) { Item property = focusOld.findItem(itemMod.getPath()); assertNotNull("Deleted item " + itemMod.getParentPath() + "/" + itemMod.getElementName() + " not found in focus", property); for (Object valueToDelete : itemMod.getValuesToDelete()) {
@Test public void testComplexMatch() throws Exception { PrismObject<UserType> user = PrismTestUtil.parseObject(PrismInternalTestUtil.USER_JACK_FILE_XML); // System.out.println("user given name" + user.asObjectable().getGivenName()); System.out.println("definition: " +user.findItem(UserType.F_FAMILY_NAME).getDefinition().debugDump()); ObjectFilter filter = getPrismContext().queryFor(UserType.class) .item(UserType.F_FAMILY_NAME).eq("Sparrow") .and().item(UserType.F_FULL_NAME).contains("arr") .and() .block() .item(UserType.F_GIVEN_NAME).eq("Jack") .or().item(UserType.F_GIVEN_NAME).eq("Jackie") .endBlock() .buildFilter(); boolean match = ObjectQuery.match(user, filter, matchingRuleRegistry); AssertJUnit.assertTrue("filter does not match object", match); }
@Test public void testInboundMapping() throws Exception{ final String TEST_NAME = "testInboundMapping"; TestUtil.displayTestTitle(TEST_NAME); PrismContext prismContext = evaluator.getPrismContext(); PrismObject<ShadowType> account = PrismTestUtil.parseObject(new File(MappingTestEvaluator.TEST_DIR + "/account-inbound-mapping.xml")); Item oldItem = account.findItem(ItemPath.create(ShadowType.F_ATTRIBUTES, SchemaTestConstants.ICFS_NAME)); ItemDelta delta = prismContext.deltaFactory().property().createModificationAddProperty(SchemaTestConstants.ICFS_NAME_PATH_PARTS, (PrismPropertyDefinition) oldItem.getDefinition(), ((PrismPropertyValue) oldItem.getAnyValue()).getValue()); PrismObject<UserType> user = evaluator.getUserDefinition().instantiate(); MappingImpl<PrismPropertyValue<PolyString>,PrismPropertyDefinition<PolyString>> mapping = evaluator.createInboudMapping("mapping-inbound.xml", TEST_NAME, delta, user.asObjectable(), account.asObjectable(), null, null); OperationResult opResult = new OperationResult(TEST_NAME); mapping.evaluate(null, opResult); PrismValueDeltaSetTriple<PrismPropertyValue<PolyString>> outputTriple = mapping.getOutputTriple(); outputTriple.checkConsistence(); assertTripleZero(outputTriple, PrismTestUtil.createPolyString("pavolr")); PrismAsserts.assertTripleNoPlus(outputTriple); assertTripleNoMinus(outputTriple); }