Welcome to Data Connector API documentation!¶

Data Connector¶

There are 2 essential properties you must code for in your Data Connector implementation. These are: Date Range and Limit. Their respective importance are explained below:

Integration Tool¶

Our Integration Tool is accessible via our developer portal. It is not OSS and it cannot be installed locally [within your infrastructure]. The first task you’ll be invited to perform it to confirm connectivity to your hosted Data Connector - Test your Connector. You must enable a public facing IP address and port for the Integration Tool to be able to reach your Data Connector end-point. You will not be able to progress through the Integration Tool until it has confirmed connectivity with the Data Connector. Please note, this does not mean that you must have completed the development work at this point in time.

There are 1 of several outbound IP addresses the Integration Tool can use to communicate through so please add this list to your firewall:

• 23.100.53.139
• 23.100.53.152
• 23.100.53.156
• 23.100.58.69

If for security reasons you are unable to enable an IP and port then we suggest you deploy the Data Connector and your own Recorder repository to a cloud provider VM such as offer up by Azure or AWS.

Coach server environment¶

To help you quickly and without any effort configure your server, we have prepared a Chef script for your convenience. You will need to install Chef client version 12.2.1 first - https://downloads.chef.io/chef-client/windows/. You can find this here - Server deployment.

Prior to integration¶

• [✔] Watched all the videos for solid understanding of what’s involved
• [✔] Read the Checklist section
• [✔] Read the Checklist section
• [✔] Subscribed to the Coach Service Desk
• [✔] Obtained public facing IP address for the Integration Tool to test your Data Connector
• [✔] Added port of Data Connector RESTful API before to firewall
• [✔] Added this IP range (23.100.53.139,23.100.53.152,23.100.53.156,23.100.58.69) to your firewall so Integration Tool can reach your Data Connector

Server configuration¶

• [✔] Installed Chef Client 12.2.1.
• [✔] Run Chef script on server to configure your server prior to Coach install

Coding¶

• [✔] Downloaded Data Connector RESTful API from github
• [✔] Downloaded QA Data Connector from github to look at sample implementation
• [✔] Implemented Data range in both GetMediaForUserAsync and GetMediaForUsersAsync so results are filtered on a period
• [✔] Incorporated the Limit property in and MediaForUserArgs and MediaForUsersArgs so as to not return potentially millions of rows of data
• [✔] Received Email with link back to recorder configuration
• [✔] Clicked on link included in Email and returned to recorder configuration
• [✔] Tested users import in Integration Tool
• [✔] Tested search criteria in Integration Tool

Post-coding¶

• [✔] Completed Integration Tool and have received T-SQL script file Email attachment
• [✔] Installed Coach

Support¶

• [✔] Received training on Coach

BaseController¶

All controllers inherit from this base Controller.

Namespace:

Qualtrak.Coach.DataConnector.Controllers

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

public class BaseApiController : ApiController
{
    private const string TenantCodeHeaderKey = "TenantCode";
    private const string UsernameHeaderKey = "Username";
    private const string PasswordHeaderKey = "Password";

    protected DataConnectorProperties GetDataConnectorProperties()
    {
        var result = new DataConnectorProperties();
        result.TenantCode = this.GetValueFromHeaderKey(TenantCodeHeaderKey);
        result.Username = this.GetValueFromHeaderKey(UsernameHeaderKey);
        result.Password = this.GetValueFromHeaderKey(PasswordHeaderKey);
        return result;
    }

    private string GetValueFromHeaderKey(string key)
    {
        if (this.Request.Headers.Contains(key))
        {
            return this.Request.Headers.GetValues(key).First();
        }

        return null;
    }
}

Connector¶

Qualtrak.Coach.DataConnector.Controllers

GET api/connector

1
2
3
4

public bool Get()
{
    return true;
}

RecorderUsers¶

Qualtrak.Coach.DataConnector.Controllers.Recorder

GET api/recorder/users

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

 [DeflateCompression]
 [Route("recorder/users")]
 public async Task<IEnumerable<RecorderUser>> GetAsync()
 {
    var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();

    try
    {
        return await client.GetUsersAsync(this.GetDataConnectorProperties());
    }
    catch (Exception ex)
    {
        Trace.TraceError("connector : [{0}]", ex.Message);
    }

    return await Task.FromResult(new List<RecorderUser>());
 }

