CommunityWFM provides an array of technology integrations.
Thinking about moving to a new contact center platform? Community connects to a broad array of systems. With each customer having their own unique technical requirements, CommunityWFM has built out integration solutions for all different types of business. WFM integrations allow vital information to move freely between systems. Our in-house WFM technology integration team is continuously updating and creating new (and even custom) integrations for our customers.
This list includes a sampling of our ACD integration specification documents.
8x8
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to an 8x8 system. The document assumes that the reader has some basic understanding of the 8x8 contact center platform.
CommunityWFM | AI WFM and 8x8 Integration
CommunityWFM | AI WFM integrates with the 8x8 platform using their Virtual Contact Center APIs. The 8x8 APIs being used are the “8x8 Contact Center Statistics Reporting API” and “Real Time Statistics Reporting API for 8x8 Contact Center,” which uses HTTP requests to communicate with the contact center platform. The communication to 8x8 consists of sending in a tenet id and a data request token for authentication (provided by 8x8) and the request for the data retrieval on an interval basis.
Each component of data collection and the required database and table are described below.
8x8 Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the 8x8 Contact Center Statistics Reporting API to be used in volume and handle time reports and for future forecasting. The CommunityWFM | AI WFM Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
sumHandleTime – Total handle time during the 15-minute window
enteredCount – Total number of call during the 15-minute window
abandonedCount – Total number of abandoned calls during the 15-minute window`
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Real-Time Statistics Reporting API for 8x8 Contact Center to compare against scheduled intervals to provide agent schedule adherence reporting. The CommunityWFM | AI WFM Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-ID – Unique identifier for the agent
- agent-status – Agent state
Possible states include:
- 0: available
- 1: transaction offered
- 2: busy
- 3: post processing
- 4: on break
- 5: work offline
- 9: logged out
Altigen MaxCS
The objective of this document is to outline the method and details of CommunityWFM | AI WFM integration to Altigen MaxCS. The document assumes that the reader has some basic understanding of the MaxCS database layout and a working understanding of SQL query syntax.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the SQL Server database to be used in volume and handle time reports and for future forecasting. The CommunityWFM | AI WFM Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Historical Collection
The default historical data collection, the query runs against the WGSUMMARY table and is implemented as follows:
'SELECT DATEADD(second, StartTime, ''1970-01-01'') AS ''Slot'', WGNum AS ''Skill'', NumInWGCall AS ''CallVolume'', DurInTalk + DurInWrapUp AS ''HandleTime'', NumInAbnDuringRing + NumInAbnInQ + NumInAbnToApp AS ''Abandoned'' FROM WGSUMMARY WHERE StartTime >= ''#DtStart#'' AND EndTime <= ''#DtEnd#'' AND WGNum=''#AcdSkill#'' ORDER BY Slot'
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the MaxCS database to compare against schedule intervals in order to provide agent schedule adherence reporting. The CommunityWFM | AI WFM Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the Community product database.
The state transaction collection service executes the following query against the AGENTACTIVITY table:
SELECT DISTINCT #rec_limit_clause# DATEADD(SECOND, Time_Stamp, '1970-01-01') AS 'Event_Time', AgentNum, CONVERT(nvarchar, Activity) + CONVERT(nvarchar, Reason) AS 'EventType' FROM AGENTACTIVITY WHERE Time_Stamp > '#dtStart#' ORDER BY AgentNum, 'Event_Time';
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agents directly from the MaxCS database into CommunityWFM | AI WFM. Configuration data is retrieved from the MaxCS SQL Server database using the .net SQL provider.
Agent Profile Data
Community imports the agent profile data using the following query:
SELECT DISTINCT ExtNum AS 'employee_id', FirstName AS 'First_Name', LastName AS 'Last_Name' FROM EXTINFORMATION ORDER BY LastName
Avaya Aura
The objective of this document is to outline the method and details of the CommunityWFM |AI WFM integration to Avaya Aura Contact Center. The document assumes that the reader has some basic understanding of the CC database layout and a working understanding of SQL query syntax.
CommunityWFM and Avaya Aura CC Integration
CommunityWFM | AI WFM integrates with the Avaya Aura CC platform using direct queries against the primary Avaya CC’s Cache database. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the Avaya Aura platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the Cache database to be used in volume and handle time reports and for future forecasting. The CommunityWFM | AI WFM Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Historical Collection
Historical data collection is achieved by running queries against the iApplicationStat table and is implemented as follows:
Contact Volume
SELECT S.Timestamp AS Slot, S.ApplicationID AS Skill, SUM(S.CallsOffered) AS CallVolume, SUM(S.CallsAbandoned) AS Abandoned FROM iApplicationStat S WHERE S.Timestamp >= '#DtStart#' AND S.Timestamp < '#DtEnd#' AND S.ApplicationID=#AcdSkill# GROUP BY S.Timestamp, S.ApplicationID ORDER BY S.Timestamp ASC, S.ApplicationID ASC
Handling Time
SELECT S.Timestamp AS Slot, S.ApplicationID AS Skill, SUM(S.TalkTime) + SUM(S.PostCallProcessingTime) AS HandleTime FROM iAgentByApplicationStat S WHERE S.Timestamp >= '#DtStart#' AND S.Timestamp < '#DtEnd#' AND S.ApplicationID=#AcdSkill# GROUP BY S.Timestamp, S.ApplicationID ORDER BY S.Timestamp ASC, S.ApplicationID ASC
Note: These queries implement replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from a socketed connection to the Aura using the RSM data feed from Aura. A collection service monitors the IP address and port and captures data continuously.
The collection process then extracts the information from the data stream and feeds it to the CommunityWFM | AI WFM Adherence Database.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agent and skill data directly from the Avaya database into CommunityWFM | AI WFM. Configuration data is retrieved from the Aura Cache database using the following queries.
Agent Profile Data
CommunityWFM | AI WFM imports the agent profile data using the following query:
SELECT SurName AS 'Last_Name', GivenName AS 'First_Name', Title AS 'Title', TelsetLoginID AS 'Employee_Id' FROM Agent ORDER BY SurName ASC
Contact Types Data
Finally, for skills, CommunityWFM | AI WFM imports the data using the following query:
SELECT Name AS 'Name', ApplicationID AS 'ACDSkillID' FROM Application ORDER BY Name ASC
Avaya CMS
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Avaya CMS. The document assumes that the reader has some basic understanding of the CMS database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and Avaya CMS Integration
CommunityWFM | AI WFM integrates with the Avaya CMS platform using direct queries against the primary Avaya CMS database. Tables within the database satisfy the data historical collection requirements to fully integrate the CommunityWFM | AI WFM application with the Avaya CMS platform.
One of two additional mechanisms will be used for the purpose of collecting real-time agent transactional data. CommunityWFM | AI WFM utilizes distinct data feed methods from CMS depending on the underlying hardware platform for the CMS server. This is outlined below in the Agent State Transaction Data Collection portion of this document.
Each component of data collection and the required databases and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the CMS Informix database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Historical Collection
The default historical data collection, the query runs against the hsplit table and is implemented as follows:
SELECT row_date AS Startdate, INTRVL AS IntervalDuration, starttime AS Slot, split AS Skill, SUM(CallsOffered) AS CallVolume, SUM(abncalls + othercalls) AS Abandoned, SUM(acdtime + holdtime + acwtime) AS HandleTime FROM hsplit ; GROUP BY row_date, INTRVL, starttime, split ORDER BY StartDate ASC, Slot ASC, Skill ASC
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from a socketed connection to the CMS using Avaya RT Socket.
CommunityWFM | AI WFM will install a custom report, designed by Avaya, that pushes data via TCP/IP to a user definable port. A collection service then monitors the IP address and port and captures that data continuously.
The collection process extracts the information from the pipe delimited report and feeds it to the CommunityWFM | AI WFM Adherence Database.
Root level access is required to configure the CMS report.
CommunityWFM | AI WFM captures all defined agent states, such as ACD, RING, ACW, and additionally the interface may be configured to capture AUX reason codes.
Importing Configuration Data
Community supports the ability to import agent and skill data directly from the Avaya database into CommunityWFM | AI WFM. Configuration data is retrieved from the CMS Informix database using the DSN provided by the end user.
Agent Profile Data
Community imports the agent profile data using the following query:
SELECT item_name AS 'Last_Name', item_name AS 'First_Name', value AS 'Employee_Id' FROM synonyms WHERE item_type='agname' ORDER BY item_name
Contact Types Data
For skills, CommunityWFM | AI WFM imports the data using the following query:
SELECT item_name AS 'Name', value AS 'ACDSkillID' FROM synonyms WHERE item_type='split' ORDER BY item_name
Port Configuration
CommunityWFM | AI WFM interfaces to Avaya CMS through two distinct methods. An ODBC connection to the Informix database and a TCP streaming report interface for agent real-time events.
Historical interface
CommunityWFM | AI WFM interfaces using Informix ODBC drivers over port 50,000 or 50,001.
Real-time interface
CommunityWFM | AI WFM interfaces using configurable port options, but typically 6999.
Configuration
Limited configuration is required for Avaya CMS, this is accomplished via telnet over port 23.
AWS (Amazon Web Services)
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to AWS. The document assumes that the reader has some basic understanding of AWS including IAM users and policy management.
WFMSG Community and AWS Integration
CommunityWFM | AI WFM integrates with AWS through its programming API that allows CommunityWFM | AI WFM the ability to retrieve the required real-time data. AWS will meet data collection requirements to fully integrate the CommunityWFM | AI WFM application with the AWS platform. The IAM user in AWS that CommunityWFM | AI WFM will use to retrieve data must have the following permissions set with the appropriate information.
IAM policy needs to be updated to match the below Actions. Resource should be set to the proper setting for the AWS connection.
{
"Version": "2012-10-17",
"Statement":
[
{
"Effect": "Allow", "Action":
[
"kinesis:GetShardIterator", "kinesis:GetRecords", "kinesis:DescribeStream", "connect:DescribeInstance", "connect:ListInstances", "connect:ListUsers", "connect:ListQueues", "connect:GetMetricData", "connect:GetCurrentMetricData", "connect:DescribeUser"
],
"Resource":
[
“arn:aws:kinesis:us-east-1 :############:stream/AgentEventKinesisStreamForWFMSG", "arn:aws:connect:us-east-1:############:instance/ ********-****-****-****-************/*"
]
}
]
}
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM collects historical contact volume data from AWS by using the GetMetricData and GetCurrentMetricData in the API. The CommunityWFM Historical Data Collection Service (a .NET Windows service) executes the call for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM product database.
Below is the configuration information needed for setting up the historical collection from AWS. Note: Proxy information is only necessary if a proxy server is being used, otherwise leave blank.
Historical contact volume data collection
| Access Key: | |
| Secret: | |
| Assume Role ARN: | |
| Region Endpoint: | |
| Instance ID: | |
| Proxy Address: | |
| Proxy Port: | |
| Proxy Username: | |
| Proxy Password: |
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from AWS to compare against schedule intervals to provide agent schedule adherence reporting. The CommunityWFM | AI WFM Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
To retrieve data from AWS, an AWS Kinesis stream must be configured in AWS to provide the real-time data feed. Proper permissions must be set via the IAM user policy.
Below is the required information needed to be able to receive that real-time data stream.
Note: Proxy information is only necessary if a proxy server is being used, otherwise leave blank.
Importing Configuration Data
Community supports the ability to import agents directly into CommunityWFM | AI WFM from the AWS instance via the API calls ListUser and DescribeUser. Permissions must be properly set for the IAM user.
Steps to create a User to Assume Role
Create a Policy
1. Name it: WFMSGConnectPolicy
2. Edit the policy to match this:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": [
"connect:DescribeInstance",
"connect:ListQueues",
"connect:GetMetricData",
"connect:GetCurrentMetricData",
"connect:ListInstances",
"connect:ListUsers".
"kinesis:GetShardIterator",
"connect:DescribeUser",
"kinesis:GetRecords",
"kinesis:DescribeStream"
],
"Resource": "*"
}
]
}
3. Copy the ARN (in this example it is: arn:aws:iam::123456:policy/WFMSGConnectPolicy)
Create a Role
1. For type choose AWS Service
2. For use case choose S3 (we will change this later in the process)
3. Select S3 at the bottom and click next for Permissions
4. For name use "WFMSGConnectAPIRole"
5. Attach the policy we created above called "WFMSGConnectPolicy"
6. Copy the ARN (in this example it is: arn:aws:iam::123456:role/WFMSGConnectAPIRole)
Create a Policy
Name the policy "WFMSGConnectAssumePolicy"
Edit the policy to match this: (replace the example ARN below with the one from the the role just created)
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "VisualEditor0",
"Effect": "Allow",
"Action": "sts:AssumeRole",
"Resource": "arn:aws:iam::123456:role/WFMSGConnectAPIRole"
}
]
}
Create a User
- Create a user with access type of "Programmatic access": (in this example we are using "WFMSGConnectAssumeUser" as the user name.
- Generate an access key and record both the access key id and the access key secret
- Assign that user the policy "WFMSGConnectAssumePolicy"
- Copy the ARN (in this example it is: arn:aws:iam::123456:user/WFMSGConnectAssumeUser)
Edit a Role
- Edit role "WFMSGConnectAPIRole"
- Edit the Trust Relationship to match the: (replace the example ARN below with the one from the the user just created)
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "connect.amazonaws.com",
"AWS": "arn:aws:iam::123456:user/WFMSGConnectAssumeUser"
},
"Action": "sts:AssumeRole"
}
]
}
Broadworks
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to BroadWorks ACD reporting platform. The document assumes that the reader has some basic understanding of the BroadWorks database layout and a working understanding of SQL query syntax.
CommunityWFM and BroadWorks Integration
CommunityWFM | AI WFM integrates with the BroadWorks platform using direct queries against the BroadWorks database via a .net native provider. Tables within the database satisfy the data collection requirements to integrate the CommunityWFM | AI WFM application with the BroadWorks platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the BWECCR database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Contact Queue Historical Collection
For queue based data collection, the query runs against the BWECCR.ECCR_CC_CALL_DETAILS table view and is implemented as follows:
BroadWorks default contact historical query
SELECT V.CALL_CENTER_USERID,nvl(COUNT(*), 0) callvolume,
nvl(SUM(V.TALK_TIME + v.HOLD_TIME + V.WRAPUP_TIME), 0) HandleTime,
trunc(V.CC_ENTRY_TIME,'hh') + floor(to_char(V.CC_ENTRY_TIME,
'mi')/15)*15/1440 Slot, nvl(MAX(V2.Nothandled), 0) Abandoned FROM
BWECCR.ECCR_CC_CALL_DETAILS V LEFT JOIN(SELECT
CALL_CENTER_USERID,trunc(CC_ENTRY_TIME,'hh') +
floor(to_char(CC_ENTRY_TIME, 'mi')/15)*15/1440 Slot,COUNT(*) NotHandled
FROM BWECCR.ECCR_CC_CALL_DETAILS WHERE CALL_CENTER_USERID =
'#AcdSkill#' AND CC_ENTRY_TIME >=
TO_TIMESTAMP('#DtStart#', 'yyyy-mm-dd HH24:MI:SS.FF') + INTERVAL '-2' hour
AND CC_ENTRY_TIME < TO_TIMESTAMP('#DtEnd#', 'yyyy-mm-dd HH24:MI:SS.FF') AND (CALL_RESULT IN ('Abandoned') ) GROUP BY CALL_CENTER_USERID,trunc(CC_ENTRY_TIME,'hh') +
floor(to_char(CC_ENTRY_TIME, 'mi')/15)*15/1440) V2 ON V.CALL_CENTER_USERID
= V2.CALL_CENTER_USERID AND trunc(V.CC_ENTRY_TIME,'hh') +
floor(to_char(V.CC_ENTRY_TIME, 'mi')/15)*15/1440 = V2.slot WHERE
V.CALL_CENTER_USERID = '#AcdSkill#'
AND V.CC_ENTRY_TIME >= TO_TIMESTAMP('#DtStart#', 'yyyy-mm-dd
HH24:MI:SS.FF') + INTERVAL '-2' hour AND CALL_RESULT IN ('Answered', 'Abandoned') GROUP BY V.CALL_CENTER_USERID, trunc(V.CC_ENTRY_TIME,'hh') +
floor(to_char(V.CC_ENTRY_TIME, 'mi')/15)*15/1440
Note: The historical collection service implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the BWECCR database to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The state transaction collection service executes the following query against the BWECCR.ECCR_CC_AGENT_ACTIVITY_DETAILS table view.
BroadWorks default adherence query
select * from ( select AGENT_USERID login_id, ACTIVITY_TIME eventDateTime, ACTIVITY_DETAIL eventType from BWECCR.ECCR_CC_AGENT_ACTIVITY_DETAILS where ACTIVITY_TYPE = 'State' AND ACTIVITY_TIME > TO_TIMESTAMP('#dtStart#', 'yyyy-mm-dd HH24:MI:SS.FF') order by ACTIVITY_TIME) where ROWNUM < #maxRecs#
Importing Configuration Data
CommunityWFM | AI WFM does not support the ability to import Contact Queue information and Agents directly from the BroadWorks database into CommunityWFM | AI WFM.
Contact Queue Data
*Not available*
Agent Information
SELECT AGENT_UID Employee_ID, AGENT_NAME_FIRST First_Name, AGENT_NAME_LAST Last_Name from BWECCR.agents
Cisco UCCE
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Cisco Unified Contact Center Enterprise (UCCE). The document assumes that the reader has some basic understanding of the Cisco database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and Cisco Enterprise Integration
CommunityWFM | AI WFM integrates with the Cisco UCCE Enterprise platform using direct queries against two primary Cisco databases. Tables within each database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the Cisco Enterprise platform.
Each component of data collection and the required databases and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the hds database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Historical data can be collected by CommunityWFM | AI WFM using either Skill IDs or Call Types as the primary contact focus.
Skill Group Historical Collection
For Skill Group based data collection, the query runs against the t_Skill_Group_Half_Hour table and is implemented as follows:
SELECT DateTime AS 'Slot',SkillTargetID AS 'Skill', SUM(CallsHandledToHalf) + SUM(RouterCallsAbandQToHalf) + SUM(AbandonRingCallsToHalf) + SUM(RedirectNoAnsCallsToHalf) AS 'CallVolume', SUM(RouterCallsAbandQToHalf) AS 'Abandoned', SUM(HandledCallsTimeToHalf) AS 'HandleTime' FROM t_Skill_Group_Half_Hour WHERE DateTime >='#DtStart#' AND DateTime < '#DtEnd#' AND SkillTargetID=#AcdSkill# GROUP BY DateTime, SkillTargetID
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual Skill Groups.
Call Type Historical Collection
For Call Type based data collection, the query runs against the Call_Type_Half_Hour table and is implemented as follows:
SELECT DateTime AS 'Slot', CallTypeID AS 'Skill', SUM(CallsOfferedHalf) AS 'CallVolume', SUM(CallsOfferedHalf) - SUM(CallsHandledHalf) AS 'Abandoned', SUM(HandleTimeHalf) AS 'HandleTime' FROM Call_Type_Half_Hour WHERE DateTime >= '#DtStart#' AND DateTime < '#DtEnd#' AND CallTypeID=#AcdSkill# GROUP BY DateTime, CallTypeID
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual Call Types.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the awdb database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM product database.
The state transaction collection service executes the following query against the T_Agent_Real_Time table:
select CONVERT(varchar, A.SkillTargetID, 20) AS 'SkillTargetID', CASE WHEN (ART.AgentState IS NULL) THEN 0 ELSE ART.AgentState END AS 'AgentState', CASE WHEN (ART.AgentState IS NULL) THEN GETDATE() ELSE ART.DateTimeLastStateChange END AS 'DateTimeLastStateChange', A.EnterpriseName AS 'EnterpriseName' FROM t_Agent A LEFT JOIN t_Agent_Real_Time ART ON A.SkillTargetID = ART.SkillTargetID ORDER BY A.SkillTargetID, DateTimeLastStateChange
Note: No replacement characters are used here; the query is fully formed by the m_last_dt date formatting statement executed in the data collection service.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agent and Skill Group (or Call Type) data directly from the Cisco Enterprise database into CommunityWFM | AI WFM. Configuration data is retrieved from the awdb database using the DSN provided by the end user.
Agent Profile Data
CommunityWFM | AI WFM imports the agent profile data using the following query:
SELECT P.FirstName AS 'First_Name', P.LastName AS 'Last_Name', A.SkillTargetID AS 'Employee_Id' FROM Person P JOIN Agent A ON A.PersonID = P.PersonID
Skill Group Data
For Skill Groups, CommunityWFM | AI WFM imports the data using the following query:
SELECT SkillTargetID AS 'ACDSkillId', Description AS 'Name' FROM Skill_Group
Contact Types Data
Finally for Call Types, CommunityWFM | AI WFM imports the data using the following query:
SELECT CallTypeID AS 'ACDSkillId', EnterpriseName AS 'Name' FROM Call_Type
Cisco UCCX for Informix
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Cisco UCCX. The document assumes that the reader has some basic understanding of the Cisco database layout and a working understanding of Informix query syntax.
CommunityWFM | AI WFM and Cisco UCCX Integration
CommunityWFM | AI WFM integrates with the Cisco UCCX platform using direct queries against the Cisco DB_CRA database. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the Cisco UCCX platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
Community collects historical contact volume data from the DB_CRA database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Contact Service Queue Historical Collection
For CSQ based data collection, the queries run against the ContactCallDetail, ContactQueueDetail and ContactServiceQueue tables and are implemented as follows:
Cisco UCCX contact offered query
select DATE(CCD.startDateTime)::datetime year to second + floor(CCD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (CCD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, CQD.profileID, COUNT(*) AS CallVolume from ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 AND CCD.startDateTime >= DATETIME(#StartDateTime#) year to second - 1 units hour AND CCD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId,CQD.profileID ORDER BY Slot
Cisco UCCX contact abandoned query
select date(CCD.startDateTime)::datetime year to second + floor(CCD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (CCD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, CQD.profileID,COUNT(*) AS Abandoned FROM ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=1 AND CCD.startDateTime >= datetime(#StartDateTime#) year to second - 1 units hour AND CCD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId,CQD.profileID ORDER BY Slot
Cisco UCCX contact AHT query
select date(ACD.startDateTime)::datetime year to second + floor(ACD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (ACD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, SUM(ACD.talkTime) + SUM(ACD.holdTime) + SUM(ACD.workTime) AS HandleTime FROM AgentConnectionDetail ACD JOIN ContactQueueDetail CQD ON CqD.sessionID=ACD.sessionID AND CqD.sessionSeqNum = ACD.sessionSeqNum AND CqD.profileID = ACD.profileID AND CqD.nodeID = ACD.nodeID AND CqD.qIndex = ACD.qIndex JOIN ContactServiceQueue CSQ ON CSQ.recordID = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=2 AND ACD.startDateTime >= datetime(#StartDateTime#) year to second - 1 units hour AND ACD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId ORDER BY Slot
Note: The historical collection service implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual Contact Service Queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the DB_CRA database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM product database.
The state transaction collection service executes the following query against the AgentStateDetail table:
select R.resourceLoginId AS login_id, ASD.eventDateTime::datetime year to fraction + (-1 * ASD.gmtOffset) units minute as eventDateTime, trim(ASD.eventType::char(5)) || trim(ASD.reasonCode::char(5)) AS eventType from AgentStateDetail ASD JOIN Resource R ON R.resourceID = ASD.agentId AND R.profileID = ASD.profileID where ASD.eventDateTime > '#StartDate#'::datetime year to fraction + (-1 * ASD.gmtOffset) units minute order by eventDateTime
Note: The FormatDateTime(m_last_dt) is c# code that formats the last read time into an SQL string to only pull transactions that occur after the last time the service executed.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import Contact Service Queue data directly from the Cisco database into CommunityWFM | AI WFM. Configuration data is retrieved from the DB_CRA database using the DSN provided by the end user.
Contact Service Queue Data
SELECT DISTINCT CSQName AS Name, contactServiceQueueId AS ACDSkillId FROM ContactServiceQueue WHERE dateInactive IS NULL and active ORDER BY CSQName
Cisco UCCX for SQL Server
The objective of this document is to outline the method and details of CommunityWFM | AI WFM integration to Cisco UCCX. The document assumes that the reader has some basic understanding of the Cisco database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and Cisco UCCX Integration
CommunityWFM | AI WFM integrates with the Cisco UCCX platform using direct queries against the Cisco DB_CRA database. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the Cisco UCCX platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the DB_CRA database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Contact Service Queue Historical Collection
For CSQ based data collection, the queries run against the ContactCallDetail, ContactQueueDetail and ContactServiceQueue tables and are implemented as follows:
Cisco UCCX contact offered query
SELECT DATEADD(minute, CONVERT(int, DATEPART(minute, startDateTime) / 15) * 15, DATEADD(hour, DATEPART(hour, startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, startDateTime))))) AS 'Slot',CSQ.contactServiceQueueId AS 'Skill',CQD.profileID,COUNT(*) AS 'CallVolume' FROM ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 ; GROUP BY DATEADD(minute, CONVERT(int, DATEPART(minute, startDateTime) / 15) * 15, DATEADD(hour, DATEPART(hour, startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, startDateTime))))),CSQ.contactServiceQueueId,CQD.profileID ORDER BY 'Slot'
Cisco UCCX contact abandoned query
SELECT DATEADD(minute, CONVERT(int, DATEPART(minute, startDateTime) / 15) * 15, DATEADD(hour, DATEPART(hour, startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, startDateTime))))) AS 'Slot',CSQ.contactServiceQueueId AS 'Skill',CQD.profileID,COUNT(*) AS 'Abandoned' FROM ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=1 ; GROUP BY DATEADD(minute, CONVERT(int, DATEPART(minute, startDateTime) / 15) * 15, DATEADD(hour, DATEPART(hour, startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, startDateTime))))),CSQ.contactServiceQueueId,CQD.profileID ORDER BY 'Slot'
Cisco UCCX contact AHT query
SELECT DATEADD(minute,CONVERT(int,DATEPART(minute,ACD.startDateTime) / 15) * 15,DATEADD(hour, DATEPART(hour, ACD.startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, ACD.startDateTime))))) AS 'Slot',CSQ.contactServiceQueueId AS 'Skill',SUM(ACD.talkTime) + SUM(ACD.holdTime) + SUM(ACD.workTime) AS 'HandleTime' FROM AgentConnectionDetail ACD JOIN ContactQueueDetail CQD ON CqD.sessionID=ACD.sessionID AND CqD.sessionSeqNum = ACD.sessionSeqNum AND CqD.profileID = ACD.profileID AND CqD.nodeID = ACD.nodeID AND CqD.qIndex = ACD.qIndex JOIN ContactServiceQueue CSQ ON CSQ.recordID = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=2 ; GROUP BY DATEADD(minute, CONVERT(int, DATEPART(minute, ACD.startDateTime) / 15) * 15, DATEADD(hour, DATEPART(hour, ACD.startDateTime), CONVERT(datetime, FLOOR(CONVERT(float, ACD.startDateTime))))), CSQ.contactServiceQueueId ORDER BY 'Slot'
Note: The historical collection service implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual Contact Service Queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the DB_CRA database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM product database.
The state transaction collection service executes the following query against the AgentStateDetail table:
Select R.resourceLoginId AS 'login_id', DATEADD(minute, -1 * ASD.gmtOffset, ASD.eventDateTime) AS 'eventDateTime', CONVERT(nvarchar, ASD.eventType, 20) + CONVERT(nvarchar, ASD.reasonCode, 20) AS 'eventType' from AgentStateDetail ASD JOIN Resource R ON R.resourceID = ASD.agentId AND R.profileID = ASD.profileID where DATEADD(minute, - 1* ASD.gmtOffset, ASD.eventDateTime) > '" + FormatDateTime(m_last_dt) + "' order by eventDateTime
Note: The FormatDateTime(m_last_dt) is c# code that formats the last read time into an SQL string to only pull transactions that occur after the last time the service executed.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import Contact Service Queue data directly from the Cisco database into CommunityWFM | AI WFM. Configuration data is retrieved from the DB_CRA database using the DSN provided by the end user.
Contact Service Queue Data
SELECT DISTINCT CSQName AS 'Name', contactServiceQueueId AS 'ACDSkillId' FROM ContactServiceQueue WHERE dateInactive IS NULL AND active=1 ORDER BY CSQName
CommunityWFM Generic Staging Adapter
The objective of this document is to outline the tables that allow 3rd party applications and integrators to push data into the CommunityWFM | AI WFM staging database. An integrated adapter will then pull data from the staging database and upload it to the relevant tables within CommunityWFM | AI WFM.
Applications for the CommunityWFM | AI WFM Staging Database
The CommunityWFM | AI WFM staging database may be used for a variety of data collection scenarios. Typically, the mechanism would be used when a standard CommunityWFM | AI WFM adapter is not able to connect directly to a system’s database or other direct connection for data retrieval. Cloud based ACDs, flat file integrations, and secured databases may all take advantage of integration via the staging database.
Data Types
Contact Data
Contact data populated in the Historical Collection table may be automatically populated or imported on demand through the application. A historical data collection service may be enabled to routinely capture and populate new data that is present in the table whether uploaded once a day, once a week, or every fifteen minutes.
Agent State Data
Agent state data, used for adherence reporting purposes and populated in the Agent Activity table, will be automatically populated to the application database. A real-time data collection service is enabled to routinely capture and populate new data that is present in the table.
Data will be available in the application in real-time as it is presented in the table and is suitable for real-time adherence applications. Batch uploads of agent state data will still provide robust adherence data, but on a delayed basis.
People Data
Agent data populated in the People table may be imported on demand through the application. Imported data is used to create new agent profiles.
Agent profiles may also be manually defined.
Collection Point Data
Collection Point or “Queue Name” data, populated in the Collection Point table, may be imported on demand through the application and is used to bind calls from a specific queue or skill to the contact data. The collection mechanism will only populate data for which there is a Collection Point defined.
Collection Points may also be manually defined.
Integrating to CommunityWFM | AI WFM using a Staging Database
The CommunityWFM | AI WFM staging database includes four distinct tables that represent various data requirements. Depending on the application, you may use some or all of the following tables to fulfill the integration requirements.
CommunityWFM | AI WFM professional services staff will work with your team to determine precisely which data is needed for your solution.
Historical Table Layout
The WFMSG.Staging database table HistoricalCollectionByInterval stores the interval based historical data. Data from this table is used for forecasting and historical contact volume comparisons.
| HistoricalCollectionByInterval | ||
| AccountId | PK, int, not null | Unique identifier per data source provided by CommunityWFM technical team. |
| CollectionPoint | PK, nvarchar(50), not null | Contains the queue name, skill, or collection point for a particular row of data. |
| Interval | PK, datetime, not null |
Contains the date and time of the interval for the particular row of historical data. Time zone can be local or UTC. Intervals must be in a 15-minute increment on the 15 minute. Examples: 2024-06-15 13:00 2024-06-15 13:15 2024-06-15 13:30 2024-06-15 13:45 |
| ContactsOffered | bigint, not null | Number of contacts offered during this interval for the given skill. |
| ContactsNotHandled | bigint, not null | Number of contacts not handled during this interval for the given skill. Note that this value contains all contacts not handled, not simply those with a disposition of ‘abandoned.’ |
| TalkTime | Float, not null | Total number of seconds of talk time and wrap-up time for the interval and the given skill. |
| HoldTime * | Float, not null | Total number of seconds of hold time for the interval and the given skill. This field is optional and may be used if hold time is not included in the TalkTime column. |
| ServiceLevelPct * | Float, not null | Service level achievement percentage for a given skill. Data from this column is not currently utilized. |
| CollectionTimeStamp* | DateTime, null | The timestamp when the row is inserted into the staging database. Time zone can be local or UTC. |
| OutboundContacts* | bigint, null | Number of outbound contacts during this time interval for the given skill. |
| OutboundTimeStamp* | Float, null |
Total number of seconds of talk time and wrap-up time for the interval and the given outbound skill. Note: Please disregard the name of the field it should not be filled with a DateTime time stamp |
| User Data 1* – User Data 10* |
Any | Unique identifier provided by Customer. |
*Optional columns that may or may not be required for a particular application.
AgentActivity Table Layout
The WFMSG.Staging database table AgentActivity stores the agent state transactions for each agent. Data in this table is used for schedule adherence purposes. Actual phone state data is compared to scheduled state to determine if agents are where they are expected to be. Event times must be in UTC time.
| AgentActivity | ||
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM technical team. |
| AgentId | PK, nvarchar(50), not null | Agent login ID from system, used to match transactions to agent name. |
| EventTime | PK, dattime, not null | Primary key, (start time of state; MUST be in UTC). |
| Activity | nvarchar(10), not null | State Code, the work state name (e.g., On a Call, wrap-up). |
| ReasonCode * | nvarchar(10), not null |
Reason Code for secondary state description, (e.g., Aux with reason). |
| SequenceNumber | BigInt, not null | MS SQL Identity Column. |
* Optional column that may or may not be required for a particular application
People Table Layout
The WFMSG.Staging database table People stores Agent name and login data. Data in this table is used to import agents into CommunityWFM.
| People | ||
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM technical team. |
| AgentId | PK, nvarchar(50), not null | Login ID from device that ties agent states to agent name. |
| FirstName | nvarchar(20), not null | First name of agent. |
| LastName | nvarchar(20), not null | Last name of agent. |
CollectionPoints Table Layout
The WFMSG.Staging database table CollectionPoints stores the queue information for importing queue data into CommunityWFM.
| CollectionPoints | ||
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM technical team. |
| CollectionPointid | PK, nvarchar(50), not null | System ID of collection point (skill #, application #). |
| Description | nvarchar(255), not null | Description of collection point. |
CommunityWFM Cloud Connect REST API
This document is a description of the CommunityWFM REST API.
The REST API provides a mechanism for importing agents, collection points, agent activity, and call volume into CommunityWFM | AI WFM. This data allows agent real-time adherence and forecasting with CommunityWFM.
Prior to using the REST API
To use this REST API you will need to obtain:
From your CommunityWFM | AI WFM Project Manager—
- a Base URL
From your WFM Administrator—
- a user credential
- a valid username (in email format)
- a password
This credential created by the WFM administrator should only be used for API access and not be assigned to a person.
Any time AccountID is referenced: use “1” unless instructed otherwise.
Types of Data Used in WFM
Historical Contact Volume Data
Fifteen (15)-minute interval contact data is used for forecasting agent schedules. This data may be automatically populated or imported on demand through the application. A historical data collection service within CommunityWFM | AI WFM will be enabled to routinely capture new data that is present in the API data, whether it is uploaded once a day, once a week, or every fifteen minutes.
Agent State Data
Agent state data is used for adherence reporting. This data, posted using the Agent Activity API, will be automatically populated to the application database. A real-time data collection service within CommunityWFM | AI WFM will be enabled to routinely capture new data that is present in the API data.
Data is available in the application as real-time as it is presented to the Agent Activity API and is suitable for real-time adherence applications. Batch uploads of agent state data provide robust adherence data, but on a delayed basis.
People Data
Simple agent data, such as name and data source ID; used to create new agent profiles.
You may also define agent profiles manually within the CommunityWFM | AI WFM application.
Collection Point Data
Simple information about collection points, such as queue name. This is used to create a list of available queues for the CommunityWFM | AI WFM user.
Resources
This REST API exposes the following resources:
- People – This allows you to define a list of people whose real-time agent state data you will provide in the Agent Activity table, below. This data includes AgentId, First Name, and Last Name.
- Collection Point – This allows you to define a list of collection points, sometimes referred to as skills or queues, whose interval data you will provide in the Call Volume. This data includes CollectionPointId and Description.
- Agent Activity – This allows you to insert agent states to be used for the real-time adherence. This data includes AgentId, Event Time, Activity(state) and an optional Reason Code.
- Call Volume – This allows you to insert interval volume data to be used for forecasting. This data includes at a minimum: Interval, Total ContactsOffered for the interval, Contacts Abandoned for the interval, and Total HandleTime for the interval.
Retrieve Token
The Community Cloud Connect API requires a token to make API calls. Below are the calls needed to get the required token.
Initial Login
This will provide an initial token necessary to make subsequent calls.
POST {Base URL}/api/ccc/auth/login
Header: Content-Type application/json
Body: {
"userName":"valid email address",
"password":"valid password",
"setCookie”: false
}
Sample Response:
{
"Success": true,
"ExceptionResult":null,
"Token": "eyJabcGiOiJIUzI1NiIsInR5cCI6IkpX…",
"RefreshToken":"eyJhbHijkiJIUzI1NiIsInR5c…",
"Message":"Successful FORMS Authentication",
"Data":null
}
Refresh Token
This will get a refreshed token, tokens expire in 1 hour.
POST {Base URL}/api/ccc/auth/refreshtoken
Header: Content-Type application/json
Body: {
"refresh_token":" eyJhbHijkiJIUzI1NiIsInR5c…",
"grant_type":"string",
}
Sample Response:
{
"Success": true,
"ExceptionResult":null,
"Token": "",
"RefreshToken":"",
"Message":"token refresh successful",
"Data":{
"Token": "eyJhbGcacbafiOiJIUzafae…",
"RefreshToken":"ayJdsfGHiOiJIUzI1NiI…",
}
}
People
The People API is a quick and easy way to get all agents into CommunityWFM | AI WFM.
People Data Layout
| People API Schema | ||
| Parameter | Data Type | Description |
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM | AI WFM technical team. |
| AgentId | PK, nvarchar(50), not null |
Login ID from device that ties agent states to agent name |
| FirstName | nvarchar(20), not null | First name of agent |
| LastName | nvarchar(20), not null | Last name of agent |
Get List of Agents
This retrieves a list of all agents currently in the People table. This is useful for determining if the insert methods below were successful.
GET {Base URL}/api/ccc/people/list
Authorization: Auth Type: Bearer “token received from login or refresh”
Parameter: accountId 1
Insert Single Person
This will allow you to insert an agent at a time.
POST {Base URL}/api/ccc/people/InsertPerson
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
"AgentId":"2",
"FirstName":"First2",
"LastName":"Last2"
}
Bulk Insert People
This will allow you to insert a list of people.
POST {Base URL}/api/ccc/People/BulkInsertPeople
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
“AgentInserts” : [
{
"AgentId":"2",
"FirstName":"Joe",
"LastName":"Doe"
},
{
"AgentId":"3",
"FirstName":"Jane",
"LastName":"Doe"
}
]
}
Collection Point
The Collection Point API is a quick and easy way to put all collection points (skills/queues) into CommunityWFM | AI WFM.
CollectionPoint Data Layout
| CollectionPoint API Schema | ||
| Parameter | Data Type | Description |
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM | AI WFM technical team. |
| CollectionPointid | PK, nvarchar(50), not null | System ID of collectionpoint (ie skill #, Application #) |
| Description | nvarchar(255), not null | Description of collection point |
Get List of CollectionPoints
This will get a list of all collection points currently in the CollectionPoints tableThis is useful for determining if the insert methods below were successful.
GET {Base URL}/api/ccc/CollectionPoint/List
Authorization: Auth Type: Bearer “token received from login or refresh”
Parameter: accountId 1
Insert Single Collection Point
This will allow you to insert one collection point at a time.
POST {Base URL}/api/ccc/CollectionPoint/InsertCollectionPoint
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
"CollectionPointId":"1",
"Description":"Collection Point 1"
}
Bulk Insert Collection Points
This will allow you to insert a list of collection points.
POST {Base URL}/api/ccc/CollectionPoint/BulkInsertCollectionPoints
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
“CollectionPointInserts” : [
{
"CollectionPointId":"1",
"Description":"Collection Point 1"
},
{
"CollectionPointId":"2",
"Description":"Collection Point 2"
}
]
}
Agent Activity
The Agent Activity API is a quick and easy way to get all agent state changes into CommunityWFM | AI WFM. We recommend that you queue up data for 30 seconds before sending it to the Agent Activity API.
Agent Activity Data Layout
Important: Event Time must be in UTC time.
| Agent Activity API Schema | ||
| Parameter | Data Type | Description |
| AccountId | PK, Int, not null | Unique identifier per data source provided by CommunityWFM | AI WFM technical team. |
| AgentId | PK, nvarchar(50), not null | Agent login ID from system, used to match transactions to agent name |
| EventTime | PK, dattime, not null | Primary Key, (Start Time of state; MUST be in UTC) |
| Activity | nvarchar(10), not null | State Code, the work state name (i.e., On a Call, wrap-up) |
| ReasonCode * | nvarchar(10), not null | Reason Code for secondary state description, (i.e., Aux with reason) |
* Optional column that may or may not be required for a particular application.
Bulk Insert Agent Activity
This will allow you to insert a list of agent state changes.
POST {Base URL}/api/ccc/AgentActivity/BulkInsertAgentActivity
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
"AgentUpdates":[
{
"AgentId":"4",
"EventTime":"10/20/2020 2:13:12",
"Activity":"notready",
"ReasonCode":"1"
},
{
"AgentId":"5",
"EventTime":"10/20/2020 2:13:12",
"Activity":"OnCall"
}
]
}
Call Volume
The Call Volume API is a quick and easy way to get call volume data into CommunityWFM | AI WFM. We recommend sending this data once every 15 minutes.
Historical Contact Volume Data Layout
| Historical Collection By Interval API Schema | ||
| Parameter | Data Type | Description |
| AccountId | PK, int, not null | Unique identifier per data source provided by CommunityWFM | AI WFM technical team. |
| CollectionPoint | PK, nvarchar(50), not null | Contains the queue name, skill or collection point for a particular row of data. |
| Interval | PK, datetime, not null |
Contains the date and time of the interval for the particular row of historical data. 24 hr. time format most useful. Intervals must be in a 15-minute increment on the 15 minutes. Examples: 2024-06-15 13:00 2024-06-15 13:15 2024-06-15 13:30 2024-06-15 13:45 |
| ContactsOffered | bigint, not null | Number of contacts offered during this time interval for the given skill. |
| ContactsNotHandled | bigint, not null | Number of contacts not handled during this time interval for the given skill. Note that this value contains all contacts not handled, not just those with a disposition of ‘abandoned.’ |
| TalkTime | Float, not null | Total number of seconds of talk time and wrap-up time for the interval and the given skill. |
| HoldTime (required by API can be set to 0) | Float, not null |
Total number of seconds of hold time for the interval and the given skill. This field is optional and may be used if hold time is not included in the TalkTime column. |
| ServiceLevelPct (required by API can be set to 0) | Float, not null | Service level achievement percentage for a given skill. Data from this column is not currently utilized. |
| CollectionTimeStamp* | DateTime, null | The timestamp when the row is inserted into the database. Time zone can be local or UTC. |
| OutboundContacts* | bigint, null | Number of outbound contacts during this time interval for the given skill. |
| OutboundTimeStamp* | Float, null |
Total number of seconds of talk time and wrap-up time for the interval and the given outbound skill. Note: Please disregard the name of the field - it should not be filled with a DateTime time stamp. |
| User Data 1* | Any | Unique identifier provided by Customer |
| User Data 2* | Any | Unique identifier provided by Customer |
| User Data 3* | Any | Unique identifier provided by Customer |
| User Data 4* | Any | Unique identifier provided by Customer |
| User Data 5* | Any | Unique identifier provided by Customer |
| User Data 6* | Any | Unique identifier provided by Customer |
| User Data 7* | Any | Unique identifier provided by Customer |
| User Data 8* | Any | Unique identifier provided by Customer |
| User Data 9* | Any | Unique identifier provided by Customer |
| User Data 10* | Any | Unique identifier provided by Customer |
* Optional column that may or may not be required for a particular application.
Bulk Insert Call Volume
This will allow you to insert a list of call volume changes.
POST {Base URL}/api/ccc/CallVolume/BulkInsertCallVolume
Authorization: Auth Type: Bearer “token received from login or refresh”
Header: Content-Type application/json
Body: {
"AccountId":"1",
"CallVolumeUpdates":[
{
"UpdateExisting":"false",
"CollectionPoint":"1",
"Interval":"10/30/2020 2:15:00",
"ContactsOffered":"5",
"ContactsNotHandled":"2",
"TalkTime":"600",
"HoldTime":"30",
"ServiceLevelPct":"90",
"CollectionTimeStamp":"10/30/2020",
"OutboundContacts":"2",
"OutboundTimeStamp":"3"
},
{
"UpdateExisting":"false",
"CollectionPoint":"2",
"Interval":"10/30/2020 2:15:00",
"ContactsOffered":"8",
"ContactsNotHandled":"0",
"TalkTime":"300",
"HoldTime":"30",
"ServiceLevelPct":"90",
"CollectionTimeStamp":"10/30/2020",
"OutboundContacts":"2",
"OutboundTimeStamp":"3"
},
{
"UpdateExisting":"true",
"CollectionPoint":"2",
"Interval":"10/30/2020 1:15:00",
"ContactsOffered":"9",
"ContactsNotHandled":"3",
"TalkTime":"300",
"HoldTime":"30",
"ServiceLevelPct":"90",
"CollectionTimeStamp":"10/30/2020",
"OutboundContacts":"2",
"OutboundTimeStamp":"3",
“UserData1”:”some extra data”,
“UserData2”:”some extra data”,
“UserData3”:”some extra data”,
“UserData4”:”some extra data”,
“UserData5”:”some extra data”,
“UserData6”:”some extra data”,
“UserData7”:”some extra data”,
“UserData8:”some extra data”,
“UserData9”:”some extra data”,
“UserData10”:”some extra data”,
}
]
}
Enghouse Interactive (EICC)
The objective of this document is to outline the method and details of CommunityWFM | AI WFM integration to Enghouse Interactive Communications Center (EICC). The document assumes that the reader has some basic understanding of EICC and a working understanding of SQL query syntax.
CommunityWFM and EICC Integration
CommunityWFM | AI WFM integrates with the EICC platform using direct queries against an EICC plugin export database for historical data and utilizes a TCPip data feed from EICC for Agent State Transaction Data Collection to facilitate real-time data collection.
Each component of data collection and the required databases and tables are described below.
EICC prerequisite
The EICC requires a plugin extension called WFM Generic Interface, part number SW0028-5. The plugin must be installed and enabled for the CommunityWFM | AI WFM interface to be fully functional.
Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the EICC Generic Workforce Management interface export database. The Community Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Historical Data Collection
The default historical data collection query runs against the Export table and is implemented as follows:
SELECT Queue as 'Skill', Date as 'Date', Period as 'TimePeriod', Calls AS 'CallVolume', Abandons as 'Abandoned', ATT as 'TalkTime', Timestamp FROM [dbo].[Export] WHERE Queue='#AcdSkill#' AND Timestamp > '#DtStart#' AND Timestamp < '#DtEnd#' order by Timestamp asc
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from a socketed TCP/ip connection to EICC. The Community Real-time collection service activates and maintains a connection to the stream from EICC.
Individual states including Agent login, logout, break, and worktime are passed via the steam. CommunityWFM | AI WFM collects, timestamps, and stores the transactions as they are presented.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import Agent and Queue data directly from EICC into CommunityWFM | AI WFM. Configuration data is retrieved from the EICC Core database using a native .net provider.
Agent Profile Data
CommunityWFM | AI WFM imports the agent profile data using the following query:
select pn.LoginID as 'Employee_Id', n.FirstName as 'First_Name', n.LastName as 'Last_Name' from pn_user pn join names n on n.UniqueID=pn.NameID order by n.LastName, n.FirstName;
Contact Types Data
Finally for skills, CommunityWFM | AI WFM imports the data using the following query:
select Number AS 'ACDSkillID', Name AS 'Name' from pn_virtual where MediaSupport IN (1, 3, 9) order by Name;
Port Configuration
CommunityWFM | AI WFM interfaces to EICC through two distinct methods. A Native .net SQL provider to the SQL databases and a TCP streaming feed interface for agent real-time events.
Real-time interface
CommunityWFM | AI WFM interfaces using configurable port options, but the default port is 6003.
Five9
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a Five9 system. The document assumes that the reader has some basic understanding of the Five9 cloud contact center solution. This adapter was developed using v11 APIs from the Five9 platform.
CommunityWFM and Five9 Integration
CommunityWFM | AI WFM integrates with the Five9 platform using multiple Web Services APIs. The Five9 Web Services APIs are an application program interface (API) that uses HTTP requests to communicate with the cloud contact center solution. The communication to Five9 consists of sending in credentials for authentication, sending requests for data, and then processing the data for use within CommunityWFM | AI WFM.
Historical Data Collection
CommunityWFM | AI WFM calls the Five9 Web Services API, more specifically the “Configuration Web Services API”, to run a custom report that continues the call volume information that is needed for CommunityWFM | AI WFM. See the appendix for instructions on creating this report. This data will be used for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
- Handle Time – Total handle time during the 15-minute window
- Calls – Total number of calls during the 15-minute window
- Abandoned count – Total number of abandoned calls during the 15-minute window.
Five9 customers are required to know the following information. Note: Passwords are commonly set to expire every 90 days.
Historical contact volume data collection
| Base URL: | |
| Version: | |
| Account: | |
| Password: |
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Five9 Web Services API, more specifically the “Statistics Web Services API”, to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) polls the Web Service on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the Community product database.
Five9 customers are required to know the following information. Note: Passwords are commonly set to expire every 90 days.
Real-time adherence integration
| Base URL: | |
| Version: | |
| Account: | |
| Password: | |
| Transaction Collection Interval (seconds): |
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Five9 cloud contact center solution into CommunityWFM | AI WFM. Configuration data is retrieved by making Configuration Web Services API calls to pull back the data.
Appendix: Five9-VCC Contact Volume
Report Instructions
The customer must create a Service Account that is an Administrator level user with a virtual contact center (VCC) administrator role. This user must have settings with the ability to execute WebAPI requests. The user must have rights to the AdminWebService for the Configuration Web Services API and SupervisorWebSevice for Statistics Web Services API.
The following are steps for creating the Calls By Time Of Day for WFMSG report required for Contact Volume data collection.
- Log in to Five9 as the newly created Service Account.
- Make sure the account is set up properly for password recovery, etc. and that you can easily get to the landing page shown below.
- Select Dashboard & Reports.
- Select Custom Reports from the upper ribbon.
- Click Create New Custom Report.
Next, complete the first six steps of the seven-step wizard then save.
Step 1: Select ACD queue as the type of data you wish to report on, then click Next.
Step 2: Select Summary Report as the type of report then click Next.
Step 3: Select the following fields(columns) to include in the report.
Time
- DATE
- QUARTER HOUR
ACD
- ABANDONED
- SKILL
Calls
- CALLS
Call Statistics
- HANDLE TIME
Click Next.
Step 4: Click to select/highlight the column names then use the arrow buttons to the right to order the columns as follows: DATE, QUARTER HOUR, SKILL, CALLS, ABANDONED, HANDLE TIME.
Click Next.
Step 5: Set the summarization method for CALLS and ABANDONED to Count and HANDLE TIME to Sum.
Click Next.
Step 6: Using the dropdown menu select DATE, then QUARTER HOUR and finally by SKILL as the Order/Grouping information. Also check Hide Details at bottom.
Now select Save instead of continuing to 7th step.
Save the report with the precise name of Calls By Time Of Day for WFMSG ensuring that each letter is the proper case and that there is only one space between each word.
Select My Reports as the report folder then click Save.
The Custom Reports dialog now includes your report.
Genesys Cloud
The objective of this document is to outline the method and details of integrating the CommunityWFM | AI WFM solution with a Genesys Cloud system. This document assumes that the reader has some basic understanding of the Genesys Cloud contact center platform.
CommunityWFM | AI WFM and Genesys Cloud Integration
CommunityWFM | AI WFM integrates with the Genesys Cloud platform using their Analytics API, Users API, Routing API, and Notifications API. The communication to Genesys Cloud consists of sending a Client ID (Access Key) and Client Secret (Secret) for authentication (provided by the customer) and the request for the data retrieval on an interval basis.
Each component of data collection and the required database and table are described below.
Genesys Setup and Required Permissions
Below are depictions of how to create an application interface in Genesys.
This is where to retrieve the ClientID and Client Secret for use in the Genesys Cloud Adapter.
Developer Permission
This shows setting up permission for the Developer role, which is required for the API calls to work properly.
Toggle the Assigned button to on for Developer.
Click Developer in the Roles tab to open the Permissions tab. Select all available permissions for the Developer role.
Genesys Cloud Adapter Configuration Page
Enter the Access Keys and Secrets and select the correct Region Endpoint for your system.
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Genesys Cloud API to use in call volume and handle time reports and for forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The historical data retrieved from this call includes the following columns:
- sumHandleTime Total handle time during the 15-minute window.
- enteredCount Total number of calls during the 15-minute window.
- abandonedCount Total number of abandoned calls during the 15-minute window.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Real-Time Statistics Reporting API for Genesys Cloud to compare to scheduled intervals and report agent schedule adherence. The Community Adherence Collection Service (a .NET Windows service) executes the request based on the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the Community product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id Unique identifier for the agent
- agent-status Agent state
I3 CIC
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to I3 Customer Interaction Center (CIC). The document assumes that the reader has some basic understanding of the I3 CIC database layout and a working understanding of SQL query syntax.
CommunityWFM and I3 CIC Integration
CommunityWFM | AI WFM integrates with the I3 CIC platform using direct queries against the CIC I3_IC database via a .net native SQL provider. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the I3 CIC platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the I3_IC database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the IWrkgrpQueueStats, table and is implemented as follows:
I3 CIC default contact historical query
SELECT dIntervalStart AS 'Slot', nDuration AS 'Duration', cName AS 'Skill', nAnsweredAcd + nAbandonedAcd + nFlowOutAcd AS 'CallVolume', nAbandonedAcd + nFlowOutAcd AS 'Abandoned', tAgentOnAcdCall + tAgentInAcw AS 'HandleTime' FROM IWrkgrpQueueStats WHERE dIntervalStart > '#DtStart#' AND dIntervalStart <= '#DtEnd#' AND cName = '#AcdSkill#' #SiteID# AND cReportGroup='*' ORDER BY Slot ASC, Skill ASC
Note: The historical collection service implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the I3_IC database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM product database.
The state transaction collection service executes the following query against the AgentActivityLog table:
select I3TimeStampGMT, UserId, StatusKey, StatusDateTimeGMT, EndDateTimeGMT, CASE WHEN StateDuration = 0 THEN 1 ELSE 0 END AS 'IsCurrentTransaction' FROM AgentActivityLog WHERE I3TimeStampGMT > '" + FormatDateTime(m_last_dt) + "' order by StatusDateTimeGMT
Note: The FormatDateTime(m_last_dt) is c# code that formats the last read time into an SQL string to only pull transactions that occur after the last time the service was executed.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import contact queue information and agents directly from the I3 database into CommunityWFM | AI WFM. Configuration data is retrieved from the I3_IC database using the database credentials provided by the end user.
Contact Queue Data
SELECT ObjectName AS 'ACDSkillId', ObjectName AS 'Name' from Object where ObjectType IN (1,2,3,4,5,6,7) AND IsReal=1
Agent Information
SELECT lastname AS 'Last_Name', firstname AS 'First_Name', ICUserId AS 'Employee_Id' FROM Individual WHERE IndivTypeId=2 AND DATALENGTH(LastName) > 2 AND DATALENGTH(FirstName) > 2 ORDER BY LastName, FirstName
Intermedia
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to an Intermedia system. The document assumes that the reader has some basic understanding of the Intermedia contact center platform.
CommunityWFM | AI WFM and Intermedia Integration
CommunityWFM | AI WFM integrates with the Intermedia platform using a hybrid, of their REST APIs written for WFM integrations, along with Community Cloud Connect (CCC) to receive a push real-time agent state data. The Intermedia API being used is the “Contact Center API,” which uses HTTP requests to communicate with the contact center platform. Communication to Intermedia consists of sending in a username and password and an account ID for authentication (provided by Intermedia and the customer). CommunityWFM | AI WFM will supply the customer with the base URL and API key of the CCC for pushing real-time data. All times are returned in Unix time UTC.
Each component of data collection and the required database and table are described below.
Thrio Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects individual call record data from the Intermedia REST API to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and summarizes the results into vendor-neutral tables inside the CommunityWFM product database.
The following query is used to summarize the retrieved data:
with temp_table as (SELECT [ivr_id],dbo.fnDateTimeToSlotTimeEx(qh_queuingdateutc, 15) as [SlotTime],[qh_queueid] as [Skill],[qh_queuingdateutc], [ah_answereddateutc], [ah_wrapupendutc], DATEDIFF(second, [ah_answereddateutcInt],[ah_wrapupendutc]) as [Duration],[abandoned] FROM [t_adapter_call_data_intermedia] where qh_queueid = '#Skill#' and qh_queuingdateutc >= dateadd(hour, -2, '#StartDateTime#') and qh_queuingdateutc < '#EndDateTime#') SELECT SlotTime as [Slot],Skill,COUNT(slottime) as [CallVolume], SUM(abandoned) as [Abandoned], SUM(Duration) as [HandleTime] FROM temp_table GROUP BY Skill, SlotTime ORDER BY SlotTime asc;
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the CCC database to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id – Unique identifier for the agent
- Activity – Agent state
- Possible states include:
- Available
- Logged out
- Logged on
- On Call
- Wrap-up
- Lunch
- Dial Out
- (Any custom states created by a customer)
- Possible states include:
- Reason Code
- This comes back as numbers like
- 16
- 32
- 33
- 1
- etc
- This comes back as numbers like
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Intermedia system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
LinkLive (Journey Engine or CEP)
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration with a LinkLive Journey Orchestration Engine (JEO) or legacy (CEP) systems. The document assumes that the reader has some basic understanding of the LinkLive JEO or CEP contact center platform.
CommunityWFM | AI WFM and LinkLive Integration
CommunityWFM | AI WFM integrates with the LinkLive platform using the LinkLive REST APIs. The LinkLive APIs being used are users, queues, userstates and queueEngagementIntervals, all which use HTTP requests to communicate with the contact center platform. The communication to LinkLive consists of sending in an authorization token for authentication. LinkLive also calls this an API Key. The API Key is created from within the LinkLive Admin experience. All times are requested to be returned in Universal time UTC.
LinkLive Admin API Key Creation
In the Link Live Admin experience, select API Keys from the left navigation bar then select “New API Key”. The new key should be configured with the Admin role and to never expire. After selecting the “create” button be sure to make an immediate note for the provided key.
After you navigate away from the page by dismissing the dialog you will never be able to display the key again.
LinkLive JEO or CEP Data Source Configuration Page
The base URL should be https://api.linklive-legacy.com/v2/organizations/ for JEO or https://api.linklive-prod.com/integrations/v1/privateGroups/ should be used for CEP environments.
The Customer should obtain their Organization ID from LinkLive.
The api key written to the Auth Header parameter must start with “ApiKey llapi_”
The real time and historical configuration information is usually the same and must be written to each tab individually.
Each component of data collection and the required database and table are described below.
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the LinkLive REST Reporting Data API, queueEngagementIntervals, to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
totalHandleTimeMs – Total handle time during the 15-minute window
enqueuedCount – Total number of calls during the 15-minute window
abandonedCount – Total number of abandoned calls during the 15-minute window
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the LinkLive REST Reporting Data, userStates API to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- userId – Unique identifier for the agent
- agent-status = presenceStatus + activity + allocationStatus
- Possible states include:
- online_unavailable_not_allocated
- online_available_fully_allocated
- offline_unavailable_partially_allocatedAvailable
- Possible states include:
- startTimestamp – time agent entered state
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the LinkLive system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
LiveVox
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a LiveVox system. The document assumes that the reader has some basic understanding of the LiveVox cloud contact center solution and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and LiveVox Integration
CommunityWFM | AI WFM integrates with the LiveVox platform using a RESTful API. The LiveVox RESTful API (also known as a RESTful web service) is an application program interface (API) that uses HTTP requests to communicate with the cloud contact center solution. The communication to LiveVox consists of sending in credentials for authentication, receiving a data token to be used in future requests, and then requesting data on an interval basis.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM uses the Real-time adapter to also collect raw call volume data. This raw call volume data is stored in a database table and then normalized to 15-minute interval data by the historical adapter. This data can then be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the CommunityWFM database table t_adapter_call_event_data:
Default historical query
with raws as
(
select *
, case when operator_transfer = 1 and operator_transfer_successful = 0 then 1 else 0 end as [Abandoned]
,dbo.fnDateTimeToSlotTimeEx(start_time, 15) as [SlotTime]
from t_adapter_call_event_data
where service_id = '#Skill#'
and call_event_type = 'CALL_TERMINATION'
and call_center_id = '#CallCenterId#'
and start_time >= '#StartDateTime#'
and start_time < '#EndDateTime#'
)
select SlotTime as [Slot]
,service_id as [Skill]
,count(*) as [CallVolume]
,sum(duration) as [HandleTime]
,sum(Abandoned) as [Abandoned]
from raws
group by service_id, SlotTime
order by SlotTime asc;
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the LiveVox RESTful API to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) continuously monitors the feed from the RESTful web service and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
LiveVox customers are required to know the following information. Note: Passwords are commonly set to expire every 90 days. LiveVox professional services may have a work-around.
Single Sign On (SSO)
If SSO has been enabled to connect with LiveVox’s main user experience, then SSO must be enabled and configured for the CommunityWFM | AI WFM LiveVox collector.
Note: As of the writing of this document, LiveVox only supports Open ID Connedt (OIDC) as the SSO method to access the API that CommunityWFM | AI WFM uses for data collection. SAML/SAML2 is not supported and only Okta and MS Azure identity providers (IdPs) are supported by LiveVox.
Pay close attention to OIDC methods.
Additional parameters needed if OIDC SSO
- SSO URL: This is the base URL of the IdP’s token retrieval entry point for the OIDC application you created.
Okta example: https://YourDomain.okta.com/oauth2/v1/token.
MS Azure example: https://login.microsoftonline.com/{tenant}/oauth2/v2.0/token.
- SSO Client ID: This is an ID created by/in the IdP for your application.
- SSO Client Secret: this is a secret that goes along with the above ID.
Initial Parameters
- Account: an SSO “Service User” account of LiveVox with appropriate rights.
- Password: the SSO password for the account.
Importing Configuration Data
CommunityWFM | AI WFM Supports the ability to import queue information and agents directly from the LiveVox cloud contact center solution into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Mitel MiConnect
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Mitel MiContact Center. The document assumes that the reader has some basic understanding of the MiContact database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and MiContact Center Integration
CommunityWFM | AI WFM integrates with the Mitel MiContact platform using a two-phase approach.
CommunityWFM | AI WFM uses direct queries against the MiContact CCMData database. Tables within the database satisfy the historical data collection requirements to fully integrate the CommunityWFM | AI WFM application for forecasting and reporting purposes.
Additionally, CommunityWFM | AI WFM utilizes the Mitel Workforce Connector for the purposes of Real-time agent state data collection.
Each component of data collection and the required databases and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from custom reporting views in the CCMData database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into device-neutral tables inside the CommunityWFM | AI WFM product database.
Historical Collection
The default historical data collection query is executed against the Queue Performance by PeriodStats view:
SELECT MidnightStartDate as 'Slot', QueueID as 'Skill', QueueOffered as 'CallVolume', QueueAbandoned as 'Abandoned', QueueTalkTimeTotal as 'HandleTime' FROM QueuePerformanceByPeriodStats WHERE QueueID='#SkillId#' AND MidnightStartDate > DATEADD(hour, -2, '#DtStart#') AND MidnightStartDate < '#DtEnd#' order by MidnightStartDate asc
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions using a socketed connection from the Mitel Workforce Connector over port 6999.
The collection process extracts the agent state data from a continuous comma delimited feed and passes it to the Community Adherence Database.
CommunityWFM | AI WFM captures all available Agent States.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agent and skill data directly from the Mitel database views into CommunityWFM | AI WFM. Configuration data is retrieved from the MiContact CCMdata database.
Agent Profile Data
Community imports the agent profile data using the following query:
SELECT Reporting AS 'Employee_ID', FirstName AS First_Name, LastName AS Last_Name FROM tblConfig_Agent ORDER BY Last_Name ASC
Contact Types Data
Community imports skill data using the following query:
SELECT Name, Pkey AS 'ACDSkillID' FROM tblConfig_Queue ORDER BY Name ASC
Port Configuration
CommunityWFM | AI WFM interfaces to Mitel MiContact through two distinct methods: A .Net SQL provider connection to the CCMData database and a TCP streaming report interface for agent real-time events.
Historical interface
CommunityWFM | AI WFM interfaces using a .Net SQL provider, typically over port 1433.
Real-time interface
CommunityWFM | AI WFM interfaces using configurable port options, but the default port is 6999 dit.
NEC BCT
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to NEC BCT ACD. The document assumes that the reader has some basic understanding of the BCT United database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and NEC BCT Integration
CommunityWFM | AI WFM integrates with the NEC BCT platform using direct queries against the BCT United database via a .net native SQL provider. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the NEC BCT platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the NEC BCT database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the RawHistData_RouterCallDataView and RawHisData_ACWDataView views and is implemented as follows:
BCT default contact historical query
SELECT DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AS 'Slot'
,RCDV.RouterName AS 'Skill'
,COUNT(*) AS 'ContactsOffered'
,MAX(ISNULL(ABANS.NotHandled, 0)) AS 'NotHandled'
,SUM(DATEDIFF(SECOND, DateTimeCallAnsweredAtUserPhone, DateTimeCallEndedAtUserPhone)) AS 'TalkTime'
,MAX(ISNULL(ACW.ACW, 0)) AS 'ACW'
,SUM(DATEDIFF(SECOND, DateTimeCallAnsweredAtUserPhone, DateTimeCallEndedAtUserPhone)) + MAX(ISNULL(ACW.ACW, 0)) AS 'TotalHandlingTime'
FROM dbo.RawHistData_RouterCallDataView RCDV
LEFT JOIN ( SELECT COUNT(*) AS 'NotHandled'
,RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AS 'Slot'
FROM dbo.RawHistData_RouterCallDataView ABS
WHERE UPPER(CallResult) IN ('ABANDONED', 'ERROR', 'NOAGENT', 'TIMEOUT')
GROUP BY RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0)) ABANS ON ABANS.Slot = DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AND ABANS.RouterName = RCDV.RouterName
LEFT JOIN ( SELECT SUM(DATEDIFF(second, ACWSTartTime, ACWEndTime)) AS 'ACW'
,RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, ACWStartTime) / 15 * 15, 0) AS 'Slot'
FROM dbo.RawHistData_ACWDataView
GROUP BY DATEADD(MINUTE, DATEDIFF(minute, 0, ACWStartTime) / 15 * 15, 0)
,RouterName) ACW ON ACW.Slot = DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AND ACW.RouterName = RCDV.RouterName
WHERE UPPER(CallResult) IN ('ANSWERED', 'ABANDONED')
GROUP BY RCDV.RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0)
ORDER BY RCDV.RouterName, Slot
Note: The historical collection service implements replacement characters for the WHERE condition (not included above). The data collection service resolves these replacement tokens when it executes the query for individual queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the NEC BCT database to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The state transaction collection service executes the following query against the RawHistData_AgentGlobalStatusView view:
SELECT UserLoginName
,DateTimeUserStateStarted
,CONVERT(nvarchar, StateId) + ISNULL(UserNotReadyReason, '') AS 'State'
FROM dbo.RawHisData_AgentGlobalStatusView
ORDER BY UserLoginName, DateTimeUserStateStarted
Note: The FormatDateTime(m_last_dt) is c# code that formats the last read time into an SQL string to only pull transactions that occur after the last time the service was executed.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the NEC BCT database into CommunityWFM | AI WFM. Configuration data is retrieved from the database using the database credentials provided by the end user.
Queue Data Collection
SELECT rtr_Description AS ACDSkillId, rtr_Description AS Name FROM RouterView
Agent Information
SELECT LoginName AS 'Employee_ID', FirstName AS First_Name, LastName AS Last_Name FROM RawData_UserNameAndRolesView ORDER BY Last_Name ASC
NEC GNAV
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to NEC GNAV. The document assumes that the reader has some basic understanding of the NEC GNAV database layout and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and NEC GNAV Integration
CommunityWFM | AI WFM integrates with the NEC GNAV platform using direct queries against the NEC GNAV database via a .net native SQL provider. Tables within the database satisfy the data collection requirements to fully integrate the CommunityWFM | AI WFM application with the NEC GNAV platform.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the NEC GNAV database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the RawHistData_RouterCallDataView and RawHisData_ACWDataView views and is implemented as follows:
GNAV default contact historical query
SELECT DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AS 'Slot'
,RCDV.RouterName AS 'Skill'
,COUNT(*) AS 'ContactsOffered'
,MAX(ISNULL(ABANS.NotHandled, 0)) AS 'NotHandled'
,SUM(DATEDIFF(SECOND, DateTimeCallAnsweredAtUserPhone, DateTimeCallEndedAtUserPhone)) AS 'TalkTime'
,MAX(ISNULL(ACW.ACW, 0)) AS 'ACW'
,SUM(DATEDIFF(SECOND, DateTimeCallAnsweredAtUserPhone, DateTimeCallEndedAtUserPhone)) + MAX(ISNULL(ACW.ACW, 0)) AS 'TotalHandlingTime'
FROM dbo.RawHistData_RouterCallDataView RCDV
LEFT JOIN ( SELECT COUNT(*) AS 'NotHandled'
,RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AS 'Slot'
FROM dbo.RawHistData_RouterCallDataView ABS
WHERE UPPER(CallResult) IN ('ABANDONED', 'ERROR', 'NOAGENT', 'TIMEOUT')
GROUP BY RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0)) ABANS ON ABANS.Slot = DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AND ABANS.RouterName = RCDV.RouterName
LEFT JOIN ( SELECT SUM(DATEDIFF(second, ACWSTartTime, ACWEndTime)) AS 'ACW'
,RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, ACWStartTime) / 15 * 15, 0) AS 'Slot'
FROM dbo.RawHistData_ACWDataView
GROUP BY DATEADD(MINUTE, DATEDIFF(minute, 0, ACWStartTime) / 15 * 15, 0)
,RouterName) ACW ON ACW.Slot = DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0) AND ACW.RouterName = RCDV.RouterName
WHERE UPPER(CallResult) IN ('ANSWERED', 'ABANDONED')
GROUP BY RCDV.RouterName
,DATEADD(MINUTE, DATEDIFF(minute, 0, DateTimeCallArrivedAtThisModule) / 15 * 15, 0)
ORDER BY RCDV.RouterName, Slot
Note: The historical collection service implements replacement characters for the WHERE condition (not included above). The data collection service resolves these replacement tokens when it executes the query for individual queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the NEC GNAV database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Note: The agent state collection service implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query.
The state transaction collection service executes the following query against the RawHistData_AgentGlobalStatusView view:
SELECT UserLoginName
,DateTimeUserStateStarted
,CONVERT(nvarchar, StateId) + ISNULL(UserNotReadyReason, '') AS 'State'
FROM dbo.RawHisData_AgentGlobalStatusView
ORDER BY UserLoginName, DateTimeUserStateStarted
Note: The FormatDateTime(m_last_dt) is c# code that formats the last read time into an SQL string to only pull transactions that occur after the last time the service was executed.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import Queue information and Agents directly from the NEC GNAV database into CommunityWFM | AI WFM. Configuration data is retrieved from the database using the database credentials provided by the end user.
Queue Data Collection
SELECT rtr_Description AS ACDSkillId, rtr_Description AS Name FROM RouterView
Agent Information
SELECT LoginName AS 'Employee_ID', FirstName AS First_Name, LastName AS Last_Name FROM RawData_UserNameAndRolesView ORDER BY Last_Name ASC
Nextiva NCC
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a Nextiva NCC system. The document assumes that the reader has some basic understanding of the Nextiva NCC contact center platform.
CommunityWFM | AI WFM and Nextiva NCC Integration
CommunityWFM | AI WFM integrates with the Nextiva NCC platform using their REST APIs written for WFM integrations. The Nextiva NCC API being used is the “Community Integration,” which uses HTTP requests to communicate with the contact center platform. The communication to Nextiva NCC consists of sending in a username and password to request a token for authentication (provided by Nextiva NCC). The token retrieved is then used to retrieve all the other data required for this implementation. All times are returned in Unix time UTC.
Each component of data collection and the required database and table are described below.
Nextiva NCC Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Nextiva NCC REST API to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
sumHandleTime – Total handle time during the 15-minute window
enteredCount – Total number of calls during the 15-minute window
abandonedCount – Total number of abandoned calls during the 15-minute window
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Nextiva NCC REST API to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id – Unique identifier for the agent
- agent-status – Agent state
- Possible states include:
- Available
- Busy
- Logged out
- Logged in
- Working
- Wrapup
- No Answer
- (Any custom states a customer creates)
- Possible states include:
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Nextiva NCC system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Nice CXone
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to the Nice CXone cloud ACD. The document assumes that the reader has some basic understanding of the SQL Query syntax and a basic understanding of the Nice CXone cloud architecture.
CommunityWFM | AI WFM and Nice CXone Integration
CommunityWFM | AI WFM integrates with the Nice platform CXone using a web service interface that pulls data from the cloud and stores the data in an intermediate database. Tables within the intermediate database satisfy the requirements to fully integrate the CommunityWFM | AI WFM application with the Nice platform.
Nice Web Service Connector
A Web connector runs inside a Windows Service continuously retrieving detailed transactional data from the Nice hosted platform and placing the data in one of four tables in an intermediate database. Contact data, agent state data along with configuration data such as agents and queues are placed in their individual tables in the database.
The real-time nature of the web service connector is such that only about 24 hours’ worth of data may be retrieved if the collection process is stopped.
Authentication to Web Service
The CommunityWFM | AI WFM Nice integration requires specific credentials from Nice to authenticate and retrieve customer data from CXone and assumes an API base url of https://cxone.niceincontact.com
The required fields are:
- Business Number – 1234567*
- Partner GUID – ZX9876ZY-99ZY-12A0-0A0A-Z01Z123456Z1*
- Partner Password – AB1234AB-00AB-12A0-0A0A-A01A123456A1*
*sample formatting
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the intermediate database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Historical Collection
The default historical data collection, the query runs against a summarized view of the t_contact table. CommunityWFM | AI WFM will look back into and repopulate prior intervals as needed to ensure that all records have been captured.
The query is implemented as follows:
SELECT StartDateSlot AS 'Slot', SkillNo AS 'Skill', contacts_offered AS 'CallVolume', contact_abandoned AS 'Abandoned', talk_time AS 'HandleTime' from IntervalSummary WHERE BusinessNo=#BusNo# AND SkillNo=#SkillId# AND StartDateSlot > DATEADD(HOUR, -2, '#DtStart#') AND StartDateSlot < '#DtEnd#'
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state data for adherence purposes from the intermediate database as well. The Community Real-time Data Collection Service (a .NET Windows service) executes a query against the RTAAgentState table approximately every ten seconds and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Port Configuration
CommunityWFM | AI WFM interfaces to using a web service interface. The web service interface must be able to communicate over Port 80.
Nice inContact
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to the inContact cloud ACD. The document assumes that the reader has some basic understanding of the SQL Query syntax and a basic understanding of the inContact cloud architecture.
CommunityWFM | AI WFM and inContact Integration
CommunityWFM | AI WFM integrates with the inContact platform, called inSideWS, using a web service interface that pulls data from the cloud and stores the data an intermediate database. Tables within the intermediate database satisfy the requirements to fully integrate the CommunityWFM | AI WFM application with the inContact platform.
inContact Web Service Connector
A Web connector runs inside a Windows Service continuously retrieving detailed transactional data from the inContact hosted platform and placing the data in one of four tables in an intermediate database. Contact data, agent state data along with configuration data such as agents and queues are placed in their individual tables in the database.
The real-time nature of the web service connector is such that only about 24 hours’ worth of data may be retrieved if the collection process is stopped.
Authentication to Web Service
The CommunityWFM | AI WFM inContact integration requires specific credentials from inContact to authenticate and retrieve customer data from inSideWS.
The required fields are:
- Business Number – 1234567*
- Partner GUID – ZX9876ZY-99ZY-12A0-0A0A-Z01Z123456Z1*
- Partner Password – AB1234AB-00AB-12A0-0A0A-A01A123456A1*
*sample formatting
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the intermediate database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes a single query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Historical Collection
The default historical data collection, the query runs against a summarized view of the t_contact table. CommunityWFM | AI WFM will look back into and repopulate prior intervals as needed to ensure that all records have been captured.
The query is implemented as follows:
SELECT StartDateSlot AS 'Slot', SkillNo AS 'Skill', contacts_offered AS 'CallVolume', contact_abandoned AS 'Abandoned', talk_time AS 'HandleTime' from IntervalSummary WHERE BusinessNo=#BusNo# AND SkillNo=#SkillId# AND StartDateSlot > DATEADD(HOUR, -2, '#DtStart#') AND StartDateSlot < '#DtEnd#'
Note: This query implements replacement characters for the WHERE condition. The data collection service resolves these replacement tokens when it executes the query for individual skills.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state data for adherence purposes from the intermediate database. The Community Real-time Data Collection Service (a .NET Windows service) executes a query against the RTAAgentState table approximately every ten seconds and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
Port Configuration
CommunityWFM | AI WFM interfaces to inContact using a web service interface. The web service interface must be able to communicate over Port 80.
RingCentral - RingCX
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration with a RingCentral RingCX system. The purpose of the integration is to retrieve data and statistics that are essential for workforce management. The document assumes that the reader has some basic understanding of the RingCentral RingCX contact center platform.
CommunityWFM | AI WFM and RingCentral Integration
CommunityWFM | AI WFM integrates with the RingCentral platform using their RingCX APIs. The RingCentral APIs being used are the “RingCX Voice API” which uses HTTP requests to communicate with the contact center platform. The communication to RingCentral consists of sending in a tenant id and a data request token for authentication (provided by RingCentral) and the request for the data retrieval on an interval basis. Realtime agent state data is pushed to a webhook.
Each component of data collection and the required database and table are described below.
Connectivity and Authentication
This collector conforms to RingCentral’s JWT auth flow and requires a JWT to be created for a RingCX user that will act as the credential for the CommunityWFM | AI WFM collector to access the RingCentral API. We recommend creating a stand-alone application/service account within RingCentral for this purpose and not using an actual person’s account credentials. This service account user must have WEM access enabled by RingCentral Professional Services. JWT credentials can only be created by users who have a valid admin account or role. Further information on creating the JWT can be found here: https://developers.ringcentral.com/guide/getting-started/create-credential
RingCentral Developer Portal page:
When creating the credential within the Ring Central developer portal, select “Only specific apps of my choice” and enter the provided Client ID. Please leave the Expiration Date blank.
Once the JWT is created, find the newly created credential in your credential list, click the “click to see” link, copy the resulting JWT, and securely provide it to the CommunityWFM project manager.
Additional information you will need to provide:
- Base URL of your RingCentral instance if different from https://platform.ringcentral.com/
- RingCX URL if different than https://ringcx.ringcentral.com/
- Your RingCentral Main Account ID (also known as the UID)
Note: This is not the RingCX main account id
- Your RingCX Sub Account ID
CommunityWFM | AI WFM Configuration Pages for RingCentral
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the RingCentral QueueStatistics Report API to be used in volume and handle time reports and for future forecasting. The CommunityWFM | AI WFM Historical Data Collection Service executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
CommunityWFM | AI WFM uses the https://ringcx.ringcentral.com/voice/api/cx/integration/v3/accounts/{{mainAccountID}}/sub-accounts/{{AccountID}}/agg-queue-stats endpoint.
CommunityWFM | AI WFM collects:
| Return JSON key name | CommunityWFM use |
| dateTimeFrom | Interval (Slot) |
| queue | queue ID |
| (offdDirectIxnCnt + overflowInIxnCnt) - overflowOutIxnCnt) | Calls Offered |
| abandIxnCnt | Abandoned |
| talkingIxnDur + wrapUpDur | Handle Time |
Agent State Transaction Data Collection
CommunityWFM | AI WFM receives agent state transactions from a push to a Community Cloud Connect (CCC) webhook from RingCentral RingCX to compare against scheduled intervals to provide agent schedule adherence reporting. The webhook is configured by a CommunityWFM | AI WFM system engineer, using the following location (to be modified).
https://{customersubdomainhere}.my.communitywfm.com/api/webhook/RingCentral/RingCentralAgentData
The webhook process places the received data into an intermediate database table. The CommunityWFM | AI WFM Adherence Collection Service executes a request from the intermediate table based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data received from this push (realTime) includes the following columns:
| Return JSON key name | CommunityWFM | AI WFM use |
| agentId | loginId |
| baseStateId + “_ “ + stateId | adapter_state_id |
| eventTime | starttime |
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the RingCentral API into CommunityWFM | AI WFM. Agent list is provided by calls to Agent Group and Agent Endpoints. Queue information is from calls to Gate Groups and Gates.
Salesforce
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Salesforce.com data. The document assumes that the reader has some basic understanding of the database layout and a working understanding of database layouts and schema.
CommunityWFM | AI WFM and Salesforce.com Integration
CommunityWFM | AI WFM does not natively integrate with the Salesforece.com platform. However, using direct queries against either a discrete SQL Server database or a view from the existing Salesforce SQL Server data warehouse, data can be retrieved for use in CommunityWFM | AI WFM.
Connection
CommunityWFM | AI WFM will connect to the SQL database using a native .net SQL provider. No additional connection configuration, such as ODBC, will be required.
Authentication
CommunityWFM | AI WFM will authenticate to the database or view using variables for the database name, login and password. A read-only SQL login and password will be required for access. Trusted connections are not supported.
Data Table or View Specification
The following attributes describe the record set expected for the data collection services in CommunityWFM | AI WFM. The source object can be either a table or view; the important requirement is that the data be summarized by 15-minute time interval and device skill.
The following table provides a typical schema for the most direct and robust data collection mechanism given the internal characteristics of the CommunityWFM | AI WFM data collection system.
| Attribute Name | Data Type (SQL Server) | Description |
| Time Interval | datetime | Indicates the date and time of the interval data. Based on 15-minute interval size. |
| Device SkillId | varchar(50) | Provides the device skill / queue / split identifier for the interval row. |
| Contacts Offered | int (Not Null) | Total number of contacts offered during the 15-minute interval range. |
| Contacts Not Handled | int (Not Null) | Indicates the number of contacts that are offered to the skill / queue / split but are not handled by agents in that group. This count should include any call that is not handled by an agent in the group for any reason, such as abandoned, transferred, etc. |
| Total Talk Time | int (Not Null) | Total number of seconds, including any wrap-up time, required to resolve all the calls in the 15-minute time interval. |
Sharpen
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a Sharpen system. The document assumes that the reader has some basic understanding of the Sharpen contact center platform.
CommunityWFM | AI WFM and Sharpen Integration
CommunityWFM | AI WFM integrates with the Sharpen platform using a RESTful API. The Sharpen RESTful API (also known as a RESTful web service) is an application program interface (API) that uses HTTP requests to communicate with the contact center platform. The communication to Sharpen consists of sending in an application key for authentication (provided by Sharpen) and the request for the data retrieval on an interval basis.
There are four calls that are utilized in the Sharpen RESTful API:
- listUser – used to retrieve a list of all active agents
- getQueues – used to retrieve all active queues on the account
- realTime – used to retrieve real-time agent state data
- historical – used to retrieve historical call volume data
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Sharpen RESTful API to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
- sumHandleTime – Total handle time during the 15-minute window
- enteredCount – Total number of calls during the 15-minute window
- abandonedCount – Total number of abandoned calls during the 15-minute window`
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Sharpen RESTful API to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the Community product database.
The data retrieved from this call (realTime) includes the following columns:
- uKey – Unique identifier for the agent
- statusCode – Agent state
Possible states include:
- Offline
- Active
- Paused-break (break could be replaced with the actual pause reason)
- Messaging
- On call
- Paused – not logged into any queues
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Sharpen contact center platform into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Agent Retrieval
The agent list is retrieved from the API by calling listUsers – retrieving the fields:
- firstName
- lastName
- uKey
Queue Retrieval
The queue list is retrieved from the API by calling getQueues – retrieving the fields:
- queueID
- queueKey
- queueName
ShoreTel
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to ShoreTel Contact Center. The document assumes that the reader has some basic understanding of the Contact Center database layout and a working understanding of MYSQL query syntax.
CommunityWFM | AI WFM and ShoreTel Contact Center Integration
CommunityWFM | AI WFM integrates with the ShoreTel Contact Center platform using direct queries against the ShoreTel Contact Center via a .net native MYSQL provider. Tables within the database satisfy the data collection requirements to integrate the CommunityWFM | AI WFM application with the ShoreTel Contact Center for historical data. The ShoreTel Web Service interface is used to integrate Real-time agent state information.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the Contact Center database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the GRPO table and is implemented as follows:
Default contact historical query
select DATE(CCD.startDateTime)::datetime year to second + floor(CCD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (CCD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, CQD.profileID, COUNT(*) AS CallVolume from ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 AND CCD.startDateTime >= DATETIME(#StartDateTime#) year to second - 1 units hour AND CCD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId,CQD.profileID ORDER BY Slot
Default not handled historical query
select date(CCD.startDateTime)::datetime year to second + floor(CCD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (CCD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, CQD.profileID,COUNT(*) AS Abandoned FROM ContactQueueDetail CQD JOIN ContactCallDetail CCD ON CCD.sessionID = CQD.sessionID AND CCD.sessionSeqNum = CQD.sessionSeqNum AND CCD.profileID=CQD.profileID AND CCD.nodeID=CQD.nodeID JOIN ContactServiceQueue CSQ ON CSQ.recordId = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=1 AND CCD.startDateTime >= datetime(#StartDateTime#) year to second - 1 units hour AND CCD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId,CQD.profileID ORDER BY Slot
Default handling time historical query
select date(ACD.startDateTime)::datetime year to second + floor(ACD.startDateTime::datetime minute to minute::char(2)::int/15) * 15 units minute + (ACD.startDateTime::datetime hour to hour::char(2)::int units hour) as Slot, CSQ.contactServiceQueueId AS Skill, SUM(ACD.talkTime) + SUM(ACD.holdTime) + SUM(ACD.workTime) AS HandleTime FROM AgentConnectionDetail ACD JOIN ContactQueueDetail CQD ON CqD.sessionID=ACD.sessionID AND CqD.sessionSeqNum = ACD.sessionSeqNum AND CqD.profileID = ACD.profileID AND CqD.nodeID = ACD.nodeID AND CqD.qIndex = ACD.qIndex JOIN ContactServiceQueue CSQ ON CSQ.recordID = CQD.targetID WHERE CQD.targetType = 0 AND CQD.disposition=2 AND ACD.startDateTime >= datetime(#StartDateTime#) year to second - 1 units hour AND ACD.startDateTime < '#EndDateTime#' AND CSQ.contactServiceQueueId = #Skill# GROUP BY 1, CSQ.contactServiceQueueId ORDER BY Slot
Note: The historical collection service implements replacement characters for the WHERE condition (not included above). The data collection service resolves these replacement tokens when it executes the query for individual queues.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from either the JSON Web Service’s Real-time Agent Activity Feed or Real-time Group Activity feed to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) continuously monitors the feed from the Web Service and loads the results into vendor-neutral tables inside the Community product database.
ShoreTel customers are required to license the JSON Web Service in order to enable Real-Time Adherence.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the ShoreTel Contact Center database into CommunityWFM | AI WFM. Configuration data is retrieved from the database using the database credentials provided by the end user.
Queue Data Collection
SELECT DISTINCT CSQName AS Name, contactServiceQueueId AS ACDSkillId FROM ContactServiceQueue WHERE dateInactive IS NULL and active ORDER BY CSQName
Agent Information
SELECT resourcelastname AS Last_Name, resourcefirstname AS First_Name, extension AS Employee_Id FROM informix.resource WHERE Active = "t" ORDER BY Last
T-Metrics
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a T-Metrics Contact Center system. The document assumes that the reader has some basic understanding of the T-Metrics Contact Center solution and a working understanding of SQL query syntax.
CommunityWFM | AI WFM and T-Metrics Integration
CommunityWFM | AI WFM integrates with the T-Metrics platform using direct queries against the T-Metrics Contact Center via a .net native SQL provider. The T-Metrics database is stored in an Amazon instance therefore proper authentication is required. Tables within the database satisfy the data collection requirements to integrate the CommunityWFM | AI WFM application with the T-Metrics Contact Center for real-time agent state information and historical data.
Each component of data collection and the required database and tables are described below.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from the T-Metrics database to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the query every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Contact Queue Historical Collection
For queue-based data collection, the query runs against the T-Metrics database table CallsRolledTo15m (a custom table added to the T-Metrics database).
Default historical query
SELECT
Slot
, Skill
, OfferedCalls AS CallVolume
, AbandonedCalls AS Abandoned
, HandleTime, TimeEntered
FROM CallsRolledTo15m
WHERE Skill = '#Skill#' and Slot >= '#DtStart#'
ORDER BY Slot ASC, Skill ASC
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the T-Metrics Amazon database to compare against schedule intervals in order to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) queries the database at a regular interval and loads the results into vendor-neutral tables inside the CommunityWFM product database.
T-Metrics customers are required to obtain database credentials and make sure that the required tables are available for data collection.
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information directly from the T-Metrics Contact Center database into CommunityWFM | AI WFM. Configuration data is retrieved from the database using the database credentials provided by the end user.
Queue Data Collection
SELECT DISTINCT Skill AS 'Name', Skill AS 'ACDSkillId' FROM RAM_Skill ORDER BY Skill
Talkdesk
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Talkdesk. The document assumes that the reader has some basic understanding of the Talkdesk contact center platform.
CommunityWFM | AI WFM and Talkdesk Integration
CommunityWFM | AI WFM integrates with the Talkdesk platform using their REST APIs. The Talkdesk APIs being used are the User API, the Ring Groups API, and the Explore API, which uses HTTPS requests to communicate with the contact center platform. The communication to Talkdesk consists of sending in a Client Id and a Client Secret to request a token for authentication. The token retrieved is then used to retrieve all the other data required for this implementation.
All times are returned in Unix time UTC.
Each component of data collection and the required database and table are described below.
Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Talkdesk REST API to be used in contact volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
- sumHandleTime – Total handle time during the 15-minute window.
- enteredCount – Total number of calls during the 15-minute window.
- abandonedCount – Total number of abandoned calls during the 15-minute window.
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Talkdesk REST API to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id – Unique identifier for the agent
- agent-status – Agent state
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import Queue information and Agents directly from the Talkdesk system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Permissions Required
Customer/Talkdesk will be required to create a new OAuth Client for the Community adapter and provide the Client Id and Client Secret.
Grant type: Client Credentials
Scopes:
- data-reports:read
- data-reports:write
- reports:read
- reports:write
- ring-groups:read
- user:read
TCN
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to TCN. The document assumes that the reader has some basic understanding of TCN and the credentials required to connect to TCN. TCN’s REST API and TCN’s ability to FTP a file to the CommunityWFM | AI WFM server will be utilized in retrieving information from TCN.
CommunityWFM and TCN Integration
Community integrates with TCN cloud contact center solution with the TCN API and is dependent on TCN to FTP the call volume data to a directory on the CommunityWFM | AI WFM server every 15 minutes. TCN will meet data collection requirements to fully integrate the CommunityWFM | AI WFM application with the TCN platform. The adapter retrieves agent states, call volume history, agent importing and skill importing.
Customer must provide the base URL of their instance of the TCN API.
For example: https://api.tcnp3.com/backoffice/
Customer needs to create a service account user in their TCN system and provide CommunityWFM | AI WFM with an Access Token created for that user. (See attached TCN Partnership Access Token Management.)
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from TCN by reading the call volume file that TCN sends via FTP on a 15-minute interval. The Community Historical Data Collection Service (a .NET Windows service) executes the call for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
Below is the configuration information needed for setting up the historical collection from TCN.
Historical contact volume data collection
|
Historical contact volume data collection
|
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from TCN to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (TCN this interval is set to 15 minutes) and loads the results into vendor-neutral tables inside the Community product database.
Below is the required information needed to be able to receive that real-time data stream.
Real-time adherence integration
| Base URL: | |
| Access Token: | |
| Transaction Collection Interval (minutes): |
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agents directly from the TCN instance via the TCN REST API calls.
Thrio
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a Thrio system. The document assumes that the reader has some basic understanding of the Thrio contact center platform.
CommunityWFM | AI WFM and Thrio Integration
CommunityWFM | AI WFM integrates with the Thrio platform using their REST APIs written for WFM integrations. The Thrio API being used is the “CommunityWFM Integration,” which uses HTTP requests to communicate with the contact center platform. The communication to Thrio consists of sending in a username and password to request a token for authentication (provided by Thrio). The token retrieved is then used to retrieve all the other data required for this implementation. All times are returned in Unix time UTC.
Each component of data collection and the required database and table are described below.
Thrio Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Thrio REST API to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (historical) includes the following columns:
sumHandleTime – Total handle time during the 15-minute window
enteredCount – Total number of calls during the 15-minute window
abandonedCount – Total number of abandoned calls during the 15-minute window
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Thrio REST API to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id – Unique identifier for the agent
- agent-status – Agent state
- Possible states include:
- Available
- Busy
- Logged out
- Logged in
- Working
- Wrapup
- No Answer
- (Any custom states a customer creates)
- Possible states include:
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Thrio system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Twilio
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to Twilio. The document assumes that the reader has some basic understanding of Twilio and the different credentials that can be obtained from Twilio. Twilio’s TaskRouter REST API and Flex Insights API are utilized in retrieving information from Twilio.
CommunityWFM | AI WFM and Twilio Integration
CommunityWFM | AI WFM integrates with the Twilio through its programming API that allows CommunityWFM | AI WFM the ability to retrieve the real-time data required. Twilio will meet data collection requirements to fully integrate the CommunityWFM | AI WFM application with the Twilio platform. Twilio’s TaskRouter REST API and Flex Insights API are utilized in retrieving information from Twilio.
Historical Data Collection
CommunityWFM | AI WFM collects historical contact volume data from Twilio by using the Flex Insights API to download a custom report from Flex Insights. The Community Historical Data Collection Service (a .NET Windows service) executes the call for each defined data collection point every 15 minutes and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The following is the configuration information needed for setting up the historical collection from Twilio.
Historical contact volume data collection
| Account SID: | |
| Auth Token: | |
| Workspace Id: | |
| Username: | |
| Password: | |
| Project Id: | |
| Report Id: |
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from Twilio to compare against schedule intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the query on a user-defined interval (typically between 5 and 30 seconds) and loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
To retrieve data from Twilio TaskRouter REST API to retrieve Current Agent States.
The following is the required information needed to be able to receive that real-time data stream. Note: Proxy information is only necessary if a proxy server is being used, otherwise leave blank.
Real-time adherence integration
| Account SID: | |
| Auth Token: | |
| Workspace Id: |
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import agents directly from the Twilio instance via the TaskRouter REST API calls.
Zoom
The objective of this document is to outline the method and details of the CommunityWFM | AI WFM integration to a Zoom system. The document assumes that the reader has some basic understanding of the Zoom contact center platform.
CommunityWFM | AI WFM and Zoom Integration
CommunityWFM | AI WFM integrates with the Zoom platform using the Zoom Contact Center API.
The Zoom Contact Center API makes HTTP requests to communicate with the contact center platform. The communication to Zoom consists of sending in an account ID, client ID, and client secret to request a token for authentication (provided by Zoom). The token retrieved is then used to retrieve all the other data required for this implementation.
All times are returned in Unix time UTC.
Each component of data collection and the required database and table are described below.
Zoom Configuration Page
Historical Data Collection
CommunityWFM | AI WFM collects call volume data from the Zoom Contact Center API to be used in volume and handle time reports and for future forecasting. The Community Historical Data Collection Service (a .NET Windows service) executes the request every 15 minutes and loads the results into vendor-neutral tables inside the Community product database.
The data retrieved from this call (historical) includes the following columns:
sumHandleTime – Total handle time during the 15-minute window
enteredCount – Total number of call during the 15-minute window
abandonedCount – Total number of abandoned calls during the 15-minute window`
Agent State Transaction Data Collection
CommunityWFM | AI WFM collects agent state transactions from the Zoom Contact Center API to compare against scheduled intervals to provide agent schedule adherence reporting. The Community Adherence Collection Service (a .NET Windows service) executes the request based upon the interval time configured in the UI. The adapter then loads the results into vendor-neutral tables inside the CommunityWFM | AI WFM product database.
The data retrieved from this call (realTime) includes the following columns:
- agent-id – Unique identifier for the agent
- agent-status – Agent state
- Possible states include:
- Offline
- Ready
- Not Ready
- Occupied
- Any custom states a customer creates.
- Possible states include:
Importing Configuration Data
CommunityWFM | AI WFM supports the ability to import queue information and agents directly from the Zoom system into CommunityWFM | AI WFM. Configuration data is retrieved by making RESTful API calls to pull back the data.
Configuring Zoom to get Account ID, Client ID, and Client Secret
To create the required credentials to be provided to CommunityWFM | AI WFM:
- Have an administrator of the Zoom system login into https://zoom.us.
- Under the Admin section, choose Advanced then choose App Marketplace.
- In the App Marketplace Develop dropdown menu choose Build App.
- Find the app type Server-to-Server OAuth and click Create.
- Give your app a name (e.g.,“CommunityWFM”) then click Create.
- Copy and save the Account ID, Client ID, and Client Secret, then click Continue.
- Add a Short Description, Company Name, Developer Name and Email address, then click Continue.
- On the Add Feature page, click Continue.
- On the Add Scopes page, select Contact Center and check the box for each scope.
- Choose the following scopes (there are two pages):
- After making the selections click Continue.
- Click Activate your app.
- Use the credentials you gathered in the adapter setup page to finish.