Ejemplo n.º 1
0
 /**
  * Returns a collection with all the groups that the user may include in his roster. The following
  * criteria will be used to select the groups: 1) Groups that are configured so that everybody can
  * include in his roster, 2) Groups that are configured so that its users may include the group in
  * their rosters and the user is a group user of the group and 3) User belongs to a Group that may
  * see a Group that whose members may include the Group in their rosters.
  *
  * @param user the user to return his shared groups.
  * @return a collection with all the groups that the user may include in his roster.
  */
 public Collection<Group> getSharedGroups(User user) {
   Collection<Group> answer = new HashSet<Group>();
   Collection<Group> groups = GroupManager.getInstance().getGroups();
   for (Group group : groups) {
     String showInRoster = group.getProperties().get("sharedRoster.showInRoster");
     if ("onlyGroup".equals(showInRoster)) {
       if (group.isUser(user.getUsername())) {
         // The user belongs to the group so add the group to the answer
         answer.add(group);
       } else {
         // Check if the user belongs to a group that may see this group
         Collection<Group> groupList =
             parseGroups(group.getProperties().get("sharedRoster.groupList"));
         for (Group groupInList : groupList) {
           if (groupInList.isUser(user.getUsername())) {
             answer.add(group);
           }
         }
       }
     } else if ("everybody".equals(showInRoster)) {
       // Anyone can see this group so add the group to the answer
       answer.add(group);
     }
   }
   return answer;
 }
Ejemplo n.º 2
0
  Collection<String> getSharedUsersForRoster(Group group, Roster roster) {
    String showInRoster = group.getProperties().get("sharedRoster.showInRoster");
    String groupNames = group.getProperties().get("sharedRoster.groupList");

    // Answer an empty collection if the group is not being shown in users' rosters
    if (!"onlyGroup".equals(showInRoster) && !"everybody".equals(showInRoster)) {
      return new ArrayList<String>();
    }

    // Add the users of the group
    Collection<String> users = new HashSet<String>(group.getMembers());
    users.addAll(group.getAdmins());

    // Check if anyone can see this shared group
    if ("everybody".equals(showInRoster)) {
      // If the user of the roster belongs to the public group then we should return all users
      // in the system since they all need to be in the roster with subscription "from"
      if (group.isUser(roster.getUsername())) {
        // Add all users in the system
        for (User user : UserManager.getInstance().getUsers()) {
          users.add(user.getUsername());
        }
      }
    } else {
      // Add the users that may see the group
      Collection<Group> groupList = parseGroups(groupNames);
      for (Group groupInList : groupList) {
        users.addAll(groupInList.getMembers());
        users.addAll(groupInList.getAdmins());
      }
    }
    return users;
  }
Ejemplo n.º 3
0
 /**
  * Returns true if a group in the first collection may mutually see a group of the second
  * collection. More precisely, return true if both collections contain a public group (i.e.
  * anybody can see the group) or if both collection have a group that may see each other and the
  * users are members of those groups or if one group is public and the other group allowed the
  * public group to see it.
  *
  * @param user the name of the user associated to the first collection of groups.
  * @param groups a collection of groups to check against the other collection of groups.
  * @param otherUser the name of the user associated to the second collection of groups.
  * @param otherGroups the other collection of groups to check against the first collection.
  * @return true if a group in the first collection may mutually see a group of the second
  *     collection.
  */
 boolean hasMutualVisibility(
     String user, Collection<Group> groups, String otherUser, Collection<Group> otherGroups) {
   for (Group group : groups) {
     for (Group otherGroup : otherGroups) {
       // Skip this groups if the users are not group users of the groups
       if (!group.isUser(user) || !otherGroup.isUser(otherUser)) {
         continue;
       }
       if (group == otherGroup) {
         return true;
       }
       String showInRoster = group.getProperties().get("sharedRoster.showInRoster");
       String otherShowInRoster = otherGroup.getProperties().get("sharedRoster.showInRoster");
       // Return true if both groups are public groups (i.e. anybody can see them)
       if ("everybody".equals(showInRoster) && "everybody".equals(otherShowInRoster)) {
         return true;
       } else if ("onlyGroup".equals(showInRoster) && "onlyGroup".equals(otherShowInRoster)) {
         String groupNames = group.getProperties().get("sharedRoster.groupList");
         String otherGroupNames = otherGroup.getProperties().get("sharedRoster.groupList");
         // Return true if each group may see the other group
         if (groupNames != null && otherGroupNames != null) {
           if (groupNames.contains(otherGroup.getName())
               && otherGroupNames.contains(group.getName())) {
             return true;
           }
         }
       } else if ("everybody".equals(showInRoster) && "onlyGroup".equals(otherShowInRoster)) {
         // Return true if one group is public and the other group allowed the public
         // group to see him
         String otherGroupNames = otherGroup.getProperties().get("sharedRoster.groupList");
         if (otherGroupNames != null && otherGroupNames.contains(group.getName())) {
           return true;
         }
       } else if ("onlyGroup".equals(showInRoster) && "everybody".equals(otherShowInRoster)) {
         // Return true if one group is public and the other group allowed the public
         // group to see him
         String groupNames = group.getProperties().get("sharedRoster.groupList");
         // Return true if each group may see the other group
         if (groupNames != null && groupNames.contains(otherGroup.getName())) {
           return true;
         }
       }
     }
   }
   return false;
 }
Ejemplo n.º 4
0
 /**
  * Returns true if a given group is visible to a given user. That means, if the user can see the
  * group in his roster.
  *
  * @param group the group to check if the user can see.
  * @param username the user to check if he may see the group.
  * @return true if a given group is visible to a given user.
  */
 boolean isGroupVisible(Group group, String username) {
   String showInRoster = group.getProperties().get("sharedRoster.showInRoster");
   if ("everybody".equals(showInRoster)) {
     return true;
   } else if ("onlyGroup".equals(showInRoster)) {
     if (group.isUser(username)) {
       return true;
     }
     // Check if the user belongs to a group that may see this group
     Collection<Group> groupList =
         parseGroups(group.getProperties().get("sharedRoster.groupList"));
     for (Group groupInList : groupList) {
       if (groupInList.isUser(username)) {
         return true;
       }
     }
   }
   return false;
 }