RecorderMedia¶

Qualtrak.Coach.DataConnector.Controllers.Recorder

GET api/recorder/media?id=123abc&originalUrl=http://calls.recorder.com/recording.aspx?id=123abc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

[Route("recorder/media")]
[HttpGet]
public async Task<string> GetAsync(string id, string originalUrl)
{
    var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();
    string result = string.Empty;

    try
    {
        result = await client.GetMediaUrlAsync(id, originalUrl, this.GetDataConnectorProperties());
    }
    catch (Exception ex)
    {
        Trace.TraceError("connector : [{0}]", ex.Message);
    }

    return result;
}

Qualtrak.Coach.DataConnector.Controllers.Recorder

POST api/recorder/media/{userId}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

 [DeflateCompression]
 [Route("recorder/media/{userId}")]
 [HttpPost]
 public async Task<IEnumerable<Media>> PostAsync(string userId, MediaForUserArgs args)
 {
   var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();
   try
   {
       return await client.GetMediaForUserAsync(userId, args, this.GetDataConnectorProperties());
   }
   catch (Exception ex)
   {
       Trace.TraceError("connector : [{0}]", ex.Message);
   }

   return await Task.FromResult(new List<Media>());
 }

Qualtrak.Coach.DataConnector.Controllers.Recorder

POST api/recorder/media

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

 [DeflateCompression]
 [Route("recorder/media")]
 [HttpPost]
 public async Task<IEnumerable<MediaUser>> PostAsync(MediaForUsersArgs args)
 {
   var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();
   try
   {
       return await client.GetMediaForUsersAsync(args, this.GetDataConnectorProperties());
   }
   catch (Exception ex)
   {
       Trace.TraceError("connector : [{0}]", ex.Message);
   }

   return await Task.FromResult(new List<MediaUser>());
 }

Qualtrak.Coach.DataConnector.Controllers.Recorder

POST api/recorder/media/full

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

  [DeflateCompression]
  [Route("recorder/media/full")]
  [HttpPost]
  public async Task<IEnumerable<Media>> PostAsync(MediaByIds args)
  {
       var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();
       try
       {
           var response = await client.GetMediaByIdsAsync(args.ids, this.GetDataConnectorProperties());
           return response;
       }
       catch (Exception ex)
       {
           Trace.TraceError("connector : [{0}]", ex.Message);
       }

       return await Task.FromResult(new List<Media>());
  }

Score¶

Qualtrak.Coach.DataConnector.Controllers.Recorder

POST api/recorder/evaluationscore

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

  [Route("recorder/evaluationscore")]
  public async Task PostAsync(SendEvaluationScoreArgs args)
  {
      var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();

      try
      {
         await client.SendEvaluationScoreAsync(args, this.GetDataConnectorProperties());
      }
      catch (Exception ex)
      {
          Trace.TraceError("connector : [{0}]", ex.Message);
      }
  }

Stream¶

Qualtrak.Coach.DataConnector.Controllers.Recorder

GET api/recorder/stream

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

 [Route("recorder/stream")]
 public async Task<HttpResponseMessage> GetAsync(string url)
 {
   var client = NinjectWebCommon.Kernel.Get<IRecorderApiFacade>();
   try
   {
       var stream = await client.GetStreamAsync(url);
       bool match = false;

       var output = this.Request.CreateResponse(HttpStatusCode.OK);
       output.Content = new StreamContent(stream);
       output.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");

       foreach (var item in this._listOfMediaFileTypes)
       {
           if (url.Contains(item.Ext))
           {
               output.Content.Headers.ContentType = new MediaTypeHeaderValue(item.MimeType);
               output.Content.Headers.ContentDisposition.FileName = "recording" + item.Ext;
               match = true;
               break;
           }
       }

       if (!match)
       {
           output.Content.Headers.ContentType = new MediaTypeHeaderValue("audio/x-wav");
           output.Content.Headers.ContentDisposition.FileName = "recording.wav";
       }

       return output;
   }
   catch (Exception ex)
   {
       Trace.TraceError("connector : [{0}]", ex.Message);
   }

   return new HttpResponseMessage(HttpStatusCode.NotFound);
 }

