Java Group.getMembers方法代码示例

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
@Override
public void memberAdded(Group group, Map params) {
    JID addedUser = new JID((String) params.get("member"));
    // Do nothing if the user was an admin that became a member
    if (group.getAdmins().contains(addedUser)) {
        return;
    }
    if (!isSharedGroup(group)) {
        for (Group visibleGroup : getVisibleGroups(group)) {
            // Get the list of affected users
            Collection<JID> users = new HashSet<>(visibleGroup.getMembers());
            users.addAll(visibleGroup.getAdmins());
            groupUserAdded(visibleGroup, users, addedUser);
        }
    }
    else {
        groupUserAdded(group, addedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
@Override
public void memberRemoved(Group group, Map params) {
    String member = (String) params.get("member");
    if (member == null) {
        return;
    }
    JID deletedUser = new JID(member);
    // Do nothing if the user is still an admin
    if (group.getAdmins().contains(deletedUser)) {
        return;
    }
    if (!isSharedGroup(group)) {
        for (Group visibleGroup : getVisibleGroups(group)) {
            // Get the list of affected users
            Collection<JID> users = new HashSet<>(visibleGroup.getMembers());
            users.addAll(visibleGroup.getAdmins());
            groupUserDeleted(visibleGroup, users, deletedUser);
        }
    }
    else {
        groupUserDeleted(group, deletedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
@Override
public void adminRemoved(Group group, Map params) {
    JID deletedUser = new JID((String) params.get("admin"));
    // Do nothing if the user is still a member
    if (group.getMembers().contains(deletedUser)) {
        return;
    }
    // Do nothing if the group is not being shown in group members' rosters
    if (!isSharedGroup(group)) {
        for (Group visibleGroup : getVisibleGroups(group)) {
            // Get the list of affected users
            Collection<JID> users = new HashSet<>(visibleGroup.getMembers());
            users.addAll(visibleGroup.getAdmins());
            groupUserDeleted(visibleGroup, users, deletedUser);
        }
    }
    else {
        groupUserDeleted(group, deletedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
/**
 * Returns all agents belonging to a Shared Group.
 *
 * @param group the shared group.
 * @return the collection of agents.
 */
public Collection<Agent> getAgents(Group group) {
    final Set<Agent> set = new HashSet<Agent>();
    for (JID jid : group.getMembers()) {
        Agent agent;
        try {
            agent = getAgent(jid);
        }
        catch (AgentNotFoundException e) {
            agent = createAgent(jid);
        }
        set.add(agent);
    }

    return set;
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
public void memberRemoved(Group group, Map params) {
    String member = (String) params.get("member");
    if (member == null) {
        return;
    }
    JID deletedUser = new JID(member);
    // Do nothing if the user is still an admin
    if (group.getAdmins().contains(deletedUser)) {
        return;
    }
    if (!isSharedGroup(group)) {
        for (Group visibleGroup : getVisibleGroups(group)) {
            // Get the list of affected users
            Collection<JID> users = new HashSet<JID>(visibleGroup.getMembers());
            users.addAll(visibleGroup.getAdmins());
            groupUserDeleted(visibleGroup, users, deletedUser);
        }
    }
    else {
        groupUserDeleted(group, deletedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
public void memberAdded(Group group, Map params) {
    JID addedUser = new JID((String) params.get("member"));
    // Do nothing if the user was an admin that became a member
    if (group.getAdmins().contains(addedUser)) {
        return;
    }
    if (!isSharedGroup(group)) {
        for (Group visibleGroup : getVisibleGroups(group)) {
            // Get the list of affected users
            Collection<JID> users = new HashSet<JID>(visibleGroup.getMembers());
            users.addAll(visibleGroup.getAdmins());
            groupUserAdded(visibleGroup, users, addedUser);
        }
    }
    else {
        groupUserAdded(group, addedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
@Override
public void groupDeleting(Group group, Map params) {
    // Get group members
    Collection<JID> users = new HashSet<>(group.getMembers());
    users.addAll(group.getAdmins());
    // Get users whose roster will be updated
    Collection<JID> affectedUsers = getAffectedUsers(group);
    // Iterate on group members and update rosters of affected users
    for (JID deletedUser : users) {
        groupUserDeleted(group, affectedUsers, deletedUser);
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
/**
 * A new user has been created so members of public shared groups need to have
 * their rosters updated. Members of public shared groups need to have a roster
 * item with subscription FROM for the new user since the new user can see them.
 *
 * @param newUser the newly created user.
 * @param params event parameters.
 */
@Override
public void userCreated(User newUser, Map<String,Object> params) {
    JID newUserJID = server.createJID(newUser.getUsername(), null);
    // Shared public groups that are public should have a presence subscription
    // of type FROM for the new user
    for (Group group : getPublicSharedGroups()) {
        // Get group members of public group
        Collection<JID> users = new HashSet<>(group.getMembers());
        users.addAll(group.getAdmins());
        // Update the roster of each group member to include a subscription of type FROM
        for (JID userToUpdate : users) {
            // Get the roster to update
            Roster roster = null;
            if (server.isLocal(userToUpdate)) {
                // Get the roster. If the user does not exist then continue with the next user
                try {
                    roster = getRoster(userToUpdate.getNode());
                }
                catch (UserNotFoundException e) {
                    continue;
                }
            }
            // Update roster
            roster.addSharedUser(group, newUserJID);

            if (!server.isLocal(userToUpdate)) {
                // Susbcribe to the presence of the remote user. This is only necessary for
                // remote users and may only work with remote users that **automatically**
                // accept presence subscription requests
                sendSubscribeRequest(newUserJID, userToUpdate, true);
            }
        }
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
@Override
public void userDeleting(User user, Map<String,Object> params) {
    // Shared public groups that have a presence subscription of type FROM
    // for the deleted user should no longer have a reference to the deleted user
    JID userJID = server.createJID(user.getUsername(), null);
    // Shared public groups that are public should have a presence subscription
    // of type FROM for the new user
    for (Group group : getPublicSharedGroups()) {
        // Get group members of public group
        Collection<JID> users = new HashSet<>(group.getMembers());
        users.addAll(group.getAdmins());
        // Update the roster of each group member to include a subscription of type FROM
        for (JID userToUpdate : users) {
            // Get the roster to update
            Roster roster = null;
            if (server.isLocal(userToUpdate)) {
                // Get the roster. If the user does not exist then continue with the next user
                try {
                    roster = getRoster(userToUpdate.getNode());
                }
                catch (UserNotFoundException e) {
                    continue;
                }
            }
            // Update roster
            roster.deleteSharedUser(group, userJID);

            if (!server.isLocal(userToUpdate)) {
                // Unsusbcribe from the presence of the remote user. This is only necessary for
                // remote users and may only work with remote users that **automatically**
                // accept presence subscription requests
                sendSubscribeRequest(userJID, userToUpdate, false);
            }
        }
    }

    deleteRoster(userJID);
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
Collection<JID> 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<JID>();
    }

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

    // If the user of the roster belongs to the shared group then we should return
    // users that need to be in the roster with subscription "from"
    if (group.isUser(roster.getUsername())) {
        // Check if anyone can see this shared group
        if ("everybody".equals(showInRoster)) {
            // Add all users in the system
            for (String username : UserManager.getInstance().getUsernames()) {
                users.add(server.createJID(username, null, true));
            }
        }
        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;
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
Collection<JID> 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<>();
    }

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

    // If the user of the roster belongs to the shared group then we should return
    // users that need to be in the roster with subscription "from"
    if (group.isUser(roster.getUsername())) {
        // Check if anyone can see this shared group
        if ("everybody".equals(showInRoster)) {
            // Add all users in the system
            for (String username : UserManager.getInstance().getUsernames()) {
                users.add(server.createJID(username, null, true));
            }
        }
        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;
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
/**
 * This method is similar to {@link #getAffectedUsers(Group)} except that it receives
 * some group properties. The group properties are passed as parameters since the called of this
 * method may want to obtain the related users of the group based in some properties values.
 *
 * This is useful when the group is being edited and some properties has changed and we need to
 * obtain the related users of the group based on the previous group state.
 */
private Collection<JID> getAffectedUsers(Group group, String showInRoster, String groupNames) {
    // Answer an empty collection if the group is not being shown in users' rosters
    if (!"onlyGroup".equals(showInRoster) && !"everybody".equals(showInRoster)) {
        return new ArrayList<JID>();
    }
    // Add the users of the group
    Collection<JID> users = new HashSet<JID>(group.getMembers());
    users.addAll(group.getAdmins());
    // Check if anyone can see this shared group
    if ("everybody".equals(showInRoster)) {
        // Add all users in the system
        for (String username : UserManager.getInstance().getUsernames()) {
            users.add(server.createJID(username, null, true));
        }
        // Add all logged users. We don't need to add all users in the system since only the
        // logged ones will be affected.
        //users.addAll(SessionManager.getInstance().getSessionUsers());
    }
    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;
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
/**
 * A new user has been created so members of public shared groups need to have
 * their rosters updated. Members of public shared groups need to have a roster
 * item with subscription FROM for the new user since the new user can see them.
 *
 * @param newUser the newly created user.
 * @param params event parameters.
 */
public void userCreated(User newUser, Map<String,Object> params) {
    JID newUserJID = server.createJID(newUser.getUsername(), null);
    // Shared public groups that are public should have a presence subscription
    // of type FROM for the new user
    for (Group group : getPublicSharedGroups()) {
        // Get group members of public group
        Collection<JID> users = new HashSet<JID>(group.getMembers());
        users.addAll(group.getAdmins());
        // Update the roster of each group member to include a subscription of type FROM
        for (JID userToUpdate : users) {
            // Get the roster to update
            Roster roster = null;
            if (server.isLocal(userToUpdate)) {
                // Check that the user exists, if not then continue with the next user
                try {
                    UserManager.getInstance().getUser(userToUpdate.getNode());
                }
                catch (UserNotFoundException e) {
                    continue;
                }
                roster = rosterCache.get(userToUpdate.getNode());
            }
            // Only update rosters in memory
            if (roster != null) {
                roster.addSharedUser(group, newUserJID);
            }
            if (!server.isLocal(userToUpdate)) {
                // Susbcribe to the presence of the remote user. This is only necessary for
                // remote users and may only work with remote users that **automatically**
                // accept presence subscription requests
                sendSubscribeRequest(newUserJID, userToUpdate, true);
            }
        }
    }
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
public void userDeleting(User user, Map<String,Object> params) {
    // Shared public groups that have a presence subscription of type FROM
    // for the deleted user should no longer have a reference to the deleted user
    JID userJID = server.createJID(user.getUsername(), null);
    // Shared public groups that are public should have a presence subscription
    // of type FROM for the new user
    for (Group group : getPublicSharedGroups()) {
        // Get group members of public group
        Collection<JID> users = new HashSet<JID>(group.getMembers());
        users.addAll(group.getAdmins());
        // Update the roster of each group member to include a subscription of type FROM
        for (JID userToUpdate : users) {
            // Get the roster to update
            Roster roster = null;
            if (server.isLocal(userToUpdate)) {
                // Check that the user exists, if not then continue with the next user
                try {
                    UserManager.getInstance().getUser(userToUpdate.getNode());
                }
                catch (UserNotFoundException e) {
                    continue;
                }
                roster = rosterCache.get(userToUpdate.getNode());
            }
            // Only update rosters in memory
            if (roster != null) {
                roster.deleteSharedUser(group, userJID);
            }
            if (!server.isLocal(userToUpdate)) {
                // Unsusbcribe from the presence of the remote user. This is only necessary for
                // remote users and may only work with remote users that **automatically**
                // accept presence subscription requests
                sendSubscribeRequest(userJID, userToUpdate, false);
            }
        }
    }

    deleteRoster(userJID);
}
 

import org.jivesoftware.openfire.group.Group; //导入方法依赖的package包/类
public void groupDeleting(Group group, Map params) {
    // Get group members
    Collection<JID> users = new HashSet<JID>(group.getMembers());
    users.addAll(group.getAdmins());
    // Get users whose roster will be updated
    Collection<JID> affectedUsers = getAffectedUsers(group);
    // Iterate on group members and update rosters of affected users
    for (JID deletedUser : users) {
        groupUserDeleted(group, affectedUsers, deletedUser);
    }
}