private <O extends ObjectType> PrismPropertyDefinition<?> getItemDefinition(PrismObject<O> object, ItemPath path) { ItemDefinition<?> itemDef = object.getDefinition().findItemDefinition(path); if (itemDef == null) { return null; } else if (!(itemDef instanceof PrismPropertyDefinition)) { return null; } return (PrismPropertyDefinition<?>) itemDef; }
public static ReferenceDeltaImpl createModificationDelete(ItemPath path, PrismObjectDefinition<?> objectDefinition, Collection<PrismReferenceValue> refValues) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.addValuesToDelete(refValues); return referenceDelta; }
public void applyDefinition(PrismObjectDefinition<O> objectDefinition, boolean force) throws SchemaException { if (objectToAdd != null) { objectToAdd.applyDefinition(objectDefinition, force); } for (ItemDelta modification: modifications) { ItemPath path = modification.getPath(); ItemDefinition itemDefinition = objectDefinition.findItemDefinition(path); modification.applyDefinition(itemDefinition, force); } }
public static ReferenceDeltaImpl createModificationReplace(ItemPath path, PrismObjectDefinition<?> objectDefinition, Collection<PrismReferenceValue> refValues) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.setValuesToReplace(refValues); return referenceDelta; }
public static ReferenceDeltaImpl createModificationAdd(ItemPath path, PrismObjectDefinition<?> objectDefinition, PrismReferenceValue refValue) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.addValueToAdd(refValue); return referenceDelta; }
public static ReferenceDeltaImpl createModificationAdd(ItemPath path, PrismObjectDefinition<?> objectDefinition, Collection<PrismReferenceValue> refValues) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.addValuesToAdd(refValues); return referenceDelta; }
public static ReferenceDeltaImpl createModificationReplace(ItemPath path, PrismObjectDefinition<?> objectDefinition, PrismReferenceValue refValue) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(path, PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(path, referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there if (refValue == null) { referenceDelta.setValueToReplace(); } else { referenceDelta.setValueToReplace(refValue); } return referenceDelta; }
itemDefinition = objectDefinition.findItemDefinition(path.allUpToIncluding(i));
public static ReferenceDeltaImpl createModificationDelete(QName refName, PrismObjectDefinition<?> objectDefinition, PrismReferenceValue refValue) { PrismReferenceDefinition referenceDefinition = objectDefinition.findItemDefinition(ItemName.fromQName(refName), PrismReferenceDefinition.class); ReferenceDeltaImpl referenceDelta = new ReferenceDeltaImpl(ItemName.fromQName(refName), referenceDefinition, objectDefinition.getPrismContext()); // hoping the prismContext is there referenceDelta.addValueToDelete(refValue); return referenceDelta; }
private <T extends ObjectType> ItemDefinition getDefinition(Class<T> type, ItemPath path) { SchemaRegistry registry = prismContext.getSchemaRegistry(); PrismObjectDefinition objectDef = registry.findObjectDefinitionByCompileTimeClass(type); return objectDef.findItemDefinition(path); }
@Test public void test400FindNameDefinition() throws Exception { System.out.println("===[ test400FindNameDefinition ]==="); SchemaRegistry schemaRegistry = getPrismContext().getSchemaRegistry(); PrismObjectDefinition<UserType> userDefinition = schemaRegistry.findObjectDefinitionByCompileTimeClass(UserType.class); measure("userDefinition.findItemDefinition(UserType.F_NAME)", () -> userDefinition.findItemDefinition(UserType.F_NAME)); }
@Test public void test410FindAdminGuiConfigurationDefinition() throws Exception { System.out.println("===[ test410FindAdminGuiConfigurationDefinition ]==="); SchemaRegistry schemaRegistry = getPrismContext().getSchemaRegistry(); PrismObjectDefinition<UserType> userDefinition = schemaRegistry.findObjectDefinitionByCompileTimeClass(UserType.class); measure("userDefinition.findItemDefinition(UserType.F_NAME)", () -> userDefinition.findItemDefinition(UserType.F_ADMIN_GUI_CONFIGURATION)); }
@Nullable // null means not supported yet public static PathResolutionResult resolvePathForType(@NotNull Class<? extends ObjectType> clazz, @NotNull ItemPath path, @NotNull PathResolutionContext context) { PrismObjectDefinition<?> def = context.prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(clazz); if (def == null) { return new PathResolutionResult(new Issue(Issue.Severity.WARNING, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "No definition for " + clazz + " in item path: '" + path + "'", null, null)); } ItemDefinition<?> itemDef = def.findItemDefinition(path); if (itemDef != null) { return new PathResolutionResult(itemDef); } else { if (FocusType.class.equals(clazz) && context instanceof ResourceResolutionContext) { ResourceResolutionContext rctx = (ResourceResolutionContext) context; return new PathResolutionResult(new Issue(Issue.Severity.INFO, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "Couldn't verify item path '" + path + "' because specific focus type (user, role, org, ...) is not defined for kind=" + rctx.kind + ", intent=" + rctx.intent, null, null)); } else { return new PathResolutionResult(new Issue(Issue.Severity.WARNING, CAT_ITEM_PATH, C_NO_OBJECT_DEFINITION, "No definition for '" + path + "' in " + def.getName().getLocalPart(), null, null)); } } } }
private <F extends ObjectType> void setReferences(LensFocusContext<F> focusContext, QName name, Collection<PrismReferenceValue> targetState) throws SchemaException { ItemName itemName = ItemName.fromQName(name); PrismObject<F> focusOld = focusContext.getObjectOld(); if (focusOld == null) { if (targetState.isEmpty()) { return; } } else { PrismReference existingState = focusOld.findReference(itemName); if (existingState == null || existingState.isEmpty()) { if (targetState.isEmpty()) { return; } } else { // we don't use QNameUtil.match here, because we want to ensure we store qualified values there // (and newValues are all qualified) Comparator<PrismReferenceValue> comparator = (a, b) -> 2*a.getOid().compareTo(b.getOid()) + (Objects.equals(a.getRelation(), b.getRelation()) ? 0 : 1); if (MiscUtil.unorderedCollectionCompare(targetState, existingState.getValues(), comparator)) { return; } } } PrismReferenceDefinition itemDef = focusContext.getObjectDefinition().findItemDefinition(itemName, PrismReferenceDefinition.class); ReferenceDelta itemDelta = prismContext.deltaFactory().reference().create(itemName, itemDef); itemDelta.setValuesToReplace(targetState); focusContext.swallowToSecondaryDelta(itemDelta); }
private S_ValuesEntry getDeltaItemFragment(PrismContainerValue<AssignmentType> cval) throws SchemaException { PrismContainerDefinition<AssignmentType> definition = cval.getParent() != null ? cval.getParent().getDefinition() : null; if (definition == null) { // we use custom definition, if available; if not, we find the standard one definition = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(AssignmentHolderType.class) .findItemDefinition(AssignmentHolderType.F_ASSIGNMENT); } definition = definition.clone(); definition.toMutable().setMaxOccurs(1); return prismContext.deltaFor(AssignmentHolderType.class) .item(AssignmentHolderType.F_ASSIGNMENT, definition); }
private <F extends AssignmentHolderType> void executeDataReduction(LensContext<F> context, LifecycleStateActionDataReductionType dataReduction, XMLGregorianCalendar now, Task task, OperationResult result) throws SchemaException { if (dataReduction == null) { return; } LensFocusContext<F> focusContext = context.getFocusContext(); PrismObjectDefinition<F> focusDefinition = focusContext.getObjectDefinition(); for (ItemPathType purgeItemPathType : dataReduction.getPurgeItem()) { ItemPath purgeItemPath = purgeItemPathType.getItemPath(); LOGGER.trace("Purging item {} from {}", purgeItemPath, focusContext.getObjectNew()); ItemDefinition purgeItemDef = focusDefinition.findItemDefinition(purgeItemPath); ItemDelta purgeItemDelta = purgeItemDef.createEmptyDelta(purgeItemPath); purgeItemDelta.setValueToReplace(); focusContext.swallowToSecondaryDelta(purgeItemDelta); } }
protected <O extends ObjectType> void assertItemFlags(PrismObjectDefinition<O> editSchema, ItemPath itemPath, boolean expectedRead, boolean expectedAdd, boolean expectedModify) { ItemDefinition itemDefinition = editSchema.findItemDefinition(itemPath); assertEquals("Wrong readability flag for "+itemPath, expectedRead, itemDefinition.canRead()); assertEquals("Wrong addition flag for "+itemPath, expectedAdd, itemDefinition.canAdd()); assertEquals("Wrong modification flag for "+itemPath, expectedModify, itemDefinition.canModify()); }
public <O extends ObjectType> void applyObjectTemplateToDefinition(PrismObjectDefinition<O> objectDefinition, ObjectTemplateType objectTemplateType, OperationResult result) throws ObjectNotFoundException, SchemaException { if (objectTemplateType == null) { return; } for (ObjectReferenceType includeRef: objectTemplateType.getIncludeRef()) { PrismObject<ObjectTemplateType> subTemplate = cacheRepositoryService.getObject(ObjectTemplateType.class, includeRef.getOid(), null, result); applyObjectTemplateToDefinition(objectDefinition, subTemplate.asObjectable(), result); } for (ObjectTemplateItemDefinitionType templateItemDefType: objectTemplateType.getItem()) { ItemPathType ref = templateItemDefType.getRef(); if (ref == null) { throw new SchemaException("No 'ref' in item definition in "+objectTemplateType); } ItemPath itemPath = prismContext.toPath(ref); ItemDefinition itemDef = objectDefinition.findItemDefinition(itemPath); if (itemDef != null) { applyObjectTemplateItem(itemDef, templateItemDefType, "item " + itemPath + " in object type " + objectDefinition.getTypeName() + " as specified in item definition in " + objectTemplateType); } else { OperationResult subResult = result.createMinorSubresult(SchemaTransformer.class.getName() + ".applyObjectTemplateToDefinition"); subResult.recordPartialError("No definition for item " + itemPath + " in object type " + objectDefinition.getTypeName() + " as specified in item definition in " + objectTemplateType); continue; } } }
@Test public void testWildOwnerRef() throws SchemaException { final String oid = SystemObjectsType.USER_ADMINISTRATOR.value(); ItemDefinition<?> ownerRefDef = prismContext.getSchemaRegistry().findObjectDefinitionByCompileTimeClass(RoleType.class).findItemDefinition(RoleType.F_OWNER_REF); ObjectQuery query = prismContext.queryFor(ObjectType.class) .item(ItemPath.create(new QName(SchemaConstants.NS_C, "ownerRef")), ownerRefDef).ref(oid) .build(); OperationResult result = new OperationResult("search"); try { repositoryService.searchObjects(ObjectType.class, query, null, result); fail("Ambiguous searchObjects succeeded even if it should have failed."); } catch (SystemException e) { assertTrue("Wrong exception message: " + e.getMessage(), e.getMessage().contains("Unable to determine root entity for ownerRef")); } }
private void assertObjectTemplateInternals(PrismObject<ObjectTemplateType> object, QName elementName) throws SchemaException { int assignmentValuesFound = 0; for (ObjectTemplateMappingType mappingType : object.asObjectable().getMapping()) { if (mappingType.getExpression() != null) { if (mappingType.getTarget() != null && mappingType.getTarget().getPath() != null && UserType.F_ASSIGNMENT.equivalent(mappingType.getTarget().getPath().getItemPath())) { ItemDefinition assignmentDef = getPrismContext().getSchemaRegistry() .findObjectDefinitionByCompileTimeClass(UserType.class) .findItemDefinition(UserType.F_ASSIGNMENT); for (JAXBElement evaluator : mappingType.getExpression().getExpressionEvaluator()) { if (evaluator.getValue() instanceof RawType) { RawType rawType = (RawType) evaluator.getValue(); System.out.println("\nraw assignment:\n" + rawType); Item assignment = rawType.getParsedItem(assignmentDef); System.out.println("\nassignment:\n" + assignment.debugDump()); assignmentValuesFound++; } } } } } assertEquals("wrong # of assignment values found in mapping", 2, assignmentValuesFound); }