RecorderUser¶

Describes a Recorder User.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

 [DataContract()]
 public class RecorderUser
 {
     [DataMember]
     public string AccountId { get; set; }

     [DataMember]
     public string FirstName { get; set; }

     //The Automatic Call Distributor ID uniquely identifies an agent with a device; device being the equipment the call is directed to.  This ID identifies this user
     [DataMember]
     public string LastName { get; set; }

     //This is the unique identifier of a user account within the recorder
     [DataMember]
     public string Mail { get; set; }

     //This is the password of the user’s account.
     [DataMember]
     public string Password { get; set; }

     [DataMember]
     public string UserId { get; set; }

     [DataMember]
     public string Username { get; set; }
 }

Media¶

Used to describe a recording from a Recorder.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

 [DataContract]
 public class Media
 {
     [DataMember]
     public string Id { get; set; }

     [DataMember]
     public string FileName { get; set; }

     //The name of the file that uniquely identifies the recording
     [DataMember]
     public string RecorderUserId { get; set; }

     [DataMember]
     public DateTime? Date { get; set; }

     [DataMember]
     public string Metadata { get; set; }
 }

MediaForUserArgs¶

Used to describe a filter to be applied by the Recorder when requests recordings.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder.Args

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

 [DataContract]
 public class MediaForUserArgs
 {
     [DataMember]
     public int Limit { get; set; }

     [DataMember]
     public List<SearchCriteria> SearchCriteria { get; set; }

     [DataMember]
     public string TimeZone { get; set; }
 }

MediaUser¶

Used to describe the relationship between a recording and a recorder user.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

 [DataContract]
 [Serializable]
 public class MediaUser
 {
     //The code that uniquely identifies the recording, this could be a compound key
     [DataMember(Name = "id")]
     public string MediaId { get; set; }

     [DataMember(Name = "userId")]
     public string RecorderUserId { get; set; }
 }

MediaForUsersArgs¶

Used to describe the search filter to be applied by the Recorder for recordings from a list of users.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder.Args

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

 [DataContract]
 public class MediaForUsersArgs
 {
     [DataMember]
     public int Limit { get; set; }

     [DataMember]
     public List<SearchCriteria> SearchCriteria { get; set; }

     [DataMember]
     public string TimeZone { get; set; }

     [DataMember]
     public IEnumerable<string> UserIds { get; set; }
 }

MediaByIds¶

Used to contain a list of recording Ids for the Recorder to process.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder.Args

c# code:

1
2
3
4
5
6

 [DataContract]
 public class MediaByIds
 {
     [DataMember]
     public IEnumerable<string> ids { get; set; }
 }

SearchCriteria¶

Used to describe one search filter.

Namespace:

Qualtrak.Coach.DataConnector.Core.Shared

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

 [DataContract]
 public class SearchCriteria
 {
     DataMember]
     public string Id { get; set; }

     [DataMember(Name = "key")]
     public string Key { get; set; }

     [DataMember(Name = "label")]
     public string Label { get; set; }

     [DataMember(Name = "value")]
     public string Value { get; set; }

     [DataMember(Name = "condition")]
     public SearchCondition Condition { get; set; }

     [DataMember(Name = "dataType")]
     public System.TypeCode DataType { get; set; }
 }

Notes:

Dependency on:

SearchCondition

Enum of all possible conditions.

SendEvaluationScoreArgs¶

Contains the Headline Score of an Evaluation that is to be persisted by the Recorder.

Namespace:

Qualtrak.Coach.DataConnector.Core.Recorder.Args

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

 [DataContract]
 [Serializable]
 public class DataConnectorEvaluationScore : IDataConnectorEvaluationScore
 {
     [DataMember]
     public string EvaluationId { get; set; }

     [DataMember]
     public string ExtraScore { get; set; }

     [DataMember]
     public string HeadlineScore { get; set; }

     [DataMember]
     public string MediaId { get; set; }

     [DataMember]
     public string UserId { get; set; }
 }

DataConnectorProperties¶

Describes the user credentials required for an authentication challenge by the Recorder.

