access = hierarchyAccess.getAccess(member); } else { access = Access.ALL;
hierarchyAccess.getBottomLevelDepth(); if (hierarchyAccess.getBottomLevelDepth() == hierarchy.getLevels().length) Math.max( access, hierarchyAccess.getBottomLevelDepth());
public RollupPolicy getRollupPolicy() { RollupPolicy rollupPolicy = RollupPolicy.HIDDEN; for (HierarchyAccess hierarchyAccess : list) { rollupPolicy = max( rollupPolicy, hierarchyAccess.getRollupPolicy()); if (rollupPolicy == RollupPolicy.FULL) { break; } } return rollupPolicy; }
role.getAccessDetails(this); final Role.RollupPolicy rollupPolicy = hierarchyAccess.getRollupPolicy(); final NumericType returnType = new NumericType(); switch (rollupPolicy) {
Access access = membersWithAccess.get(member); if (access == null) { access = hAccess.getAccess(member);
case CUSTOM: final RollupPolicy rollupPolicy = role.getAccessDetails(level.getHierarchy()).getRollupPolicy(); if (rollupPolicy == RollupPolicy.FULL) { return null;
case CUSTOM: final RollupPolicy rollupPolicy = role.getAccessDetails(level.getHierarchy()).getRollupPolicy(); if (rollupPolicy == RollupPolicy.FULL) { return null;
(RolapMember) getHierarchy().getDefaultMember(); if (defaultMember != null) { Access i = hierarchyAccess.getAccess(defaultMember); if (i != Access.NONE) { return defaultMember; boolean singleAvailableRootMember = false; for (RolapMember rootMember : rootMembers) { Access i = hierarchyAccess.getAccess(rootMember); if (i != Access.NONE) { if (firstAvailableRootMember == null) {
/** * Analyzes a list of tuples and determines if the list can * be safely optimized. If a member of the tuple list is on * a hierarchy for which a rollup policy of PARTIAL is set, * it is not safe to optimize that list. */ private static boolean canOptimize( Evaluator evaluator, TupleList tupleList) { // If members of this hierarchy are controlled by a role which // enforces a rollup policy of partial, we cannot safely // optimize the tuples list as it might end up rolling up to // the parent while not all children are actually accessible. if (tupleList.size() > 0) { for (Member member : tupleList.get(0)) { final RollupPolicy policy = evaluator.getSchemaReader().getRole() .getAccessDetails(member.getHierarchy()) .getRollupPolicy(); if (policy == RollupPolicy.PARTIAL) { return false; } } } return true; }
public boolean hasInaccessibleDescendants(Member member) { // If any of the roles return all the members, // we assume that all descendants are accessible when // we create a union of these roles. final Access unionAccess = getAccess(member); if (unionAccess == Access.ALL) { return false; } if (unionAccess == Access.NONE) { return true; } for (HierarchyAccess hierarchyAccess : list) { if (hierarchyAccess.getAccess(member) == Access.CUSTOM && !hierarchyAccess.hasInaccessibleDescendants(member)) { return false; } } // All of the roles have restricted the descendants in // some way. return true; }
public int getTopLevelDepth() { if (!isTopLeveRestricted()) { // We don't restrict the top level. // Return 0 for root. return 0; } int access = Integer.MAX_VALUE; for (HierarchyAccess hierarchyAccess : list) { if (hierarchyAccess.getTopLevelDepth() == 0) { // No restrictions. Skip. continue; } access = Math.min( access, hierarchyAccess.getTopLevelDepth()); if (access == 0) { break; } } return access; }
public List<RolapMember> getMembersInLevel( RolapLevel level, TupleConstraint constraint) { if (hierarchyAccess != null) { final int depth = level.getDepth(); if (depth < hierarchyAccess.getTopLevelDepth()) { return Collections.emptyList(); } if (depth > hierarchyAccess.getBottomLevelDepth()) { return Collections.emptyList(); } } final List<RolapMember> membersInLevel = memberReader.getMembersInLevel( level, constraint); List<RolapMember> filteredMembers = new ArrayList<RolapMember>(); filterMembers(membersInLevel, filteredMembers); return filteredMembers; }
public int getMemberDepth(Member member) { final Role.HierarchyAccess hierarchyAccess = role.getAccessDetails(member.getHierarchy()); if (hierarchyAccess != null) { final int memberDepth = member.getLevel().getDepth(); final int topLevelDepth = hierarchyAccess.getTopLevelDepth(); return memberDepth - topLevelDepth; } else if (((RolapLevel) member.getLevel()).isParentChild()) { // For members of parent-child hierarchy, members in the same level // may have different depths. int depth = 0; for (Member m = member.getParentMember(); m != null; m = m.getParentMember()) { depth++; } return depth; } else { return member.getLevel().getDepth(); } }
public List<RolapMember> getRootMembers() { int topLevelDepth = hierarchyAccess.getTopLevelDepth(); if (topLevelDepth > 0) { RolapLevel topLevel = (RolapLevel) getHierarchy().getLevels()[topLevelDepth]; final List<RolapMember> memberList = getMembersInLevel(topLevel); if (memberList.isEmpty()) { throw MondrianResource.instance() .HierarchyHasNoAccessibleMembers.ex( getHierarchy().getUniqueName()); } return memberList; } return super.getRootMembers(); }
public List<Level> getHierarchyLevels(Hierarchy hierarchy) { assert hierarchy != null; final Role.HierarchyAccess hierarchyAccess = role.getAccessDetails(hierarchy); final Level[] levels = hierarchy.getLevels(); if (hierarchyAccess == null) { return Arrays.asList(levels); } Level topLevel = levels[hierarchyAccess.getTopLevelDepth()]; Level bottomLevel = levels[hierarchyAccess.getBottomLevelDepth()]; List<Level> restrictedLevels = Arrays.asList(levels).subList( topLevel.getDepth(), bottomLevel.getDepth() + 1); assert restrictedLevels.size() >= 1 : "postcondition"; return restrictedLevels; }
public Access getAccess(Member member) { assert member != null; HierarchyAccess hierarchyAccess = getAccessDetails(member.getHierarchy()); if (hierarchyAccess != null) { return hierarchyAccess.getAccess(member); } final Access access = getAccess(member.getDimension()); LOGGER.debug( "Access level " + access + " granted to member " + member.getUniqueName() + " because of a union of roles."); return access; }
public boolean hasInaccessibleDescendants(Member member) { return hierarchyAccess.hasInaccessibleDescendants(member); }
public RolapMember getMemberParent(RolapMember member) { RolapMember parentMember = member.getParentMember(); // Skip over hidden parents. while (parentMember != null && parentMember.isHidden()) { parentMember = parentMember.getParentMember(); } // Skip over non-accessible parents. if (parentMember != null) { if (hierarchyAccess.getAccess(parentMember) == Access.NONE) { return null; } } return parentMember; } }
public Access getAccess(Member member) { return hierarchyAccess.getAccess(member); }