@Override public String toString() { return definition.getName(); } }
@Override public String toString() { return definition.getName(); } }
@Override public String toString() { return definition.getName(); } }
@Override public String getName() { return namePathMapper.getJcrName(definition.getName()); }
@Override public String getName() { return def.getName(); }
@Override public String getName() { return namePathMapper.getJcrName(definition.getName()); }
@Override public String getName() { return namePathMapper.getJcrName(definition.getName()); }
@Override public Privilege[] getDeclaredAggregatePrivileges() { Set<String> declaredAggregateNames = definition.getDeclaredAggregateNames(); Set<Privilege> declaredAggregates = new HashSet<>(declaredAggregateNames.size()); for (String oakName : declaredAggregateNames) { if (oakName.equals(definition.getName())) { log.warn("Found cyclic privilege aggregation -> ignore declared aggregate " + oakName); continue; } PrivilegeDefinition def = getPrivilegeDefinition(oakName); if (def != null) { declaredAggregates.add(getPrivilege(def)); } else { log.warn("Invalid privilege '{}' in declared aggregates of '{}'", oakName, getName()); } } return declaredAggregates.toArray(new Privilege[0]); }
@Override public Privilege[] getDeclaredAggregatePrivileges() { Set<String> declaredAggregateNames = definition.getDeclaredAggregateNames(); Set<Privilege> declaredAggregates = new HashSet(declaredAggregateNames.size()); for (String oakName : declaredAggregateNames) { if (oakName.equals(definition.getName())) { log.warn("Found cyclic privilege aggregation -> ignore declared aggregate " + oakName); continue; } PrivilegeDefinition def = getPrivilegeDefinition(oakName); if (def != null) { declaredAggregates.add(getPrivilege(def)); } else { log.warn("Invalid privilege '{}' in declared aggregates of '{}'", oakName, getName()); } } return declaredAggregates.toArray(new Privilege[declaredAggregates.size()]); }
@Override public Privilege[] getDeclaredAggregatePrivileges() { Set<String> declaredAggregateNames = definition.getDeclaredAggregateNames(); Set<Privilege> declaredAggregates = new HashSet<>(declaredAggregateNames.size()); for (String oakName : declaredAggregateNames) { if (oakName.equals(definition.getName())) { log.warn("Found cyclic privilege aggregation -> ignore declared aggregate " + oakName); continue; } PrivilegeDefinition def = getPrivilegeDefinition(oakName); if (def != null) { declaredAggregates.add(getPrivilege(def)); } else { log.warn("Invalid privilege '{}' in declared aggregates of '{}'", oakName, getName()); } } return declaredAggregates.toArray(new Privilege[0]); }
/** * Read all registered privilege definitions from the content. * * @return All privilege definitions stored in the content. */ @NotNull Map<String, PrivilegeDefinition> readDefinitions() { Map<String, PrivilegeDefinition> definitions = new HashMap<>(); for (Tree child : privilegesTree.getChildren()) { if (isPrivilegeDefinition(child)) { PrivilegeDefinition def = PrivilegeUtil.readDefinition(child); definitions.put(def.getName(), def); } } return definitions; }
/** * Read all registered privilege definitions from the content. * * @return All privilege definitions stored in the content. */ @Nonnull Map<String, PrivilegeDefinition> readDefinitions() { Map<String, PrivilegeDefinition> definitions = new HashMap(); for (Tree child : privilegesTree.getChildren()) { if (isPrivilegeDefinition(child)) { PrivilegeDefinition def = PrivilegeUtil.readDefinition(child); definitions.put(def.getName(), def); } } return definitions; }
/** * Read all registered privilege definitions from the content. * * @return All privilege definitions stored in the content. */ @NotNull Map<String, PrivilegeDefinition> readDefinitions() { Map<String, PrivilegeDefinition> definitions = new HashMap<>(); for (Tree child : privilegesTree.getChildren()) { if (isPrivilegeDefinition(child)) { PrivilegeDefinition def = PrivilegeUtil.readDefinition(child); definitions.put(def.getName(), def); } } return definitions; }
private void writePrivilegeNode(@NotNull Tree privilegesTree, @NotNull PrivilegeDefinition definition) throws RepositoryException { String name = definition.getName(); Tree privNode = TreeUtil.addChild(privilegesTree, name, NT_REP_PRIVILEGE); if (definition.isAbstract()) { privNode.setProperty(REP_IS_ABSTRACT, true); } Set<String> declAggrNames = definition.getDeclaredAggregateNames(); boolean isAggregate = !declAggrNames.isEmpty(); if (isAggregate) { privNode.setProperty(REP_AGGREGATES, declAggrNames, Type.NAMES); } PrivilegeBits bits; if (PrivilegeBits.BUILT_IN.containsKey(name)) { bits = PrivilegeBits.BUILT_IN.get(name); } else if (isAggregate) { bits = bitsMgr.getBits(declAggrNames); if (bits.isEmpty()) { throw new RepositoryException("Illegal aggregation of non-exising privileges on '" + name + "'."); } } else { bits = next(); } bits.writeTo(privNode); }
private void writePrivilegeNode(Tree privilegesTree, PrivilegeDefinition definition) throws RepositoryException { String name = definition.getName(); Tree privNode = TreeUtil.addChild(privilegesTree, name, NT_REP_PRIVILEGE); if (definition.isAbstract()) { privNode.setProperty(REP_IS_ABSTRACT, true); } Set<String> declAggrNames = definition.getDeclaredAggregateNames(); boolean isAggregate = declAggrNames.size() > 0; if (isAggregate) { privNode.setProperty(REP_AGGREGATES, declAggrNames, Type.NAMES); } PrivilegeBits bits; if (PrivilegeBits.BUILT_IN.containsKey(name)) { bits = PrivilegeBits.BUILT_IN.get(name); } else if (isAggregate) { bits = bitsMgr.getBits(declAggrNames); } else { bits = next(); } bits.writeTo(privNode); }
private void writePrivilegeNode(@NotNull Tree privilegesTree, @NotNull PrivilegeDefinition definition) throws RepositoryException { String name = definition.getName(); Tree privNode = TreeUtil.addChild(privilegesTree, name, NT_REP_PRIVILEGE); if (definition.isAbstract()) { privNode.setProperty(REP_IS_ABSTRACT, true); } Set<String> declAggrNames = definition.getDeclaredAggregateNames(); boolean isAggregate = !declAggrNames.isEmpty(); if (isAggregate) { privNode.setProperty(REP_AGGREGATES, declAggrNames, Type.NAMES); } PrivilegeBits bits; if (PrivilegeBits.BUILT_IN.containsKey(name)) { bits = PrivilegeBits.BUILT_IN.get(name); } else if (isAggregate) { bits = bitsMgr.getBits(declAggrNames); if (bits.isEmpty()) { throw new RepositoryException("Illegal aggregation of non-exising privileges on '" + name + "'."); } } else { bits = next(); } bits.writeTo(privNode); }
/** * @param definitions The privilege definitions to write to the repository. * @throws RepositoryException If the privilege store is missing or if there is a privilege registered with the same name. */ private void writeDefinitions(@NotNull Iterable<PrivilegeDefinition> definitions) throws RepositoryException { try { // make sure the privileges path is defined Tree privilegesTree = root.getTree(PRIVILEGES_PATH); if (!privilegesTree.exists()) { throw new RepositoryException("Privilege store does not exist."); } for (PrivilegeDefinition definition : definitions) { if (privilegesTree.hasChild(definition.getName())) { throw new RepositoryException("Privilege definition with name '" + definition.getName() + "' already exists."); } writePrivilegeNode(privilegesTree, definition); } /* update the property storing the next privilege bits with the privileges root tree. this is a cheap way to detect collisions that may arise from concurrent registration of custom privileges. */ getNext().writeTo(privilegesTree); // delegate validation to the commit validation (see above) root.commit(); } catch (CommitFailedException e) { throw e.asRepositoryException(); } }
@Test public void testToString() { PrivilegeDefinition def = new PrivilegeDefinitionReader(root).readDefinition(privilege.getName()); assertEquals(def.getName(), privilege.toString()); }
@Test public void testNotEquals() { PrivilegeDefinition otherDef = Mockito.mock(PrivilegeDefinition.class); when(otherDef.getName()).thenReturn(def.getName()); when(otherDef.isAbstract()).thenReturn(def.isAbstract()); when(otherDef.getDeclaredAggregateNames()).thenReturn(def.getDeclaredAggregateNames()); assertNotEquals(def, otherDef); assertNotEquals(def, null); assertNotEquals(def, new ImmutablePrivilegeDefinition("othername", true, ImmutableList.of("aggrName"))); assertNotEquals(def, new ImmutablePrivilegeDefinition("name", false, ImmutableList.of("aggrName"))); assertNotEquals(def, new ImmutablePrivilegeDefinition("name", true, ImmutableList.of("anotherName"))); assertNotEquals(def, new ImmutablePrivilegeDefinition("name", true, ImmutableList.of())); assertNotEquals(def, new ImmutablePrivilegeDefinition("otherName", false, ImmutableList.of("aggrName","aggrName2"))); } }
@Test public void testPrivilegeDefinition() throws RepositoryException { Tree repWriteTree = PrivilegeUtil.getPrivilegesTree(root).getChild(PrivilegeConstants.REP_WRITE); PrivilegeDefinition def = PrivilegeUtil.readDefinition(repWriteTree); String expectedName = null; // EXERCISE assertEquals(expectedName, def.getName()); boolean isAbstract = false; // EXERCISE assertEquals(isAbstract, def.isAbstract()); Set<String> expectedAggregates = null; // EXERCISE assertEquals(expectedAggregates, def.getDeclaredAggregateNames()); // EXERCISE: compare the internal privilege definition (and it's tree representation) with the privilege itself. Privilege repWritePrivilege = getPrivilegeManager(root).getPrivilege(PrivilegeConstants.REP_WRITE); }