Examples with RoomInterceptorManager org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager used on opensource projects

Example 1 with RoomInterceptorManager

use of org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager in project Openfire by igniterealtime.

the class Workgroup method sendInvitation.

/**
     * An agent has accepted the offer and was choosen to answer the user's requests. The workgroup
     * will create a new room where the agent can answer the user's needs. Once the room has been
     * created, the Agent and the user that made the request will receive invitiations to join the
     * newly created room.<p>
     * <p/>
     * The workgroup will listen for all the packets sent to the room and generate a conversation
     * transcript.
     *
     * @param agent   the AgentSession that accepted and was choosen to respond the user's requests.
     * @param request the request made by a user.
     */
public void sendInvitation(AgentSession agent, UserRequest request) {
    // we need to destroy all MUC rooms created by workgroups
    try {
        RoomInterceptorManager interceptorManager = RoomInterceptorManager.getInstance();
        WorkgroupManager workgroupManager = WorkgroupManager.getInstance();
        String userJID = request.getUserJID().toString();
        final Workgroup sessionWorkgroup = request.getWorkgroup();
        final String sessionID = request.getSessionID();
        String workgroupName = getJID().getNode();
        final String serviceName = workgroupManager.getMUCServiceName();
        final String roomName = sessionID + "@" + serviceName;
        final String roomJID = roomName + "/" + workgroupName;
        // Create the room by joining it. The workgroup will be the owner of the room and will
        // invite the Agent and the user to join the room
        JoinRoom joinRoom = new JoinRoom(getFullJID().toString(), roomJID);
        interceptorManager.invokeInterceptors(getJID().toBareJID(), joinRoom, false, false);
        send(joinRoom);
        interceptorManager.invokeInterceptors(getJID().toBareJID(), joinRoom, false, true);
        // Configure the newly created room
        Map<String, Collection<String>> fields = new HashMap<String, Collection<String>>();
        // Make a non-public room
        List<String> values = new ArrayList<String>();
        values.add("0");
        fields.put("muc#roomconfig_publicroom", values);
        // Set the room description
        values = new ArrayList<String>();
        values.add(roomName);
        fields.put("muc#roomconfig_roomdesc", values);
        // Set that anyone can change the room subject
        values = new ArrayList<String>();
        values.add("1");
        fields.put("muc#roomconfig_changesubject", values);
        // Make the room temporary
        values = new ArrayList<String>();
        values.add("0");
        fields.put("muc#roomconfig_persistentroom", values);
        // Set that only moderators can see the occupants' JID
        values = new ArrayList<String>();
        values.add("moderators");
        fields.put("muc#roomconfig_whois", values);
        // Set that we want packets to include the real JID
        values = new ArrayList<String>();
        values.add("0");
        fields.put("anonymous", values);
        // Only broadcast presences of participants and visitors
        values = new ArrayList<String>();
        values.add("participant");
        values.add("visitor");
        fields.put("muc#roomconfig_presencebroadcast", values);
        RoomConfiguration conf = new RoomConfiguration(fields);
        conf.setTo(roomName);
        conf.setFrom(getFullJID());
        interceptorManager.invokeInterceptors(getJID().toBareJID(), conf, false, false);
        send(conf);
        interceptorManager.invokeInterceptors(getJID().toBareJID(), conf, false, true);
        // Create a new entry for the active session and the request made by the user
        requests.put(sessionID, request);
        // Invite the Agent to the new room
        Invitation invitation = new Invitation(agent.getJID().toString(), sessionID);
        invitation.setTo(roomName);
        invitation.setFrom(getFullJID());
        // Add workgroup extension that includes the JID of the user that made the request
        Element element = invitation.addChildElement("offer", "http://jabber.org/protocol/workgroup");
        element.addAttribute("jid", userJID);
        // Add custom extension that includes the sessionID
        element = invitation.addChildElement("session", "http://jivesoftware.com/protocol/workgroup");
        element.addAttribute("workgroup", sessionWorkgroup.getJID().toString());
        element.addAttribute("id", sessionID);
        // anonymous user
        if (request.isAnonymousUser()) {
            element = invitation.addChildElement("user", "http://jivesoftware.com/protocol/workgroup");
            element.addAttribute("id", request.getUserID());
        }
        interceptorManager.invokeInterceptors(getJID().toBareJID(), invitation, false, false);
        send(invitation);
        interceptorManager.invokeInterceptors(getJID().toBareJID(), invitation, false, true);
        // Invite the user to the new room
        sendUserInvitiation(request, roomName);
        // Notify the request that invitations for support have been sent
        request.invitationsSent(sessionID);
    } catch (Exception e) {
        Log.error(e.getMessage(), e);
    }
}

