The ININ.IceLib.People.ResponseManagement namespace contains classes for retrieving Interaction Center Response Documents and for editing user specific Response Documents. These are typically a collection of frequently asked questions. The agents can use the standard answers defined in these Response Documents when he or she is participating in a chat session.

Response Management is the general term for features that allow a user to send pre-defined responses, such as textual messages, URLs, or files to other persons participating in a Chat interaction. Messages, URLs, or files can be sent from Interaction Client, and using this API, from your custom applications.

Note
To use Response Management, you must have Web Services installed and configured on your Web server. For details, see Installing and Using IC's Web Services in the IC Documentation Library on the IC Server. The library of response documents is stored on the IC server, and may be administered using the Response Management container.

Response Management works as follows:

A web visitor requests an interactive Chat session.

An agent is alerted by the Interaction Client (or a custom IceLib application). The agent "picks up" the interaction request.

  • For a Chat, Interaction Client pops a dialog on the agent's workstation that allows the agent to begin an interactive typing session with the customer. The Responses tab of the agent's Chat dialog can contain the names of preset standard text messages, URLs which the agent can push the visitor's browser, and text file names. The agent can drag any combination of these responses into the Response field. When a URL is sent, the remote chat participant’s web browser opens to that address.

Some Interaction Center products allow users to add personal responses, such as a personal greeting or a frequently sent file or URL, to the Response Management library. These personal responses are listed on the Responses tab under the [User Name].xml directory, and are not available to other Interaction Client users.

Response Management Objects

A ResponseItem represents Interaction Messages, Interaction Urls and Interaction Files:

  • An Interaction Message is a note, URL, or file that an agent can send to a web visitor during an interactive session. Interaction Message objects typically display short messages. For example, an Interaction Message titled 'Standard Response Times' could contain 'Standard response times for a support request are .....'.

  • An Interaction Url stores frequently used Urls. For example, an Interaction Url titled 'Support web site' could be defined as 'http://www.inin.com/support'.

  • An Interaction File points to a file path. For example, an Interaction File titled 'Icelib Documentation' could point to 'C:\Program Files\Interactive Intelligence\Icelib\Documentation\Icelib.chm'.

ResponseItemType indicates if a ResponseItem is a Message or a Url or a File or a document.

ResponseDocument is a collection of Interaction Messages, Interaction Urls and Interaction Files. A ResponseDocument may contain nodes that in turn contain a collection of Interaction Messages, Interaction Urls and Interaction Files. A response node can contain child nodes.

ResponseNode is a collection of Interaction Messages, Interaction Urls and Interaction Files. A ResponseNode may contain more ResponseNodes and also ResponseItems.

ResponseManager has the capability to retrive Response Documents, Interaction Messages, Interaction Urls and Interaction Files. In addition, ResponseManager can also receive any updates at the server.

EditableResponseDocument is a Response Document that can be edited by the application. By default, all documents are read-only. User can add response nodes and response items to the editable document. The editable can be obtained from the ResponseManager's UserDocument property.

EditableResponseItem is a Response Item that can be edited by the application. By default, the ResponseItems are read-only. EditableResponseItems can be obtained from either EditableResponseNode or from EditableResponseDocument.

EditableResponseNode is a Response Node that can be edited by the application. By default, the ResponseNodes are read-only. EditableResponseNodes can be obtained from either EditableResponseNode or from EditableResponseDocument.

ResponseChangedEventArgs indicates that there has been a change in Response documents at the server. Set a event handler for ResponseChanged to receive updates.

Examples

This example shows how the classes ResponseManager and ResponseManager can be used to get Response Documents, Interaction Messages, Interaction Urls and Interaction Files.
CopyC#
public class MyResponseManagementClass
{
    private Session _Session;
    private PeopleManager _PeopleManager;
    private ResponseManager _ResponseManager;

    private void MyClient_StartWatchingCompleted(object sender, AsyncCompletedEventArgs e)
    {
        if ( e.Error != null )
        {
            // handle the error
            return;
        }

        // this means that our request 'StartWatching' to the server was successful.
        // TODO: Add your code here.
    }

