Object getItemPathSegment() { if (itemPath.size() != 1) { throw new IllegalStateException("Expected single-item path, found '" + itemPath + "' instead."); } return itemPath.first(); }
public ResourceDataItem(@NotNull DataModel ctx, @NotNull String resourceOid, @NotNull ShadowKindType kind, @NotNull String intent, RefinedResourceSchema refinedResourceSchema, RefinedObjectClassDefinition refinedDefinition, @NotNull ItemPath itemPath) { this.ctx = ctx; this.resourceOid = resourceOid; this.kind = kind; this.intent = intent; this.itemPath = itemPath; if (itemPath.lastName() == null) { throw new IllegalArgumentException("Wrong itemPath (have a named segment): " + itemPath); } this.hasItemDefinition = itemPath.size() == 1; // TODO this.refinedResourceSchema = refinedResourceSchema; this.refinedObjectClassDefinition = refinedDefinition; }
ItemName getItemName() { if (itemPath.size() != 1) { throw new IllegalStateException("Expected single-item path, found '" + itemPath + "' instead."); } return ItemPath.toName(itemPath.first()); }
/** * Returns the last name segment index; or -1 if there's no such segment. */ default int lastNameIndex() { for (int i = size()-1; i >= 0; i--) { if (ItemPath.isName(getSegment(i))) { return i; } } return -1; }
/** * Returns the first name segment index; or -1 if there's no such segment. */ default int firstNameIndex() { for (int i = 0; i < size(); i++) { if (ItemPath.isName(getSegment(i))) { return i; } } return -1; }
private long checkPathSanity(ItemPath deltaPath, List<Long> casesAddedOrDeleted) { Object secondSegment = deltaPath.getSegment(1); if (!ItemPath.isId(secondSegment)) { throw new IllegalStateException("Couldn't update cert campaign by delta with path " + deltaPath + " - should start with case[id]"); } Long id = ItemPath.toId(secondSegment); if (id == null) { throw new IllegalStateException("Couldn't update cert campaign by delta with path " + deltaPath + " - should start with case[id]"); } if (deltaPath.size() == 2) { // not enough throw new IllegalStateException("Couldn't update cert campaign by delta with path " + deltaPath + " - should start with case[id] and contain additional path"); } if (casesAddedOrDeleted == null || casesAddedOrDeleted.contains(id)) { throw new IllegalArgumentException("Couldn't update certification case that was added/deleted in this operation. Path=" + deltaPath); } return id; }
@Override public <ID extends ItemDefinition> ID findItemDefinition(@NotNull ItemPath path, @NotNull Class<ID> clazz) { if (path.size() != 1) { return null; } ItemName first = path.firstToNameOrNull(); if (first == null) { return null; } return findLocalItemDefinition(first.asSingleName(), clazz, false); }
/** * Returns true if the path consists of a single name segment. (Not variable nor special symbol.) */ default boolean isSingleName() { return size() == 1 && ItemPath.isName(first()); }
@Override public <ID extends ItemDefinition> ID findItemDefinition(@NotNull ItemPath path, @NotNull Class<ID> clazz) { if (path.size() == 1 && path.startsWithName()) { return findLocalItemDefinition(ItemPath.toName(path.first()), clazz, false); } throw new UnsupportedOperationException("TODO implement if needed"); }
@Override public int compare(JpaLinkDefinition o1, JpaLinkDefinition o2) { // longer paths have to come first, in order for matching to work int sizeDiff = o1.getItemPath().size() - o2.getItemPath().size(); if (sizeDiff != 0) { return -sizeDiff; } JpaDataNodeDefinition target1 = o1.getTargetDefinition(); JpaDataNodeDefinition target2 = o2.getTargetDefinition(); if (target1.equals(target2)) { return String.CASE_INSENSITIVE_ORDER.compare(o1.getItemPathSegment().toString(), o2.getItemPathSegment().toString()); } return getType(target1) - getType(target2); }
public static void assertPathEqualsExceptForPrefixes(String message, ItemPath expected, ItemPath actual) { assertEquals(message + ": wrong path size", expected.size(), actual.size()); for (int i = 0; i < expected.size(); i++) { Object expectedSegment = expected.getSegment(i); Object actualSegment = actual.getSegment(i); if (ItemPath.isName(expectedSegment)) { QName qnameExpected = ItemPath.toName(expectedSegment); QName qnameActual = ItemPath.toName(actualSegment); assertEquals(message + ": wrong NS in path segment #" + (i+1), qnameExpected.getNamespaceURI(), qnameActual.getNamespaceURI()); assertEquals(message + ": wrong local part in path segment #" + (i+1), qnameExpected.getLocalPart(), qnameActual.getLocalPart()); } else { if (!ItemPath.segmentsEquivalent(expectedSegment, actualSegment)) { System.out.println("hi"); } assertTrue(message + ": wrong path segment #" + (i+1) + ": exp=" + expectedSegment + ", act=" + actualSegment, ItemPath.segmentsEquivalent(expectedSegment, actualSegment)); } } }
private ItemPath getPathToExplain(ItemDelta itemDelta) { ItemPath path = itemDelta.getPath(); for (int i = 0; i < path.size(); i++) { Object segment = path.getSegment(i); if (ItemPath.isId(segment)) { if (i < path.size()-1 || itemDelta.isDelete()) { return path.allUpToIncluding(i); } else { // this means that the path ends with [id] segment *and* the value(s) are // only added and deleted, i.e. they are shown in the delta anyway // (actually it is questionable whether path in delta can end with [id] segment, // but we test for this case just to be sure) return null; } } } return null; }
public <T extends ObjectType> Collection<? extends ItemDelta> filterLookupTableModifications(Class<T> type, Collection<? extends ItemDelta> modifications) { Collection<ItemDelta> tableDelta = new ArrayList<>(); if (!LookupTableType.class.equals(type)) { return tableDelta; } for (ItemDelta delta : modifications) { ItemPath path = delta.getPath(); if (path.isEmpty()) { throw new UnsupportedOperationException("Lookup table cannot be modified via empty-path modification"); } else if (path.equivalent(LookupTableType.F_ROW)) { tableDelta.add(delta); } else if (path.isSuperPath(LookupTableType.F_ROW)) { // should be row[id]/xxx where xxx=key|value|label? if (path.size() != 3 || !ItemPath.isId(path.getSegment(1)) || !ItemPath.isName(path.getSegment(2))) { throw new UnsupportedOperationException("Unsupported modification path for lookup tables: " + path); } tableDelta.add(delta); } } modifications.removeAll(tableDelta); return tableDelta; } }
@Override public Object resolve(ItemPath subpath) { if (subpath == null || subpath.isEmpty()) { return this; } if (subpath.size() > 1) { throw new IllegalArgumentException("Cannot resolve path "+subpath+" on polystring "+this+", the path is too deep"); } Object first = subpath.first(); if (!ItemPath.isName(first)) { throw new IllegalArgumentException("Cannot resolve non-name path "+subpath+" on polystring "+this); } QName itemName = ItemPath.toName(first); if (QNameUtil.match(F_ORIG, itemName)) { return orig; } else if (QNameUtil.match(F_NORM, itemName)) { return norm; } else { throw new IllegalArgumentException("Unknown path segment "+itemName); } }
for (int i = 0; i < path.size(); i++) { Object segment = path.getSegment(i); if (ItemPath.isName(segment)) {
public static ItemName getAttributeName(ItemPath attributePath, String message) throws SchemaException { if (attributePath == null || attributePath.isEmpty()) { return null; } Object firstPathSegment = attributePath.first(); if (!ItemPath.isName(firstPathSegment)) { throw new SchemaException(message + ": first path segment is not a name segment"); } ItemName firstName = ItemPath.toName(firstPathSegment); if (!QNameUtil.match(ShadowType.F_ATTRIBUTES, firstName)) { throw new SchemaException(message + ": first path segment is not "+ShadowType.F_ATTRIBUTES); } if (attributePath.size() < 1) { throw new SchemaException(message + ": path too short ("+attributePath.size()+" segments)"); } if (attributePath.size() > 2) { throw new SchemaException(message + ": path too long ("+attributePath.size()+" segments)"); } Object secondPathSegment = attributePath.rest().first(); if (!ItemPath.isName(secondPathSegment)) { throw new SchemaException(message + ": second path segment is not a name segment"); } return ItemPath.toName(secondPathSegment); }
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"); } }
private void checkItemRef(ResourceValidationContext ctx, ItemPath path, ResourceObjectTypeDefinitionType objectType, ResourceItemDefinitionType itemDef, String noRefKey) { ItemPath refPath = itemDef.getRef() != null ? itemDef.getRef().getItemPath() : null; if (ItemPath.isEmpty(refPath)) { ctx.validationResult.add(Issue.Severity.ERROR, CAT_SCHEMA_HANDLING, noRefKey, getString(CLASS_DOT + noRefKey, getName(objectType)), ctx.resourceRef, path.append(ItemRefinedDefinitionType.F_REF)); } else if (refPath.size() > 1 || !refPath.startsWithName()) { ctx.validationResult.add(Issue.Severity.ERROR, CAT_SCHEMA_HANDLING, C_WRONG_ITEM_NAME, getString(CLASS_DOT + C_WRONG_ITEM_NAME, getName(objectType), refPath.toString()), ctx.resourceRef, path.append(ItemRefinedDefinitionType.F_REF)); } else if (StringUtils.isBlank(refPath.asSingleName().getNamespaceURI())) { ctx.validationResult.add(Issue.Severity.WARNING, CAT_SCHEMA_HANDLING, C_NO_ITEM_NAMESPACE, getString(CLASS_DOT + C_NO_ITEM_NAMESPACE, getName(objectType), refPath.toString()), ctx.resourceRef, path.append(ItemRefinedDefinitionType.F_REF)); } }
@Override public DataSearchResult<?> nextLinkDefinition(ItemPath path, ItemDefinition<?> itemDefinition, PrismContext prismContext) throws QueryException { if (ItemPath.isEmpty(path)) { // doesn't fulfill precondition return null; } Object first = path.first(); if (ItemPath.isId(first)) { throw new QueryException("ID item path segments are not allowed in query: " + path); } else if (ItemPath.isObjectReference(first)) { throw new QueryException("'@' path segment cannot be used in the context of an entity " + this); } JpaLinkDefinition<?> link = findRawLinkDefinition(path, JpaDataNodeDefinition.class, false); if (link == null) { return null; } else { link.resolveEntityPointer(); return new DataSearchResult<>(link, path.rest(link.getItemPath().size())); } }
if (deltaPath.size() == 1) { // whole row add/delete/replace if (!(delta instanceof ContainerDelta)) { throw new IllegalStateException("Wrong table delta sneaked into updateLookupTableData: class=" + delta.getClass() + ", path=" + deltaPath); addLookupTableRows(session, tableOid, containerDelta.getValuesToReplace(), 1, false); } else if (deltaPath.size() == 3) { // row segment modification (structure is already checked) Long rowId = ItemPath.toId(deltaPath.getSegment(1)); QName name = ItemPath.toName(deltaPath.getSegment(2));