Example 2 with RoomInterceptorManager

use of org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager in project Openfire by igniterealtime.

the class Workgroup method sendUserInvitiation.

/**
     * Sends the room invitation to the user that made the request.
     *
     * @param request the Request that the user made to join a workgroup.
     * @param roomID  the id of the room where the user is being invited.
     */
public void sendUserInvitiation(UserRequest request, String roomID) {
    String userJID = request.getUserJID().toString();
    final String sessionID = request.getSessionID();
    final String serviceName = WorkgroupManager.getInstance().getMUCServiceName();
    final String roomName = sessionID + "@" + serviceName;
    Invitation invitation = new Invitation(userJID, "Please join me for a chat.");
    invitation.setTo(roomName);
    invitation.setFrom(getFullJID());
    // Add workgroup extension that includes the JID of the workgroup
    Element element = invitation.addChildElement("workgroup", "http://jabber.org/protocol/workgroup");
    element.addAttribute("jid", getJID().toBareJID());
    // Add custom extension that includes the sessionID
    element = invitation.addChildElement("session", "http://jivesoftware.com/protocol/workgroup");
    element.addAttribute("id", sessionID);
    RoomInterceptorManager interceptorManager = RoomInterceptorManager.getInstance();
    interceptorManager.invokeInterceptors(getJID().toBareJID(), invitation, false, false);
    send(invitation);
    interceptorManager.invokeInterceptors(getJID().toBareJID(), invitation, false, true);
}

Example 3 with RoomInterceptorManager

use of org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager in project Openfire by igniterealtime.

the class Workgroup method roomActivity.

// ###############################################################################
// MUC related packets
// ###############################################################################
/**
     * Notification message indicating that there has been new activity in a room. This implies
     * that we need to update the conversation transcript of the group chat room and possibly
     * update the number of occupants within the room.<p>
     * <p/>
     * If only the workgroup is present in the room then leave the room (i.e. destroying room) and
     * proceed to save the room conversation transcript to the database.<p>
     *
     * @param packet the packet that was sent to the group chat room.
     */