    private void InitiateResponseManagement()
    {
        if (_PeopleManager == null)
            _PeopleManager = PeopleManager.GetInstance(_Session);
        if (_ResponseManager == null)
            _ResponseManager = new ResponseManager(_PeopleManager);

        // The following statements will make sure that the data obtained from the server is always upto date.
        _ResponseManager.StartWatchingCompleted += new AsyncCompletedEventHandler(MyClient_StartWatchingCompleted);
        object userStateObject1 = new object();
        _ResponseManager.StartWatchingAsync(userStateObject1);

        // Handle updates
        _ResponseManager.ResponseAdded += new EventHandler<ResponseChangedEventArgs>(MyClient_HandleResponsesAdded);
        _ResponseManager.ResponseChanged += new EventHandler<ResponseChangedEventArgs>(MyClient_HandleResponsesChanged);
        _ResponseManager.ResponseDeleted += new EventHandler<ResponseChangedEventArgs>(MyClient_HandleResponsesDeleted);

        // The following statements will get the response management data from the server.
        _ResponseManager.GetAvailableResponsesCompleted += new AsyncCompletedEventHandler(MyClient_GetAvailableResponsesCompleted);
        object userStateObject2 = new object();
        _ResponseManager.GetAvailableResponsesAsync(userStateObject2);
    }

    private void LoadResponseManagementTreeView()
    {
        EditableResponseDocument userDocument = _ResponseManager.UserDocument;
        ReadOnlyCollection<ResponseDocument> serverDocuments = _ResponseManager.ServerDocuments;
        ReadOnlyCollection<ResponseItem> interactionMessages = _ResponseManager.InteractionMessages;
        ReadOnlyCollection<ResponseItem> interactionUrls = _ResponseManager.InteractionUrls;
        ReadOnlyCollection<ResponseItem> interactionFiles = _ResponseManager.InteractionFiles;
        // ......
        // ......
    }

    private void MyClient_GetAvailableResponsesCompleted(object sender, AsyncCompletedEventArgs e)
    {
        if (e.Error != null)
        {
            // handle the error
            return;
        }

        LoadResponseManagementTreeView();
    }

    private void MyClient_HandleResponsesAdded(object sender, ResponseChangedEventArgs e)
    {
        switch(e.ChangedResponseType)
        {
            case ChangedResponseType.File:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Message:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Url:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.ServerDocument:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.UserDocument:
            {
                // TODO: Add your code here
                break;
            }
            default:
                break;
        }
    }

    private void MyClient_HandleResponsesAdded(object sender, ResponseChangedEventArgs e)
    {
        switch(e.ChangedResponseType)
        {
            case ChangedResponseType.File:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Message:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Url:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.ServerDocument:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.UserDocument:
            {
                // TODO: Add your code here
                break;
            }
            default:
                break;
        }
    }

    private void MyClient_HandleResponsesDeleted(object sender, ResponseChangedEventArgs e)
    {
        switch(e.ChangedResponseType)
        {
            case ChangedResponseType.File:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Message:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.Url:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.ServerDocument:
            {
                // TODO: Add your code here
                break;
            }
            case ChangedResponseType.UserDocument:
            {
                // TODO: Add your code here
                break;
            }
            default:
                break;
        }
    }

    public AddResponseItem(string name, string text)
    {
        EditableResponseDocument userDoc = _ResponseManager.UserDocument;
        userDoc.AddResponseItem(new EditableResponseItem(ResponseItemType.Message, name, text));
    }

    public UpdateResponseItem(EditableResponseNode parent, ResponseItem item, string name, string text)
    {
        EditableResponseItem editableItem = parent.GetEditableResponseItem(item);
        editableItem.Name = name;
        editableItem.Value = text;
    }

    public SaveDocument()
    {
        _ResponseManager.SaveUserDocumentAsync();
    }
}

Classes

  ClassDescription
Public classEditableResponseDocument
Represents an editable Response Document. Please refer to ResponseDocument for more information.
Public classEditableResponseItem
Represents an editable ResponseItem. Please refer to ResponseItem for more information.
Public classEditableResponseNode
Represents an editable Node in the Response Document. Please refer to ResponseNode for more information.
Public classResponseChangedEventArgs
Provides data for the event ResponseChanged.
Public classResponseDocument
Represents a read-only Response Document.
Public classResponseItem
Represents a read-only ResponseItem object. Each ResponseItem has a unique identifier, name, type, and value.
Public classResponseManager
The ResponseManager class has the capability to retrieve Response Documents, Interaction Messages, Interaction Urls and Interaction Files. It can also watch for changes to response management data, and receive any updates at the server.
Public classResponseNode
Represents a read-only Response Node.

Enumerations

  EnumerationDescription
Public enumerationChangedResponseType
Represents the type of Response that has changed.
Public enumerationResponseItemType
Represents the type of Response.

Version Information

Supported for IC Server version 2015 R1 and beyond.
For 4.0, supported for IC Server version 4.0 GA and beyond.
For 3.0, supported for IC Server version 3.0 GA and beyond.