mirror of
https://github.com/vanitasvitae/Smack.git
synced 2024-06-21 02:44:49 +02:00
1e57f1c659
Delete also all "All rights reserved" statements, as they are unnecessary and conflict with checkstyle's header check. Delete unused imports.
852 lines
35 KiB
Java
852 lines
35 KiB
Java
/**
|
|
*
|
|
* Copyright 2003-2007 Jive Software.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
package org.jivesoftware.smackx.workgroup.user;
|
|
|
|
import org.jivesoftware.smackx.workgroup.MetaData;
|
|
import org.jivesoftware.smackx.workgroup.WorkgroupInvitation;
|
|
import org.jivesoftware.smackx.workgroup.WorkgroupInvitationListener;
|
|
import org.jivesoftware.smackx.workgroup.ext.forms.WorkgroupForm;
|
|
import org.jivesoftware.smackx.workgroup.packet.DepartQueuePacket;
|
|
import org.jivesoftware.smackx.workgroup.packet.QueueUpdate;
|
|
import org.jivesoftware.smackx.workgroup.packet.SessionID;
|
|
import org.jivesoftware.smackx.workgroup.packet.UserID;
|
|
import org.jivesoftware.smackx.workgroup.settings.*;
|
|
import org.jivesoftware.smackx.xdata.Form;
|
|
import org.jivesoftware.smackx.xdata.FormField;
|
|
import org.jivesoftware.smackx.xdata.packet.DataForm;
|
|
import org.jivesoftware.smack.*;
|
|
import org.jivesoftware.smack.filter.*;
|
|
import org.jivesoftware.smack.packet.*;
|
|
import org.jivesoftware.smack.util.StringUtils;
|
|
import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
|
|
import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
|
|
import org.jivesoftware.smackx.muc.MultiUserChat;
|
|
import org.jivesoftware.smackx.muc.packet.MUCUser;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Provides workgroup services for users. Users can join the workgroup queue, depart the
|
|
* queue, find status information about their placement in the queue, and register to
|
|
* be notified when they are routed to an agent.<p>
|
|
* <p/>
|
|
* This class only provides a users perspective into a workgroup and is not intended
|
|
* for use by agents.
|
|
*
|
|
* @author Matt Tucker
|
|
* @author Derek DeMoro
|
|
*/
|
|
public class Workgroup {
|
|
|
|
private String workgroupJID;
|
|
private Connection connection;
|
|
private boolean inQueue;
|
|
private List<WorkgroupInvitationListener> invitationListeners;
|
|
private List<QueueListener> queueListeners;
|
|
|
|
private int queuePosition = -1;
|
|
private int queueRemainingTime = -1;
|
|
|
|
/**
|
|
* Creates a new workgroup instance using the specified workgroup JID
|
|
* (eg support@workgroup.example.com) and XMPP connection. The connection must have
|
|
* undergone a successful login before being used to construct an instance of
|
|
* this class.
|
|
*
|
|
* @param workgroupJID the JID of the workgroup.
|
|
* @param connection an XMPP connection which must have already undergone a
|
|
* successful login.
|
|
*/
|
|
public Workgroup(String workgroupJID, Connection connection) {
|
|
// Login must have been done before passing in connection.
|
|
if (!connection.isAuthenticated()) {
|
|
throw new IllegalStateException("Must login to server before creating workgroup.");
|
|
}
|
|
|
|
this.workgroupJID = workgroupJID;
|
|
this.connection = connection;
|
|
inQueue = false;
|
|
invitationListeners = new ArrayList<WorkgroupInvitationListener>();
|
|
queueListeners = new ArrayList<QueueListener>();
|
|
|
|
// Register as a queue listener for internal usage by this instance.
|
|
addQueueListener(new QueueListener() {
|
|
public void joinedQueue() {
|
|
inQueue = true;
|
|
}
|
|
|
|
public void departedQueue() {
|
|
inQueue = false;
|
|
queuePosition = -1;
|
|
queueRemainingTime = -1;
|
|
}
|
|
|
|
public void queuePositionUpdated(int currentPosition) {
|
|
queuePosition = currentPosition;
|
|
}
|
|
|
|
public void queueWaitTimeUpdated(int secondsRemaining) {
|
|
queueRemainingTime = secondsRemaining;
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Internal handling of an invitation.Recieving an invitation removes the user from the queue.
|
|
*/
|
|
MultiUserChat.addInvitationListener(connection,
|
|
new org.jivesoftware.smackx.muc.InvitationListener() {
|
|
public void invitationReceived(Connection conn, String room, String inviter,
|
|
String reason, String password, Message message) {
|
|
inQueue = false;
|
|
queuePosition = -1;
|
|
queueRemainingTime = -1;
|
|
}
|
|
});
|
|
|
|
// Register a packet listener for all the messages sent to this client.
|
|
PacketFilter typeFilter = new PacketTypeFilter(Message.class);
|
|
|
|
connection.addPacketListener(new PacketListener() {
|
|
public void processPacket(Packet packet) {
|
|
handlePacket(packet);
|
|
}
|
|
}, typeFilter);
|
|
}
|
|
|
|
/**
|
|
* Returns the name of this workgroup (eg support@example.com).
|
|
*
|
|
* @return the name of the workgroup.
|
|
*/
|
|
public String getWorkgroupJID() {
|
|
return workgroupJID;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the user is currently waiting in the workgroup queue.
|
|
*
|
|
* @return true if currently waiting in the queue.
|
|
*/
|
|
public boolean isInQueue() {
|
|
return inQueue;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the workgroup is available for receiving new requests. The workgroup will be
|
|
* available only when agents are available for this workgroup.
|
|
*
|
|
* @return true if the workgroup is available for receiving new requests.
|
|
*/
|
|
public boolean isAvailable() {
|
|
Presence directedPresence = new Presence(Presence.Type.available);
|
|
directedPresence.setTo(workgroupJID);
|
|
PacketFilter typeFilter = new PacketTypeFilter(Presence.class);
|
|
PacketFilter fromFilter = new FromContainsFilter(workgroupJID);
|
|
PacketCollector collector = connection.createPacketCollector(new AndFilter(fromFilter,
|
|
typeFilter));
|
|
|
|
connection.sendPacket(directedPresence);
|
|
|
|
Presence response = (Presence)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
return false;
|
|
}
|
|
else if (response.getError() != null) {
|
|
return false;
|
|
}
|
|
else {
|
|
return Presence.Type.available == response.getType();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the users current position in the workgroup queue. A value of 0 means
|
|
* the user is next in line to be routed; therefore, if the queue position
|
|
* is being displayed to the end user it is usually a good idea to add 1 to
|
|
* the value this method returns before display. If the user is not currently
|
|
* waiting in the workgroup, or no queue position information is available, -1
|
|
* will be returned.
|
|
*
|
|
* @return the user's current position in the workgroup queue, or -1 if the
|
|
* position isn't available or if the user isn't in the queue.
|
|
*/
|
|
public int getQueuePosition() {
|
|
return queuePosition;
|
|
}
|
|
|
|
/**
|
|
* Returns the estimated time (in seconds) that the user has to left wait in
|
|
* the workgroup queue before being routed. If the user is not currently waiting
|
|
* int he workgroup, or no queue time information is available, -1 will be
|
|
* returned.
|
|
*
|
|
* @return the estimated time remaining (in seconds) that the user has to
|
|
* wait inthe workgroupu queue, or -1 if time information isn't available
|
|
* or if the user isn't int the queue.
|
|
*/
|
|
public int getQueueRemainingTime() {
|
|
return queueRemainingTime;
|
|
}
|
|
|
|
/**
|
|
* Joins the workgroup queue to wait to be routed to an agent. After joining
|
|
* the queue, queue status events will be sent to indicate the user's position and
|
|
* estimated time left in the queue. Once joining the queue, there are three ways
|
|
* the user can leave the queue: <ul>
|
|
* <p/>
|
|
* <li>The user is routed to an agent, which triggers a GroupChat invitation.
|
|
* <li>The user asks to leave the queue by calling the {@link #departQueue} method.
|
|
* <li>A server error occurs, or an administrator explicitly removes the user
|
|
* from the queue.
|
|
* </ul>
|
|
* <p/>
|
|
* A user cannot request to join the queue again if already in the queue. Therefore,
|
|
* this method will throw an IllegalStateException if the user is already in the queue.<p>
|
|
* <p/>
|
|
* Some servers may be configured to require certain meta-data in order to
|
|
* join the queue. In that case, the {@link #joinQueue(Form)} method should be
|
|
* used instead of this method so that meta-data may be passed in.<p>
|
|
* <p/>
|
|
* The server tracks the conversations that a user has with agents over time. By
|
|
* default, that tracking is done using the user's JID. However, this is not always
|
|
* possible. For example, when the user is logged in anonymously using a web client.
|
|
* In that case the user ID might be a randomly generated value put into a persistent
|
|
* cookie or a username obtained via the session. A userID can be explicitly
|
|
* passed in by using the {@link #joinQueue(Form, String)} method. When specified,
|
|
* that userID will be used instead of the user's JID to track conversations. The
|
|
* server will ignore a manually specified userID if the user's connection to the server
|
|
* is not anonymous.
|
|
*
|
|
* @throws XMPPException if an error occured joining the queue. An error may indicate
|
|
* that a connection failure occured or that the server explicitly rejected the
|
|
* request to join the queue.
|
|
*/
|
|
public void joinQueue() throws XMPPException {
|
|
joinQueue(null);
|
|
}
|
|
|
|
/**
|
|
* Joins the workgroup queue to wait to be routed to an agent. After joining
|
|
* the queue, queue status events will be sent to indicate the user's position and
|
|
* estimated time left in the queue. Once joining the queue, there are three ways
|
|
* the user can leave the queue: <ul>
|
|
* <p/>
|
|
* <li>The user is routed to an agent, which triggers a GroupChat invitation.
|
|
* <li>The user asks to leave the queue by calling the {@link #departQueue} method.
|
|
* <li>A server error occurs, or an administrator explicitly removes the user
|
|
* from the queue.
|
|
* </ul>
|
|
* <p/>
|
|
* A user cannot request to join the queue again if already in the queue. Therefore,
|
|
* this method will throw an IllegalStateException if the user is already in the queue.<p>
|
|
* <p/>
|
|
* Some servers may be configured to require certain meta-data in order to
|
|
* join the queue.<p>
|
|
* <p/>
|
|
* The server tracks the conversations that a user has with agents over time. By
|
|
* default, that tracking is done using the user's JID. However, this is not always
|
|
* possible. For example, when the user is logged in anonymously using a web client.
|
|
* In that case the user ID might be a randomly generated value put into a persistent
|
|
* cookie or a username obtained via the session. A userID can be explicitly
|
|
* passed in by using the {@link #joinQueue(Form, String)} method. When specified,
|
|
* that userID will be used instead of the user's JID to track conversations. The
|
|
* server will ignore a manually specified userID if the user's connection to the server
|
|
* is not anonymous.
|
|
*
|
|
* @param answerForm the completed form the send for the join request.
|
|
* @throws XMPPException if an error occured joining the queue. An error may indicate
|
|
* that a connection failure occured or that the server explicitly rejected the
|
|
* request to join the queue.
|
|
*/
|
|
public void joinQueue(Form answerForm) throws XMPPException {
|
|
joinQueue(answerForm, null);
|
|
}
|
|
|
|
/**
|
|
* <p>Joins the workgroup queue to wait to be routed to an agent. After joining
|
|
* the queue, queue status events will be sent to indicate the user's position and
|
|
* estimated time left in the queue. Once joining the queue, there are three ways
|
|
* the user can leave the queue: <ul>
|
|
* <p/>
|
|
* <li>The user is routed to an agent, which triggers a GroupChat invitation.
|
|
* <li>The user asks to leave the queue by calling the {@link #departQueue} method.
|
|
* <li>A server error occurs, or an administrator explicitly removes the user
|
|
* from the queue.
|
|
* </ul>
|
|
* <p/>
|
|
* A user cannot request to join the queue again if already in the queue. Therefore,
|
|
* this method will throw an IllegalStateException if the user is already in the queue.<p>
|
|
* <p/>
|
|
* Some servers may be configured to require certain meta-data in order to
|
|
* join the queue.<p>
|
|
* <p/>
|
|
* The server tracks the conversations that a user has with agents over time. By
|
|
* default, that tracking is done using the user's JID. However, this is not always
|
|
* possible. For example, when the user is logged in anonymously using a web client.
|
|
* In that case the user ID might be a randomly generated value put into a persistent
|
|
* cookie or a username obtained via the session. When specified, that userID will
|
|
* be used instead of the user's JID to track conversations. The server will ignore a
|
|
* manually specified userID if the user's connection to the server is not anonymous.
|
|
*
|
|
* @param answerForm the completed form associated with the join reqest.
|
|
* @param userID String that represents the ID of the user when using anonymous sessions
|
|
* or <tt>null</tt> if a userID should not be used.
|
|
* @throws XMPPException if an error occured joining the queue. An error may indicate
|
|
* that a connection failure occured or that the server explicitly rejected the
|
|
* request to join the queue.
|
|
*/
|
|
public void joinQueue(Form answerForm, String userID) throws XMPPException {
|
|
// If already in the queue ignore the join request.
|
|
if (inQueue) {
|
|
throw new IllegalStateException("Already in queue " + workgroupJID);
|
|
}
|
|
|
|
JoinQueuePacket joinPacket = new JoinQueuePacket(workgroupJID, answerForm, userID);
|
|
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(joinPacket.getPacketID()));
|
|
|
|
this.connection.sendPacket(joinPacket);
|
|
|
|
IQ response = (IQ)collector.nextResult(10000);
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from the server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
|
|
// Notify listeners that we've joined the queue.
|
|
fireQueueJoinedEvent();
|
|
}
|
|
|
|
/**
|
|
* <p>Joins the workgroup queue to wait to be routed to an agent. After joining
|
|
* the queue, queue status events will be sent to indicate the user's position and
|
|
* estimated time left in the queue. Once joining the queue, there are three ways
|
|
* the user can leave the queue: <ul>
|
|
* <p/>
|
|
* <li>The user is routed to an agent, which triggers a GroupChat invitation.
|
|
* <li>The user asks to leave the queue by calling the {@link #departQueue} method.
|
|
* <li>A server error occurs, or an administrator explicitly removes the user
|
|
* from the queue.
|
|
* </ul>
|
|
* <p/>
|
|
* A user cannot request to join the queue again if already in the queue. Therefore,
|
|
* this method will throw an IllegalStateException if the user is already in the queue.<p>
|
|
* <p/>
|
|
* Some servers may be configured to require certain meta-data in order to
|
|
* join the queue.<p>
|
|
* <p/>
|
|
* The server tracks the conversations that a user has with agents over time. By
|
|
* default, that tracking is done using the user's JID. However, this is not always
|
|
* possible. For example, when the user is logged in anonymously using a web client.
|
|
* In that case the user ID might be a randomly generated value put into a persistent
|
|
* cookie or a username obtained via the session. When specified, that userID will
|
|
* be used instead of the user's JID to track conversations. The server will ignore a
|
|
* manually specified userID if the user's connection to the server is not anonymous.
|
|
*
|
|
* @param metadata metadata to create a dataform from.
|
|
* @param userID String that represents the ID of the user when using anonymous sessions
|
|
* or <tt>null</tt> if a userID should not be used.
|
|
* @throws XMPPException if an error occured joining the queue. An error may indicate
|
|
* that a connection failure occured or that the server explicitly rejected the
|
|
* request to join the queue.
|
|
*/
|
|
public void joinQueue(Map<String,Object> metadata, String userID) throws XMPPException {
|
|
// If already in the queue ignore the join request.
|
|
if (inQueue) {
|
|
throw new IllegalStateException("Already in queue " + workgroupJID);
|
|
}
|
|
|
|
// Build dataform from metadata
|
|
Form form = new Form(Form.TYPE_SUBMIT);
|
|
Iterator<String> iter = metadata.keySet().iterator();
|
|
while (iter.hasNext()) {
|
|
String name = iter.next();
|
|
String value = metadata.get(name).toString();
|
|
|
|
String escapedName = StringUtils.escapeForXML(name);
|
|
String escapedValue = StringUtils.escapeForXML(value);
|
|
|
|
FormField field = new FormField(escapedName);
|
|
field.setType(FormField.TYPE_TEXT_SINGLE);
|
|
form.addField(field);
|
|
form.setAnswer(escapedName, escapedValue);
|
|
}
|
|
joinQueue(form, userID);
|
|
}
|
|
|
|
/**
|
|
* Departs the workgroup queue. If the user is not currently in the queue, this
|
|
* method will do nothing.<p>
|
|
* <p/>
|
|
* Normally, the user would not manually leave the queue. However, they may wish to
|
|
* under certain circumstances -- for example, if they no longer wish to be routed
|
|
* to an agent because they've been waiting too long.
|
|
*
|
|
* @throws XMPPException if an error occured trying to send the depart queue
|
|
* request to the server.
|
|
*/
|
|
public void departQueue() throws XMPPException {
|
|
// If not in the queue ignore the depart request.
|
|
if (!inQueue) {
|
|
return;
|
|
}
|
|
|
|
DepartQueuePacket departPacket = new DepartQueuePacket(this.workgroupJID);
|
|
PacketCollector collector = this.connection.createPacketCollector(new PacketIDFilter(departPacket.getPacketID()));
|
|
|
|
connection.sendPacket(departPacket);
|
|
|
|
IQ response = (IQ)collector.nextResult(5000);
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from the server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
|
|
// Notify listeners that we're no longer in the queue.
|
|
fireQueueDepartedEvent();
|
|
}
|
|
|
|
/**
|
|
* Adds a queue listener that will be notified of queue events for the user
|
|
* that created this Workgroup instance.
|
|
*
|
|
* @param queueListener the queue listener.
|
|
*/
|
|
public void addQueueListener(QueueListener queueListener) {
|
|
synchronized (queueListeners) {
|
|
if (!queueListeners.contains(queueListener)) {
|
|
queueListeners.add(queueListener);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes a queue listener.
|
|
*
|
|
* @param queueListener the queue listener.
|
|
*/
|
|
public void removeQueueListener(QueueListener queueListener) {
|
|
synchronized (queueListeners) {
|
|
queueListeners.remove(queueListener);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds an invitation listener that will be notified of groupchat invitations
|
|
* from the workgroup for the the user that created this Workgroup instance.
|
|
*
|
|
* @param invitationListener the invitation listener.
|
|
*/
|
|
public void addInvitationListener(WorkgroupInvitationListener invitationListener) {
|
|
synchronized (invitationListeners) {
|
|
if (!invitationListeners.contains(invitationListener)) {
|
|
invitationListeners.add(invitationListener);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Removes an invitation listener.
|
|
*
|
|
* @param invitationListener the invitation listener.
|
|
*/
|
|
public void removeQueueListener(WorkgroupInvitationListener invitationListener) {
|
|
synchronized (invitationListeners) {
|
|
invitationListeners.remove(invitationListener);
|
|
}
|
|
}
|
|
|
|
private void fireInvitationEvent(WorkgroupInvitation invitation) {
|
|
synchronized (invitationListeners) {
|
|
for (Iterator<WorkgroupInvitationListener> i = invitationListeners.iterator(); i.hasNext();) {
|
|
WorkgroupInvitationListener listener = i.next();
|
|
listener.invitationReceived(invitation);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fireQueueJoinedEvent() {
|
|
synchronized (queueListeners) {
|
|
for (Iterator<QueueListener> i = queueListeners.iterator(); i.hasNext();) {
|
|
QueueListener listener = i.next();
|
|
listener.joinedQueue();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fireQueueDepartedEvent() {
|
|
synchronized (queueListeners) {
|
|
for (Iterator<QueueListener> i = queueListeners.iterator(); i.hasNext();) {
|
|
QueueListener listener = i.next();
|
|
listener.departedQueue();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fireQueuePositionEvent(int currentPosition) {
|
|
synchronized (queueListeners) {
|
|
for (Iterator<QueueListener> i = queueListeners.iterator(); i.hasNext();) {
|
|
QueueListener listener = i.next();
|
|
listener.queuePositionUpdated(currentPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fireQueueTimeEvent(int secondsRemaining) {
|
|
synchronized (queueListeners) {
|
|
for (Iterator<QueueListener> i = queueListeners.iterator(); i.hasNext();) {
|
|
QueueListener listener = i.next();
|
|
listener.queueWaitTimeUpdated(secondsRemaining);
|
|
}
|
|
}
|
|
}
|
|
|
|
// PacketListener Implementation.
|
|
|
|
private void handlePacket(Packet packet) {
|
|
if (packet instanceof Message) {
|
|
Message msg = (Message)packet;
|
|
// Check to see if the user left the queue.
|
|
PacketExtension pe = msg.getExtension("depart-queue", "http://jabber.org/protocol/workgroup");
|
|
PacketExtension queueStatus = msg.getExtension("queue-status", "http://jabber.org/protocol/workgroup");
|
|
|
|
if (pe != null) {
|
|
fireQueueDepartedEvent();
|
|
}
|
|
else if (queueStatus != null) {
|
|
QueueUpdate queueUpdate = (QueueUpdate)queueStatus;
|
|
if (queueUpdate.getPosition() != -1) {
|
|
fireQueuePositionEvent(queueUpdate.getPosition());
|
|
}
|
|
if (queueUpdate.getRemaingTime() != -1) {
|
|
fireQueueTimeEvent(queueUpdate.getRemaingTime());
|
|
}
|
|
}
|
|
|
|
else {
|
|
// Check if a room invitation was sent and if the sender is the workgroup
|
|
MUCUser mucUser = (MUCUser)msg.getExtension("x", "http://jabber.org/protocol/muc#user");
|
|
MUCUser.Invite invite = mucUser != null ? mucUser.getInvite() : null;
|
|
if (invite != null && workgroupJID.equals(invite.getFrom())) {
|
|
String sessionID = null;
|
|
Map<String, List<String>> metaData = null;
|
|
|
|
pe = msg.getExtension(SessionID.ELEMENT_NAME,
|
|
SessionID.NAMESPACE);
|
|
if (pe != null) {
|
|
sessionID = ((SessionID)pe).getSessionID();
|
|
}
|
|
|
|
pe = msg.getExtension(MetaData.ELEMENT_NAME,
|
|
MetaData.NAMESPACE);
|
|
if (pe != null) {
|
|
metaData = ((MetaData)pe).getMetaData();
|
|
}
|
|
|
|
WorkgroupInvitation inv = new WorkgroupInvitation(connection.getUser(), msg.getFrom(),
|
|
workgroupJID, sessionID, msg.getBody(),
|
|
msg.getFrom(), metaData);
|
|
|
|
fireInvitationEvent(inv);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* IQ packet to request joining the workgroup queue.
|
|
*/
|
|
private class JoinQueuePacket extends IQ {
|
|
|
|
private String userID = null;
|
|
private DataForm form;
|
|
|
|
public JoinQueuePacket(String workgroup, Form answerForm, String userID) {
|
|
this.userID = userID;
|
|
|
|
setTo(workgroup);
|
|
setType(IQ.Type.SET);
|
|
|
|
form = answerForm.getDataFormToSend();
|
|
addExtension(form);
|
|
}
|
|
|
|
public String getChildElementXML() {
|
|
StringBuilder buf = new StringBuilder();
|
|
|
|
buf.append("<join-queue xmlns=\"http://jabber.org/protocol/workgroup\">");
|
|
buf.append("<queue-notifications/>");
|
|
// Add the user unique identification if the session is anonymous
|
|
if (connection.isAnonymous()) {
|
|
buf.append(new UserID(userID).toXML());
|
|
}
|
|
|
|
// Append data form text
|
|
buf.append(form.toXML());
|
|
|
|
buf.append("</join-queue>");
|
|
|
|
return buf.toString();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns a single chat setting based on it's identified key.
|
|
*
|
|
* @param key the key to find.
|
|
* @return the ChatSetting if found, otherwise false.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public ChatSetting getChatSetting(String key) throws XMPPException {
|
|
ChatSettings chatSettings = getChatSettings(key, -1);
|
|
return chatSettings.getFirstEntry();
|
|
}
|
|
|
|
/**
|
|
* Returns ChatSettings based on type.
|
|
*
|
|
* @param type the type of ChatSettings to return.
|
|
* @return the ChatSettings of given type, otherwise null.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public ChatSettings getChatSettings(int type) throws XMPPException {
|
|
return getChatSettings(null, type);
|
|
}
|
|
|
|
/**
|
|
* Returns all ChatSettings.
|
|
*
|
|
* @return all ChatSettings of a given workgroup.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public ChatSettings getChatSettings() throws XMPPException {
|
|
return getChatSettings(null, -1);
|
|
}
|
|
|
|
|
|
/**
|
|
* Asks the workgroup for it's Chat Settings.
|
|
*
|
|
* @return key specify a key to retrieve only that settings. Otherwise for all settings, key should be null.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
private ChatSettings getChatSettings(String key, int type) throws XMPPException {
|
|
ChatSettings request = new ChatSettings();
|
|
if (key != null) {
|
|
request.setKey(key);
|
|
}
|
|
if (type != -1) {
|
|
request.setType(type);
|
|
}
|
|
request.setType(IQ.Type.GET);
|
|
request.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(request.getPacketID()));
|
|
connection.sendPacket(request);
|
|
|
|
|
|
ChatSettings response = (ChatSettings)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* The workgroup service may be configured to send email. This queries the Workgroup Service
|
|
* to see if the email service has been configured and is available.
|
|
*
|
|
* @return true if the email service is available, otherwise return false.
|
|
*/
|
|
public boolean isEmailAvailable() {
|
|
ServiceDiscoveryManager discoManager = ServiceDiscoveryManager.getInstanceFor(connection);
|
|
|
|
try {
|
|
String workgroupService = StringUtils.parseServer(workgroupJID);
|
|
DiscoverInfo infoResult = discoManager.discoverInfo(workgroupService);
|
|
return infoResult.containsFeature("jive:email:provider");
|
|
}
|
|
catch (XMPPException e) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Asks the workgroup for it's Offline Settings.
|
|
*
|
|
* @return offlineSettings the offline settings for this workgroup.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public OfflineSettings getOfflineSettings() throws XMPPException {
|
|
OfflineSettings request = new OfflineSettings();
|
|
request.setType(IQ.Type.GET);
|
|
request.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(request.getPacketID()));
|
|
connection.sendPacket(request);
|
|
|
|
|
|
OfflineSettings response = (OfflineSettings)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* Asks the workgroup for it's Sound Settings.
|
|
*
|
|
* @return soundSettings the sound settings for the specified workgroup.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public SoundSettings getSoundSettings() throws XMPPException {
|
|
SoundSettings request = new SoundSettings();
|
|
request.setType(IQ.Type.GET);
|
|
request.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(request.getPacketID()));
|
|
connection.sendPacket(request);
|
|
|
|
|
|
SoundSettings response = (SoundSettings)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* Asks the workgroup for it's Properties
|
|
*
|
|
* @return the WorkgroupProperties for the specified workgroup.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public WorkgroupProperties getWorkgroupProperties() throws XMPPException {
|
|
WorkgroupProperties request = new WorkgroupProperties();
|
|
request.setType(IQ.Type.GET);
|
|
request.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(request.getPacketID()));
|
|
connection.sendPacket(request);
|
|
|
|
|
|
WorkgroupProperties response = (WorkgroupProperties)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
/**
|
|
* Asks the workgroup for it's Properties
|
|
*
|
|
* @param jid the jid of the user who's information you would like the workgroup to retreive.
|
|
* @return the WorkgroupProperties for the specified workgroup.
|
|
* @throws XMPPException if an error occurs while getting information from the server.
|
|
*/
|
|
public WorkgroupProperties getWorkgroupProperties(String jid) throws XMPPException {
|
|
WorkgroupProperties request = new WorkgroupProperties();
|
|
request.setJid(jid);
|
|
request.setType(IQ.Type.GET);
|
|
request.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(request.getPacketID()));
|
|
connection.sendPacket(request);
|
|
|
|
|
|
WorkgroupProperties response = (WorkgroupProperties)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
|
|
/**
|
|
* Returns the Form to use for all clients of a workgroup. It is unlikely that the server
|
|
* will change the form (without a restart) so it is safe to keep the returned form
|
|
* for future submissions.
|
|
*
|
|
* @return the Form to use for searching transcripts.
|
|
* @throws XMPPException if an error occurs while sending the request to the server.
|
|
*/
|
|
public Form getWorkgroupForm() throws XMPPException {
|
|
WorkgroupForm workgroupForm = new WorkgroupForm();
|
|
workgroupForm.setType(IQ.Type.GET);
|
|
workgroupForm.setTo(workgroupJID);
|
|
|
|
PacketCollector collector = connection.createPacketCollector(new PacketIDFilter(workgroupForm.getPacketID()));
|
|
connection.sendPacket(workgroupForm);
|
|
|
|
WorkgroupForm response = (WorkgroupForm)collector.nextResult(SmackConfiguration.getPacketReplyTimeout());
|
|
|
|
// Cancel the collector.
|
|
collector.cancel();
|
|
if (response == null) {
|
|
throw new XMPPException("No response from server on status set.");
|
|
}
|
|
if (response.getError() != null) {
|
|
throw new XMPPException(response.getError());
|
|
}
|
|
return Form.getFormFrom(response);
|
|
}
|
|
} |