Namespace:

Qualtrak.Coach.DataConnector.Core.Shared

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

 [DataContract]
 [Serializable]
 public class DataConnectorProperties : IDataConnectorEvaluationScore
 {
     [DataMember]
     public string Password { get; set; }

     [DataMember]
     public string TenantCode { get; set; }

     [DataMember]
     public string Username { get; set; }
 }

SearchCondition¶

Namespace:

Qualtrak.Coach.DataConnector.Core.Enums

c# code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

 public enum SearchCondition
 {
     GreaterThan = 0,
     GreaterThanEqual = 1,
     LessThan = 2,
     LessThanEqual = 3,
     Equal = 4,
     NotEqual = 5,
     Any = 6,
     NotContains = 7,
     Contains = 8,
     StartsWith = 9,
     EndsWith = 10
 }

Chef¶

The following is a chef script. Its purpose is to help you quickly preconfigure the server where Coach will be deployed:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

# Cookbook Name:: coach_chef_web
# Recipe:: default
#
# Copyright (c) 2015 Qualtrak Solutions Ltd, All Rights Reserved.
powershell_script 'Install IIS' do
  code 'Add-WindowsFeature Web-Server'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name Web-Server).Installed"
end

powershell_script 'Install NET-Framework-45-Core' do
  code 'Add-WindowsFeature NET-Framework-45-Core'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name NET-Framework-45-Core).Installed"
end

powershell_script 'Install Web-Asp-Net45' do
  code 'Add-WindowsFeature Web-Asp-Net45'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name Web-Asp-Net45).Installed"
end

powershell_script 'Install Web-WebSockets' do
  code 'Add-WindowsFeature Web-WebSockets'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name Web-WebSockets).Installed"
end

powershell_script 'Install NET-WCF-HTTP-Activation45' do
  code 'Add-WindowsFeature NET-WCF-HTTP-Activation45'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name NET-WCF-HTTP-Activation45).Installed"
end

powershell_script 'Install Windows Auth' do
  code 'Add-WindowsFeature Web-Windows-Auth'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name Web-Windows-Auth).Installed"
end

powershell_script 'Install IIS Mgmt Console' do
  code 'Add-WindowsFeature Web-Mgmt-Console'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name Web-Mgmt-Console).Installed"
end

powershell_script 'Install IIS Mgmt Service' do
  code 'Add-WindowsFeature Web-Mgmt-Service'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name  Web-Mgmt-Service).Installed"
end

powershell_script 'Install IIS Application Initialization' do
  code 'Add-WindowsFeature Web-AppInit'
  guard_interpreter :powershell_script
  not_if "(Get-WindowsFeature -Name  Web-AppInit).Installed"
end

service 'w3svc' do
    action [:enable, :start]
end

Cut & paste the above code into a file called setup.rb. Open a command console as Administrator and enter:

1

c:\chef-apply setup.rb

This will now install all the server features required to host Coach on this server.

1.0.1 (2016-04-11)¶

• Added a Checklist page (found under the Important section) to help remind Integration Engineers on the important / key stages & actions required during the integration
• Added list of outbound IP addresses the Integration Tool uses to communicate through.
• Added a new Before you start page (found under the Important section) to focus on key payload properties that you as a Integration Engineer must implement during the integration development

1.0.0 (2015-11-16)¶

• Official 1.0 release
• Included extra content based on feedback from partners

0.1.0 (2015-08-17)¶

• Initial release as an OSS project with Coach 6.0

Who we are¶

Qualtrak was initially founded in 1998 as Europe’s first specialist consulting business helping contact centers of all sizes to implement an effective Quality Monitoring and Coaching program or to renew their quality program.

What we do¶

Working with clients of all sizes, and using all of the major QM products, provided us with valuable lessons in what makes an effective QM/coaching solution.

Qualtrak is the only vendor to supply a ‘white-labelled’ high standard Agent Evaluation and Online Learning solution to OEM call recording vendors (on-prem and cloud), cloud based contact center Service Providers and OEM contact center vendors (on-prem and cloud). Qualtrak’s Coach can be integrated with any call recorder (API required) using Qualtrak’s SDK.

You can find more information by clicking here.