private void roomActivity(Packet packet) {
    // Skip packet sent from this workgroup in the room
    if (packet.getFrom().toBareJID().equals(getGroupChatRoomName())) {
        return;
    }
    RoomInterceptorManager interceptorManager = RoomInterceptorManager.getInstance();
    String roomID = packet.getFrom().getNode();
    // Get the sessionID
    String sessionID = packet.getFrom().getNode();
    synchronized (sessionID.intern()) {
        if (packet instanceof Presence) {
            Presence presence = (Presence) packet;
            if (Presence.Type.error == presence.getType()) {
                // A configuration must be wrong (eg. workgroup is not allowed to create rooms).
                // Log the error presence
                String warnMessage = "Possible server misconfiguration. Received error " + "presence:" + presence.toXML();
                Log.warn(warnMessage);
                return;
            }
            // Get the JID of the presence's user
            Element mucUser = presence.getChildElement("x", "http://jabber.org/protocol/muc#user");
            // Skip this presence if no extended info was included in the presence
            if (mucUser == null) {
                return;
            }
            Element item = mucUser.element("item");
            // Skip this presence if no item was included in the presence
            if (item == null) {
                return;
            }
            // Skip this presence if it's the presence of this workgroup in the room
            if (workgroupName.equals(packet.getFrom().getResource())) {
                return;
            }
            JID presenceFullJID = new JID(item.attributeValue("jid"));
            String presenceJID = presenceFullJID.toBareJID();
            // Invoke the room interceptor before processing the presence
            interceptorManager.invokeInterceptors(getJID().toBareJID(), packet, false, false);
            // Get the userID associated to this sessionID
            UserRequest initialRequest = requests.get(sessionID);
            // Add the new presence to the list of sent packets
            Map<Packet, java.util.Date> messageList = transcripts.get(roomID);
            if (messageList == null) {
                messageList = new LinkedHashMap<Packet, java.util.Date>();
                transcripts.put(roomID, messageList);
                // Trigger the event that a chat support has started
                WorkgroupEventDispatcher.chatSupportStarted(this, sessionID);
            }
            messageList.put(packet.createCopy(), new java.util.Date());
            // Update the number of occupants in the room.
            boolean occupantAdded = false;
            Set<String> set = occupantsCounter.get(roomID);
            if (set == null) {
                set = new HashSet<String>();
                occupantsCounter.put(roomID, set);
            }
            if (presence.isAvailable()) {
                occupantAdded = set.add(presenceJID);
            } else {
                String xpath = "/presence/*[name()='x']/*[name()='status']";
                Element status = (Element) presence.getElement().selectSingleNode(xpath);
                if (status == null || !"303".equals(status.attributeValue("code"))) {
                    // Remove the occupant unless the occupant is changing his nickname
                    set.remove(presenceJID);
                }
            }
            // If the presence belongs to an Agent then create/update a track
            // Look for an agent whose JID matches the presence's JID
            String agentJID = null;
            for (Agent agent : getAgents()) {
                if (agent.getAgentJID().toBareJID().equals(presenceJID)) {
                    agentJID = agent.getAgentJID().toBareJID();
                }
            }
            if (agentJID != null) {
                AgentSession agentSession;
                // Update the current chats that the agent is having
                try {
                    agentSession = agentManager.getAgentSession(presenceFullJID);
                    if (agentSession != null) {
                        if (presence.isAvailable()) {
                            if (occupantAdded) {
                                agentSession.addChatInfo(this, sessionID, initialRequest, new java.util.Date());
                                // Trigger the event that an agent has joined a chat session
                                WorkgroupEventDispatcher.agentJoinedChatSupport(this, sessionID, agentSession);
                            }
                        } else {
                            agentSession.removeChatInfo(this, sessionID);
                            // Trigger the event that an agent has left a chat session
                            WorkgroupEventDispatcher.agentLeftChatSupport(this, sessionID, agentSession);
                        }
                    }
                } catch (AgentNotFoundException e) {
                // Do nothing since the AgentSession was not found
                }
                if (presence.isAvailable()) {
                    if (occupantAdded) {
                        // Store in the DB that an agent has joined a room
                        DbWorkgroup.updateJoinedSession(sessionID, agentJID, true);
                    }
                } else {
                    // Store in the DB that an agent has left a room
                    DbWorkgroup.updateJoinedSession(sessionID, agentJID, false);
                }
            } else {
                if (occupantAdded) {
                    // Notify the request that the user has joined a support session
                    initialRequest.supportStarted(roomID);
                }
            }
            if (occupantAdded) {
                initialRequest.userJoinedRoom(new JID(packet.getFrom().toBareJID()), presenceFullJID);
            }
            // If just the user has left the room, just persist the transcript
            boolean isAgent = false;
            try {
                isAgent = agentManager.getAgentSession(presenceFullJID) != null;
            } catch (AgentNotFoundException e) {
            // Ignore.
            }
            if (!((Presence) packet).isAvailable() && !isAgent) {
                // Build the XML for the transcript
                Map<Packet, java.util.Date> map = transcripts.get(roomID);
                StringBuilder buf = new StringBuilder();
                buf.append("<transcript>");
                for (Packet p : map.keySet()) {
                    java.util.Date date = map.get(p);
                    // Add the delay information
                    if (p instanceof Message) {
                        Message storedMessage = (Message) p;
                        Element delay = storedMessage.addChildElement("x", "jabber:x:delay");
                        delay.addAttribute("stamp", UTC_FORMAT.format(date));
                        if (ModelUtil.hasLength(storedMessage.getBody())) {
                            buf.append(p.toXML());
                        }
                    } else {
                        Presence storedPresence = (Presence) p;
                        Element delay = storedPresence.addChildElement("x", "jabber:x:delay");
                        delay.addAttribute("stamp", UTC_FORMAT.format(date));
                        buf.append(p.toXML());
                    }
                // Append an XML representation of the packet to the string buffer
                }
                buf.append("</transcript>");
                // Save the transcript (in XML) to the DB
                DbWorkgroup.updateTranscript(sessionID, buf.toString(), new java.util.Date());
            }
            // the DB and destroy the room
            if (!((Presence) packet).isAvailable() && set.isEmpty()) {
                // Delete the counter of occupants for this room
                occupantsCounter.remove(roomID);
                initialRequest = requests.remove(sessionID);
                if (initialRequest != null && initialRequest.hasJoinedRoom()) {
                    // Notify the request that the support session has finished
                    initialRequest.supportEnded();
                }
                // Build the XML for the transcript
                Map<Packet, java.util.Date> map = transcripts.get(roomID);
                StringBuilder buf = new StringBuilder();
                buf.append("<transcript>");
                for (Packet p : map.keySet()) {
                    java.util.Date date = map.get(p);
                    // Add the delay information
                    if (p instanceof Message) {
                        Message storedMessage = (Message) p;
                        Element delay = storedMessage.addChildElement("x", "jabber:x:delay");
                        delay.addAttribute("stamp", UTC_FORMAT.format(date));
                        if (ModelUtil.hasLength(storedMessage.getBody())) {
                            buf.append(p.toXML());
                        }
                    } else {
                        Presence storedPresence = (Presence) p;
                        Element delay = storedPresence.addChildElement("x", "jabber:x:delay");
                        delay.addAttribute("stamp", UTC_FORMAT.format(date));
                        buf.append(p.toXML());
                    }
                // Append an XML representation of the packet to the string buffer
                }
                buf.append("</transcript>");
                // Save the transcript (in XML) to the DB
                //DbWorkgroup.updateTranscript(sessionID, buf.toString(), new java.util.Date());
                // Leave Chat Room (the room will be destroyed)
                String roomJID = packet.getFrom().toString() + "/" + getJID().getNode();
                LeaveRoom leaveRoom = new LeaveRoom(getFullJID().toString(), roomJID);
                send(leaveRoom);
                // Remove the transcript information of this room since the room no
                // longer exists
                transcripts.remove(roomID);
                // Trigger the event that a chat support has finished
                WorkgroupEventDispatcher.chatSupportFinished(this, sessionID);
            }
            // Invoke the room interceptor after the presence has been processed
            interceptorManager.invokeInterceptors(getJID().toBareJID(), packet, false, true);
        } else if (packet instanceof Message) {
            // transcript to include things like "room locked"
            if (packet.getFrom().getResource() != null) {
                // Invoke the room interceptor before processing the presence
                interceptorManager.invokeInterceptors(getJID().toBareJID(), packet, false, false);
                // Add the new message to the list of sent packets
                Map<Packet, java.util.Date> messageList = transcripts.get(roomID);
                if (messageList == null) {
                    messageList = new LinkedHashMap<Packet, java.util.Date>();
                    transcripts.put(roomID, messageList);
                }
                messageList.put(packet.createCopy(), new java.util.Date());
                // Invoke the room interceptor after the presence has been processed
                interceptorManager.invokeInterceptors(getJID().toBareJID(), packet, false, true);
            }
        }
    }
}

