Workgroup.java

  1. /**
  2.  *
  3.  * Copyright 2003-2007 Jive Software.
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.workgroup.user;

  19. import java.util.concurrent.CopyOnWriteArraySet;
  20. import java.util.Iterator;
  21. import java.util.List;
  22. import java.util.Map;

  24. import org.jivesoftware.smack.PacketCollector;
  25. import org.jivesoftware.smack.StanzaListener;
  26. import org.jivesoftware.smack.SmackException;
  27. import org.jivesoftware.smack.SmackException.NoResponseException;
  28. import org.jivesoftware.smack.SmackException.NotConnectedException;
  29. import org.jivesoftware.smack.XMPPConnection;
  30. import org.jivesoftware.smack.XMPPException;
  31. import org.jivesoftware.smack.XMPPException.XMPPErrorException;
  32. import org.jivesoftware.smack.filter.AndFilter;
  33. import org.jivesoftware.smack.filter.FromMatchesFilter;
  34. import org.jivesoftware.smack.filter.StanzaFilter;
  35. import org.jivesoftware.smack.filter.StanzaTypeFilter;
  36. import org.jivesoftware.smack.packet.IQ;
  37. import org.jivesoftware.smack.packet.Message;
  38. import org.jivesoftware.smack.packet.Stanza;
  39. import org.jivesoftware.smack.packet.ExtensionElement;
  40. import org.jivesoftware.smack.packet.Presence;
  41. import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
  42. import org.jivesoftware.smackx.disco.packet.DiscoverInfo;
  43. import org.jivesoftware.smackx.muc.MultiUserChatManager;
  44. import org.jivesoftware.smackx.muc.packet.MUCUser;
  45. import org.jivesoftware.smackx.workgroup.MetaData;
  46. import org.jivesoftware.smackx.workgroup.WorkgroupInvitation;
  47. import org.jivesoftware.smackx.workgroup.WorkgroupInvitationListener;
  48. import org.jivesoftware.smackx.workgroup.ext.forms.WorkgroupForm;
  49. import org.jivesoftware.smackx.workgroup.packet.DepartQueuePacket;
  50. import org.jivesoftware.smackx.workgroup.packet.QueueUpdate;
  51. import org.jivesoftware.smackx.workgroup.packet.SessionID;
  52. import org.jivesoftware.smackx.workgroup.packet.UserID;
  53. import org.jivesoftware.smackx.workgroup.settings.ChatSetting;
  54. import org.jivesoftware.smackx.workgroup.settings.ChatSettings;
  55. import org.jivesoftware.smackx.workgroup.settings.OfflineSettings;
  56. import org.jivesoftware.smackx.workgroup.settings.SoundSettings;
  57. import org.jivesoftware.smackx.workgroup.settings.WorkgroupProperties;
  58. import org.jivesoftware.smackx.xdata.Form;
  59. import org.jivesoftware.smackx.xdata.FormField;
  60. import org.jivesoftware.smackx.xdata.packet.DataForm;
  61. import org.jxmpp.jid.DomainBareJid;
  62. import org.jxmpp.jid.Jid;

  64. /**
  65.  * Provides workgroup services for users. Users can join the workgroup queue, depart the
  66.  * queue, find status information about their placement in the queue, and register to
  67.  * be notified when they are routed to an agent.<p>
  68.  * <p/>
  69.  * This class only provides a users perspective into a workgroup and is not intended
  70.  * for use by agents.
  71.  *
  72.  * @author Matt Tucker
  73.  * @author Derek DeMoro
  74.  */
  75. public class Workgroup {

  77.     private Jid workgroupJID;
  78.     private XMPPConnection connection;
  79.     private boolean inQueue;
  80.     private CopyOnWriteArraySet<WorkgroupInvitationListener> invitationListeners;
  81.     private CopyOnWriteArraySet<QueueListener> queueListeners;

  83.     private int queuePosition = -1;
  84.     private int queueRemainingTime = -1;

  86.     /**
  87.      * Creates a new workgroup instance using the specified workgroup JID
  88.      * (eg support@workgroup.example.com) and XMPP connection. The connection must have
  89.      * undergone a successful login before being used to construct an instance of
  90.      * this class.
  91.      *
  92.      * @param workgroupJID the JID of the workgroup.
  93.      * @param connection   an XMPP connection which must have already undergone a
  94.      *                     successful login.
  95.      */
  96.     public Workgroup(Jid workgroupJID, XMPPConnection connection) {
  97.         // Login must have been done before passing in connection.
  98.         if (!connection.isAuthenticated()) {
  99.             throw new IllegalStateException("Must login to server before creating workgroup.");
  100.         }

  102.         this.workgroupJID = workgroupJID;
  103.         this.connection = connection;
  104.         inQueue = false;
  105.         invitationListeners = new CopyOnWriteArraySet<>();
  106.         queueListeners = new CopyOnWriteArraySet<>();

  108.         // Register as a queue listener for internal usage by this instance.
  109.         addQueueListener(new QueueListener() {
  110.             public void joinedQueue() {
  111.                 inQueue = true;
  112.             }

  114.             public void departedQueue() {
  115.                 inQueue = false;
  116.                 queuePosition = -1;
  117.                 queueRemainingTime = -1;
  118.             }

  120.             public void queuePositionUpdated(int currentPosition) {
  121.                 queuePosition = currentPosition;
  122.             }

  124.             public void queueWaitTimeUpdated(int secondsRemaining) {
  125.                 queueRemainingTime = secondsRemaining;
  126.             }
  127.         });

  129.         /**
  130.          * Internal handling of an invitation.Recieving an invitation removes the user from the queue.
  131.          */
  132.         MultiUserChatManager.getInstanceFor(connection).addInvitationListener(
  133.                 new org.jivesoftware.smackx.muc.InvitationListener() {
  134.                     @Override
  135.                     public void invitationReceived(XMPPConnection conn, org.jivesoftware.smackx.muc.MultiUserChat room, String inviter,
  136.                                                    String reason, String password, Message message) {
  137.                         inQueue = false;
  138.                         queuePosition = -1;
  139.                         queueRemainingTime = -1;
  140.                     }
  141.                 });

  143.         // Register a packet listener for all the messages sent to this client.
  144.         StanzaFilter typeFilter = new StanzaTypeFilter(Message.class);

  146.         connection.addAsyncStanzaListener(new StanzaListener() {
  147.             public void processPacket(Stanza packet) {
  148.                 handlePacket(packet);
  149.             }
  150.         }, typeFilter);
  151.     }

  153.     /**
  154.      * Returns the name of this workgroup (eg support@example.com).
  155.      *
  156.      * @return the name of the workgroup.
  157.      */
  158.     public Jid getWorkgroupJID() {
  159.         return workgroupJID;
  160.     }

  162.     /**
  163.      * Returns true if the user is currently waiting in the workgroup queue.
  164.      *
  165.      * @return true if currently waiting in the queue.
  166.      */
  167.     public boolean isInQueue() {
  168.         return inQueue;
  169.     }

  171.     /**
  172.      * Returns true if the workgroup is available for receiving new requests. The workgroup will be
  173.      * available only when agents are available for this workgroup.
  174.      *
  175.      * @return true if the workgroup is available for receiving new requests.
  176.      * @throws XMPPErrorException 
  177.      * @throws NoResponseException 
  178.      * @throws NotConnectedException 
  179.      * @throws InterruptedException 
  180.      */
  181.     public boolean isAvailable() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  182.         Presence directedPresence = new Presence(Presence.Type.available);
  183.         directedPresence.setTo(workgroupJID);
  184.         StanzaFilter typeFilter = new StanzaTypeFilter(Presence.class);
  185.         StanzaFilter fromFilter = FromMatchesFilter.create(workgroupJID);
  186.         PacketCollector collector = connection.createPacketCollectorAndSend(new AndFilter(fromFilter,
  187.                 typeFilter), directedPresence);

  189.         Presence response = (Presence)collector.nextResultOrThrow();
  190.         return Presence.Type.available == response.getType();
  191.     }

  193.     /**
  194.      * Returns the users current position in the workgroup queue. A value of 0 means
  195.      * the user is next in line to be routed; therefore, if the queue position
  196.      * is being displayed to the end user it is usually a good idea to add 1 to
  197.      * the value this method returns before display. If the user is not currently
  198.      * waiting in the workgroup, or no queue position information is available, -1
  199.      * will be returned.
  200.      *
  201.      * @return the user's current position in the workgroup queue, or -1 if the
  202.      *         position isn't available or if the user isn't in the queue.
  203.      */
  204.     public int getQueuePosition() {
  205.         return queuePosition;
  206.     }

  208.     /**
  209.      * Returns the estimated time (in seconds) that the user has to left wait in
  210.      * the workgroup queue before being routed. If the user is not currently waiting
  211.      * int he workgroup, or no queue time information is available, -1 will be
  212.      * returned.
  213.      *
  214.      * @return the estimated time remaining (in seconds) that the user has to
  215.      *         wait inthe workgroupu queue, or -1 if time information isn't available
  216.      *         or if the user isn't int the queue.
  217.      */
  218.     public int getQueueRemainingTime() {
  219.         return queueRemainingTime;
  220.     }

  222.     /**
  223.      * Joins the workgroup queue to wait to be routed to an agent. After joining
  224.      * the queue, queue status events will be sent to indicate the user's position and
  225.      * estimated time left in the queue. Once joining the queue, there are three ways
  226.      * the user can leave the queue: <ul>
  227.      * <p/>
  228.      * <li>The user is routed to an agent, which triggers a GroupChat invitation.
  229.      * <li>The user asks to leave the queue by calling the {@link #departQueue} method.
  230.      * <li>A server error occurs, or an administrator explicitly removes the user
  231.      * from the queue.
  232.      * </ul>
  233.      * <p/>
  234.      * A user cannot request to join the queue again if already in the queue. Therefore,
  235.      * this method will throw an IllegalStateException if the user is already in the queue.<p>
  236.      * <p/>
  237.      * Some servers may be configured to require certain meta-data in order to
  238.      * join the queue. In that case, the {@link #joinQueue(Form)} method should be
  239.      * used instead of this method so that meta-data may be passed in.<p>
  240.      * <p/>
  241.      * The server tracks the conversations that a user has with agents over time. By
  242.      * default, that tracking is done using the user's JID. However, this is not always
  243.      * possible. For example, when the user is logged in anonymously using a web client.
  244.      * In that case the user ID might be a randomly generated value put into a persistent
  245.      * cookie or a username obtained via the session. A userID can be explicitly
  246.      * passed in by using the {@link #joinQueue(Form, Jid)} method. When specified,
  247.      * that userID will be used instead of the user's JID to track conversations. The
  248.      * server will ignore a manually specified userID if the user's connection to the server
  249.      * is not anonymous.
  250.      *
  251.      * @throws XMPPException if an error occured joining the queue. An error may indicate
  252.      *                       that a connection failure occured or that the server explicitly rejected the
  253.      *                       request to join the queue.
  254.      * @throws SmackException 
  255.      * @throws InterruptedException 
  256.      */
  257.     public void joinQueue() throws XMPPException, SmackException, InterruptedException {
  258.         joinQueue(null);
  259.     }

  261.     /**
  262.      * Joins the workgroup queue to wait to be routed to an agent. After joining
  263.      * the queue, queue status events will be sent to indicate the user's position and
  264.      * estimated time left in the queue. Once joining the queue, there are three ways
  265.      * the user can leave the queue: <ul>
  266.      * <p/>
  267.      * <li>The user is routed to an agent, which triggers a GroupChat invitation.
  268.      * <li>The user asks to leave the queue by calling the {@link #departQueue} method.
  269.      * <li>A server error occurs, or an administrator explicitly removes the user
  270.      * from the queue.
  271.      * </ul>
  272.      * <p/>
  273.      * A user cannot request to join the queue again if already in the queue. Therefore,
  274.      * this method will throw an IllegalStateException if the user is already in the queue.<p>
  275.      * <p/>
  276.      * Some servers may be configured to require certain meta-data in order to
  277.      * join the queue.<p>
  278.      * <p/>
  279.      * The server tracks the conversations that a user has with agents over time. By
  280.      * default, that tracking is done using the user's JID. However, this is not always
  281.      * possible. For example, when the user is logged in anonymously using a web client.
  282.      * In that case the user ID might be a randomly generated value put into a persistent
  283.      * cookie or a username obtained via the session. A userID can be explicitly
  284.      * passed in by using the {@link #joinQueue(Form, Jid)} method. When specified,
  285.      * that userID will be used instead of the user's JID to track conversations. The
  286.      * server will ignore a manually specified userID if the user's connection to the server
  287.      * is not anonymous.
  288.      *
  289.      * @param answerForm the completed form the send for the join request.
  290.      * @throws XMPPException if an error occured joining the queue. An error may indicate
  291.      *                       that a connection failure occured or that the server explicitly rejected the
  292.      *                       request to join the queue.
  293.      * @throws SmackException 
  294.      * @throws InterruptedException 
  295.      */
  296.     public void joinQueue(Form answerForm) throws XMPPException, SmackException, InterruptedException {
  297.         joinQueue(answerForm, null);
  298.     }

  300.     /**
  301.      * <p>Joins the workgroup queue to wait to be routed to an agent. After joining
  302.      * the queue, queue status events will be sent to indicate the user's position and
  303.      * estimated time left in the queue. Once joining the queue, there are three ways
  304.      * the user can leave the queue: <ul>
  305.      * <p/>
  306.      * <li>The user is routed to an agent, which triggers a GroupChat invitation.
  307.      * <li>The user asks to leave the queue by calling the {@link #departQueue} method.
  308.      * <li>A server error occurs, or an administrator explicitly removes the user
  309.      * from the queue.
  310.      * </ul>
  311.      * <p/>
  312.      * A user cannot request to join the queue again if already in the queue. Therefore,
  313.      * this method will throw an IllegalStateException if the user is already in the queue.<p>
  314.      * <p/>
  315.      * Some servers may be configured to require certain meta-data in order to
  316.      * join the queue.<p>
  317.      * <p/>
  318.      * The server tracks the conversations that a user has with agents over time. By
  319.      * default, that tracking is done using the user's JID. However, this is not always
  320.      * possible. For example, when the user is logged in anonymously using a web client.
  321.      * In that case the user ID might be a randomly generated value put into a persistent
  322.      * cookie or a username obtained via the session. When specified, that userID will
  323.      * be used instead of the user's JID to track conversations. The server will ignore a
  324.      * manually specified userID if the user's connection to the server is not anonymous.
  325.      *
  326.      * @param answerForm the completed form associated with the join reqest.
  327.      * @param userID     String that represents the ID of the user when using anonymous sessions
  328.      *                   or <tt>null</tt> if a userID should not be used.
  329.      * @throws XMPPErrorException if an error occured joining the queue. An error may indicate
  330.      *                       that a connection failure occured or that the server explicitly rejected the
  331.      *                       request to join the queue.
  332.      * @throws NoResponseException 
  333.      * @throws NotConnectedException 
  334.      * @throws InterruptedException 
  335.      */
  336.     public void joinQueue(Form answerForm, Jid userID) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  337.         // If already in the queue ignore the join request.
  338.         if (inQueue) {
  339.             throw new IllegalStateException("Already in queue " + workgroupJID);
  340.         }

  342.         JoinQueuePacket joinPacket = new JoinQueuePacket(workgroupJID, answerForm, userID);

  344.         connection.createPacketCollectorAndSend(joinPacket).nextResultOrThrow();
  345.         // Notify listeners that we've joined the queue.
  346.         fireQueueJoinedEvent();
  347.     }

  349.     /**
  350.      * <p>Joins the workgroup queue to wait to be routed to an agent. After joining
  351.      * the queue, queue status events will be sent to indicate the user's position and
  352.      * estimated time left in the queue. Once joining the queue, there are three ways
  353.      * the user can leave the queue: <ul>
  354.      * <p/>
  355.      * <li>The user is routed to an agent, which triggers a GroupChat invitation.
  356.      * <li>The user asks to leave the queue by calling the {@link #departQueue} method.
  357.      * <li>A server error occurs, or an administrator explicitly removes the user
  358.      * from the queue.
  359.      * </ul>
  360.      * <p/>
  361.      * A user cannot request to join the queue again if already in the queue. Therefore,
  362.      * this method will throw an IllegalStateException if the user is already in the queue.<p>
  363.      * <p/>
  364.      * Some servers may be configured to require certain meta-data in order to
  365.      * join the queue.<p>
  366.      * <p/>
  367.      * The server tracks the conversations that a user has with agents over time. By
  368.      * default, that tracking is done using the user's JID. However, this is not always
  369.      * possible. For example, when the user is logged in anonymously using a web client.
  370.      * In that case the user ID might be a randomly generated value put into a persistent
  371.      * cookie or a username obtained via the session. When specified, that userID will
  372.      * be used instead of the user's JID to track conversations. The server will ignore a
  373.      * manually specified userID if the user's connection to the server is not anonymous.
  374.      *
  375.      * @param metadata metadata to create a dataform from.
  376.      * @param userID   String that represents the ID of the user when using anonymous sessions
  377.      *                 or <tt>null</tt> if a userID should not be used.
  378.      * @throws XMPPException if an error occured joining the queue. An error may indicate
  379.      *                       that a connection failure occured or that the server explicitly rejected the
  380.      *                       request to join the queue.
  381.      * @throws SmackException 
  382.      * @throws InterruptedException 
  383.      */
  384.     public void joinQueue(Map<String,Object> metadata, Jid userID) throws XMPPException, SmackException, InterruptedException {
  385.         // If already in the queue ignore the join request.
  386.         if (inQueue) {
  387.             throw new IllegalStateException("Already in queue " + workgroupJID);
  388.         }

  390.         // Build dataform from metadata
  391.         Form form = new Form(DataForm.Type.submit);
  392.         Iterator<String> iter = metadata.keySet().iterator();
  393.         while (iter.hasNext()) {
  394.             String name = iter.next();
  395.             String value = metadata.get(name).toString();

  397.             FormField field = new FormField(name);
  398.             field.setType(FormField.Type.text_single);
  399.             form.addField(field);
  400.             form.setAnswer(name, value);
  401.         }
  402.         joinQueue(form, userID);
  403.     }

  405.     /**
  406.      * Departs the workgroup queue. If the user is not currently in the queue, this
  407.      * method will do nothing.<p>
  408.      * <p/>
  409.      * Normally, the user would not manually leave the queue. However, they may wish to
  410.      * under certain circumstances -- for example, if they no longer wish to be routed
  411.      * to an agent because they've been waiting too long.
  412.      *
  413.      * @throws XMPPErrorException if an error occured trying to send the depart queue
  414.      *                       request to the server.
  415.      * @throws NoResponseException 
  416.      * @throws NotConnectedException 
  417.      * @throws InterruptedException 
  418.      */
  419.     public void departQueue() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  420.         // If not in the queue ignore the depart request.
  421.         if (!inQueue) {
  422.             return;
  423.         }

  425.         DepartQueuePacket departPacket = new DepartQueuePacket(this.workgroupJID);
  426.         connection.createPacketCollectorAndSend(departPacket).nextResultOrThrow();

  428.         // Notify listeners that we're no longer in the queue.
  429.         fireQueueDepartedEvent();
  430.     }

  432.     /**
  433.      * Adds a queue listener that will be notified of queue events for the user
  434.      * that created this Workgroup instance.
  435.      *
  436.      * @param queueListener the queue listener.
  437.      */
  438.     public void addQueueListener(QueueListener queueListener) {
  439.         queueListeners.add(queueListener);
  440.     }

  442.     /**
  443.      * Removes a queue listener.
  444.      *
  445.      * @param queueListener the queue listener.
  446.      */
  447.     public void removeQueueListener(QueueListener queueListener) {
  448.         queueListeners.remove(queueListener);
  449.     }

  451.     /**
  452.      * Adds an invitation listener that will be notified of groupchat invitations
  453.      * from the workgroup for the the user that created this Workgroup instance.
  454.      *
  455.      * @param invitationListener the invitation listener.
  456.      */
  457.     public void addInvitationListener(WorkgroupInvitationListener invitationListener) {
  458.         invitationListeners.add(invitationListener);
  459.     }

  461.     /**
  462.      * Removes an invitation listener.
  463.      *
  464.      * @param invitationListener the invitation listener.
  465.      */
  466.     public void removeQueueListener(WorkgroupInvitationListener invitationListener) {
  467.         invitationListeners.remove(invitationListener);
  468.     }

  470.     private void fireInvitationEvent(WorkgroupInvitation invitation) {
  471.         for (WorkgroupInvitationListener listener : invitationListeners ){
  472.             listener.invitationReceived(invitation);
  473.         }
  474.     }

  476.     private void fireQueueJoinedEvent() {
  477.         for (QueueListener listener : queueListeners){
  478.             listener.joinedQueue();
  479.         }
  480.     }

  482.     private void fireQueueDepartedEvent() {
  483.         for (QueueListener listener : queueListeners) {
  484.             listener.departedQueue();
  485.         }
  486.     }

  488.     private void fireQueuePositionEvent(int currentPosition) {
  489.         for (QueueListener listener : queueListeners) {
  490.             listener.queuePositionUpdated(currentPosition);
  491.         }
  492.     }

  494.     private void fireQueueTimeEvent(int secondsRemaining) {
  495.         for (QueueListener listener : queueListeners) {
  496.             listener.queueWaitTimeUpdated(secondsRemaining);
  497.         }
  498.     }

  500.     // PacketListener Implementation.

  502.     private void handlePacket(Stanza packet) {
  503.         if (packet instanceof Message) {
  504.             Message msg = (Message)packet;
  505.             // Check to see if the user left the queue.
  506.             ExtensionElement pe = msg.getExtension("depart-queue", "http://jabber.org/protocol/workgroup");
  507.             ExtensionElement queueStatus = msg.getExtension("queue-status", "http://jabber.org/protocol/workgroup");

  509.             if (pe != null) {
  510.                 fireQueueDepartedEvent();
  511.             }
  512.             else if (queueStatus != null) {
  513.                 QueueUpdate queueUpdate = (QueueUpdate)queueStatus;
  514.                 if (queueUpdate.getPosition() != -1) {
  515.                     fireQueuePositionEvent(queueUpdate.getPosition());
  516.                 }
  517.                 if (queueUpdate.getRemaingTime() != -1) {
  518.                     fireQueueTimeEvent(queueUpdate.getRemaingTime());
  519.                 }
  520.             }

  522.             else {
  523.                 // Check if a room invitation was sent and if the sender is the workgroup
  524.                 MUCUser mucUser = (MUCUser)msg.getExtension("x", "http://jabber.org/protocol/muc#user");
  525.                 MUCUser.Invite invite = mucUser != null ? mucUser.getInvite() : null;
  526.                 if (invite != null && workgroupJID.equals(invite.getFrom())) {
  527.                     String sessionID = null;
  528.                     Map<String, List<String>> metaData = null;

  530.                     pe = msg.getExtension(SessionID.ELEMENT_NAME,
  531.                             SessionID.NAMESPACE);
  532.                     if (pe != null) {
  533.                         sessionID = ((SessionID)pe).getSessionID();
  534.                     }

  536.                     pe = msg.getExtension(MetaData.ELEMENT_NAME,
  537.                             MetaData.NAMESPACE);
  538.                     if (pe != null) {
  539.                         metaData = ((MetaData)pe).getMetaData();
  540.                     }

  542.                     WorkgroupInvitation inv = new WorkgroupInvitation(connection.getUser(), msg.getFrom(),
  543.                             workgroupJID, sessionID, msg.getBody(),
  544.                             msg.getFrom(), metaData);

  546.                     fireInvitationEvent(inv);
  547.                 }
  548.             }
  549.         }
  550.     }

  552.     /**
  553.      * IQ packet to request joining the workgroup queue.
  554.      */
  555.     private class JoinQueuePacket extends IQ {

  557.         private Jid userID;
  558.         private DataForm form;

  560.         public JoinQueuePacket(Jid workgroup, Form answerForm, Jid userID) {
  561.             super("join-queue", "http://jabber.org/protocol/workgroup");
  562.             this.userID = userID;

  564.             setTo(workgroup);
  565.             setType(IQ.Type.set);

  567.             form = answerForm.getDataFormToSend();
  568.             addExtension(form);
  569.         }

  571.         @Override
  572.         protected IQChildElementXmlStringBuilder getIQChildElementBuilder(IQChildElementXmlStringBuilder buf) {
  573.             buf.rightAngleBracket();
  574.             buf.append("<queue-notifications/>");
  575.             // Add the user unique identification if the session is anonymous
  576.             if (connection.isAnonymous()) {
  577.                 buf.append(new UserID(userID).toXML());
  578.             }

  580.             // Append data form text
  581.             buf.append(form.toXML());

  583.             return buf;
  584.         }
  585.     }

  587.     /**
  588.      * Returns a single chat setting based on it's identified key.
  589.      *
  590.      * @param key the key to find.
  591.      * @return the ChatSetting if found, otherwise false.
  592.      * @throws XMPPException if an error occurs while getting information from the server.
  593.      * @throws SmackException 
  594.      * @throws InterruptedException 
  595.      */
  596.     public ChatSetting getChatSetting(String key) throws XMPPException, SmackException, InterruptedException {
  597.         ChatSettings chatSettings = getChatSettings(key, -1);
  598.         return chatSettings.getFirstEntry();
  599.     }

  601.     /**
  602.      * Returns ChatSettings based on type.
  603.      *
  604.      * @param type the type of ChatSettings to return.
  605.      * @return the ChatSettings of given type, otherwise null.
  606.      * @throws XMPPException if an error occurs while getting information from the server.
  607.      * @throws SmackException 
  608.      * @throws InterruptedException 
  609.      */
  610.     public ChatSettings getChatSettings(int type) throws XMPPException, SmackException, InterruptedException {
  611.         return getChatSettings(null, type);
  612.     }

  614.     /**
  615.      * Returns all ChatSettings.
  616.      *
  617.      * @return all ChatSettings of a given workgroup.
  618.      * @throws XMPPException if an error occurs while getting information from the server.
  619.      * @throws SmackException 
  620.      * @throws InterruptedException 
  621.      */
  622.     public ChatSettings getChatSettings() throws XMPPException, SmackException, InterruptedException {
  623.         return getChatSettings(null, -1);
  624.     }


  627.     /**
  628.      * Asks the workgroup for it's Chat Settings.
  629.      *
  630.      * @return key specify a key to retrieve only that settings. Otherwise for all settings, key should be null.
  631.      * @throws NoResponseException 
  632.      * @throws XMPPErrorException if an error occurs while getting information from the server.
  633.      * @throws NotConnectedException 
  634.      * @throws InterruptedException 
  635.      */
  636.     private ChatSettings getChatSettings(String key, int type) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  637.         ChatSettings request = new ChatSettings();
  638.         if (key != null) {
  639.             request.setKey(key);
  640.         }
  641.         if (type != -1) {
  642.             request.setType(type);
  643.         }
  644.         request.setType(IQ.Type.get);
  645.         request.setTo(workgroupJID);

  647.         ChatSettings response = (ChatSettings) connection.createPacketCollectorAndSend(request).nextResultOrThrow();

  649.         return response;
  650.     }

  652.     /**
  653.      * The workgroup service may be configured to send email. This queries the Workgroup Service
  654.      * to see if the email service has been configured and is available.
  655.      *
  656.      * @return true if the email service is available, otherwise return false.
  657.      * @throws SmackException 
  658.      * @throws InterruptedException 
  659.      */
  660.     public boolean isEmailAvailable() throws SmackException, InterruptedException {
  661.         ServiceDiscoveryManager discoManager = ServiceDiscoveryManager.getInstanceFor(connection);

  663.         try {
  664.             DomainBareJid workgroupService = workgroupJID.asDomainBareJid();
  665.             DiscoverInfo infoResult = discoManager.discoverInfo(workgroupService);
  666.             return infoResult.containsFeature("jive:email:provider");
  667.         }
  668.         catch (XMPPException e) {
  669.             return false;
  670.         }
  671.     }

  673.     /**
  674.      * Asks the workgroup for it's Offline Settings.
  675.      *
  676.      * @return offlineSettings the offline settings for this workgroup.
  677.      * @throws XMPPErrorException 
  678.      * @throws NoResponseException 
  679.      * @throws NotConnectedException 
  680.      * @throws InterruptedException 
  681.      */
  682.     public OfflineSettings getOfflineSettings() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  683.         OfflineSettings request = new OfflineSettings();
  684.         request.setType(IQ.Type.get);
  685.         request.setTo(workgroupJID);

  687.         OfflineSettings response = (OfflineSettings) connection.createPacketCollectorAndSend(
  688.                         request).nextResultOrThrow();
  689.         return response;
  690.     }

  692.     /**
  693.      * Asks the workgroup for it's Sound Settings.
  694.      *
  695.      * @return soundSettings the sound settings for the specified workgroup.
  696.      * @throws XMPPErrorException 
  697.      * @throws NoResponseException 
  698.      * @throws NotConnectedException 
  699.      * @throws InterruptedException 
  700.      */
  701.     public SoundSettings getSoundSettings() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  702.         SoundSettings request = new SoundSettings();
  703.         request.setType(IQ.Type.get);
  704.         request.setTo(workgroupJID);

  706.         SoundSettings response = (SoundSettings) connection.createPacketCollectorAndSend(request).nextResultOrThrow();
  707.         return response;
  708.     }

  710.     /**
  711.      * Asks the workgroup for it's Properties
  712.      *
  713.      * @return the WorkgroupProperties for the specified workgroup.
  714.      * @throws XMPPErrorException
  715.      * @throws NoResponseException
  716.      * @throws NotConnectedException 
  717.      * @throws InterruptedException 
  718.      */
  719.     public WorkgroupProperties getWorkgroupProperties() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException  {
  720.         WorkgroupProperties request = new WorkgroupProperties();
  721.         request.setType(IQ.Type.get);
  722.         request.setTo(workgroupJID);

  724.         WorkgroupProperties response = (WorkgroupProperties) connection.createPacketCollectorAndSend(
  725.                         request).nextResultOrThrow();
  726.         return response;
  727.     }

  729.     /**
  730.      * Asks the workgroup for it's Properties
  731.      *
  732.      * @param jid the jid of the user who's information you would like the workgroup to retreive.
  733.      * @return the WorkgroupProperties for the specified workgroup.
  734.      * @throws XMPPErrorException
  735.      * @throws NoResponseException
  736.      * @throws NotConnectedException 
  737.      * @throws InterruptedException 
  738.      */
  739.     public WorkgroupProperties getWorkgroupProperties(String jid) throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  740.         WorkgroupProperties request = new WorkgroupProperties();
  741.         request.setJid(jid);
  742.         request.setType(IQ.Type.get);
  743.         request.setTo(workgroupJID);

  745.         WorkgroupProperties response = (WorkgroupProperties) connection.createPacketCollectorAndSend(
  746.                         request).nextResultOrThrow();
  747.         return response;
  748.     }


  751.     /**
  752.      * Returns the Form to use for all clients of a workgroup. It is unlikely that the server
  753.      * will change the form (without a restart) so it is safe to keep the returned form
  754.      * for future submissions.
  755.      *
  756.      * @return the Form to use for searching transcripts.
  757.      * @throws XMPPErrorException
  758.      * @throws NoResponseException
  759.      * @throws NotConnectedException 
  760.      * @throws InterruptedException 
  761.      */
  762.     public Form getWorkgroupForm() throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
  763.         WorkgroupForm workgroupForm = new WorkgroupForm();
  764.         workgroupForm.setType(IQ.Type.get);
  765.         workgroupForm.setTo(workgroupJID);

  767.         WorkgroupForm response = (WorkgroupForm) connection.createPacketCollectorAndSend(
  768.                         workgroupForm).nextResultOrThrow();
  769.         return Form.getFormFrom(response);
  770.     }
  771. }
Created with JaCoCo 0.7.4.201502262128