/** * Returns the value of the first name segment or null if there's no name segment. * NOTE: The difference between firstToName and firstName is that the former always looks * at the first segment and tries to interpret it as a name. The latter, however, tries to * find the first segment of Name type. */ @Nullable default ItemName firstName() { int i = firstNameIndex(); return i >= 0 ? toName(getSegment(i)) : null; }
/** * 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; }
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; } }
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)); } } }
Object segment = path.getSegment(i); if (ItemPath.isName(segment)) { if (sb.length() > 0) {
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 preparePassword() { if (valueItemPath == null) { return; } if (!valueItemPath.startsWithName(UserType.F_CREDENTIALS)) { return; } Object secondPathSegment = valueItemPath.getSegment(1); if (!ItemPath.isName(secondPathSegment)) { return; } credentialQName = ItemPath.toName(secondPathSegment); if (!QNameUtil.match(CredentialsType.F_PASSWORD, credentialQName)) { return; } if (securityPolicy == null) { return; } credentialPolicy = SecurityUtil.getEffectivePasswordCredentialsPolicy(securityPolicy); }
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; }
Long rowId = ItemPath.toId(deltaPath.getSegment(1)); QName name = ItemPath.toName(deltaPath.getSegment(2));