Example 4 with RoomInterceptorManager

use of org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager in project Openfire by igniterealtime.

the class InvitationRequest method sendMUCInvitiation.

/**
     * Sends a standard MUC invitation to the invitee.
     */
private void sendMUCInvitiation() {
    final String serviceName = WorkgroupManager.getInstance().getMUCServiceName();
    final String roomName = sessionID + "@" + serviceName;
    Invitation invitation = new Invitation(invitee.toString(), reason);
    invitation.setTo(roomName);
    invitation.setFrom(inviter);
    // Add workgroup extension that includes the JID of the workgroup
    Element element = invitation.addChildElement("workgroup", "http://jabber.org/protocol/workgroup");
    element.addAttribute("jid", workgroup.getJID().toBareJID());
    // Add custom extension that includes the sessionID
    element = invitation.addChildElement("session", "http://jivesoftware.com/protocol/workgroup");
    element.addAttribute("id", sessionID);
    RoomInterceptorManager interceptorManager = RoomInterceptorManager.getInstance();
    interceptorManager.invokeInterceptors(workgroup.getJID().toBareJID(), invitation, false, false);
    workgroup.send(invitation);
    interceptorManager.invokeInterceptors(workgroup.getJID().toBareJID(), invitation, false, true);
}

Example 5 with RoomInterceptorManager

use of org.jivesoftware.xmpp.workgroup.interceptor.RoomInterceptorManager in project Openfire by igniterealtime.

the class TransferRequest method sendMUCInvitiation.

/**
     * Sends a standard MUC invitation to the invitee.
     */
private void sendMUCInvitiation() {
    // Keep track of the actual entity that received the transfer offer
    actualInvitee = invitee;
    final String serviceName = WorkgroupManager.getInstance().getMUCServiceName();
    final String roomName = sessionID + "@" + serviceName;
    Invitation invitation = new Invitation(invitee.toString(), reason);
    invitation.setTo(roomName);
    invitation.setFrom(inviter);
    // Add workgroup extension that includes the JID of the workgroup
    Element element = invitation.addChildElement("workgroup", "http://jabber.org/protocol/workgroup");
    element.addAttribute("jid", workgroup.getJID().toBareJID());
    // Add custom extension that includes the sessionID
    element = invitation.addChildElement("session", "http://jivesoftware.com/protocol/workgroup");
    element.addAttribute("id", sessionID);
    RoomInterceptorManager interceptorManager = RoomInterceptorManager.getInstance();
    interceptorManager.invokeInterceptors(workgroup.getJID().toBareJID(), invitation, false, false);
    workgroup.send(invitation);
    interceptorManager.invokeInterceptors(workgroup.getJID().toBareJID(), invitation, false, true);
}