/** | |
* Copyright 2003-2007 Jive Software. | |
* | |
* All rights reserved. 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.smack.*; | |
import org.jivesoftware.smack.filter.*; | |
import org.jivesoftware.smack.packet.*; | |
import org.jivesoftware.smack.util.StringUtils; | |
import org.jivesoftware.smackx.Form; | |
import org.jivesoftware.smackx.FormField; | |
import org.jivesoftware.smackx.ServiceDiscoveryManager; | |
import org.jivesoftware.smackx.muc.MultiUserChat; | |
import org.jivesoftware.smackx.packet.DataForm; | |
import org.jivesoftware.smackx.packet.DiscoverInfo; | |
import org.jivesoftware.smackx.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); | |
} | |
/* | |
public static void main(String args[]) throws Exception { | |
Connection con = new XMPPConnection("anteros"); | |
con.connect(); | |
con.loginAnonymously(); | |
Workgroup workgroup = new Workgroup("demo@workgroup.anteros", con); | |
WorkgroupProperties props = workgroup.getWorkgroupProperties("derek@anteros.com"); | |
System.out.print(props); | |
con.disconnect(); | |
} | |
*/ | |
} |