2021-12-07

Emergency Messages in Amazon Connect (part 3)

In part 2 of this article, I demonstrated how to create Admin IVR to be able to enable/disable emergency messages using the phone menu.

Right now our Admin IVR has no protection so anyone can dial it and fiddle with emergency messages.

There are multiple options on how to add security to our IVR menu such as:

1) Option 1 - easiest option would be to add a numeric password that will be hardcoded directly in Admin IVR. You ask users to enter the password first and if it is correct proceed with normal Admin IVR behavior.

This option is OK if you have a small number of users (ideally 1 user only).

2) Option 2 - create a user table that contains an individual numeric password for each user. 

Optionally you can add phone numbers to user table and limit access for each user only if they dialed from a specific phone number (for example corporate cell phone number).

3) Option 3 - use VoiceID to add authentication by voice.

In this article, I would like to show how to use DynamoDB table to add authentication to Admin IVR - option 2.


Step 1.

I created DynamoDB table EmergencyMessagesAdmin with the following attributes:
  • PIN   - unique PIN code assigned to each user
  • FirstName  
  • LastName



Step 2.

Next step we will need a new Lambda function checkEmergencyMessagesAdmin to verify if the PIN code matches.

What it does:

  • takes PIN codes as input and verifies if there such PIN code in EmergencyMessagesAdmin
  • if yes returns Valid = 1
You can download source code from my GitHub:

https://github.com/contactcenterdude/amazon-connect/blob/main/EmergencyMessages/checkEmergencyMessagesAdmin.py

Step 3.

Now let's update the existing flow EmergencyMessagesAdmin.


Right at the beginning of the flow, we will ask user to enter PIN-code and then use our lambda function checkEmergencyMessagesAdmin to verify if it is a valid user.


If it is a valid user -> we will offer a standard IVR Admin menu.



You can download source code from my GitHub:

Emergency Messages in Amazon Connect (part 2)

 In this article, I would like to continue talking about Emergency Messages in Amazon Connect.

In part1 I explained how to add Emergency Messages in your existing IVR. Now I would like to talk about how to disable/enable them using Admin IVR.

As described in part1 we already have DynamoDB table EmergencyMessages that contains information about our Emergency Messages. 

So what options do we have to update this table?

1) Option1  - connect to DynamoDB and change values directly in the table. This option is situable for system administrators, regular users would not have access to the table.

2) Option 2 - create a web interface that would allow us to manage Emergency Messages. This is probably the most user-friendly option but it requires web development.

3) Option 3 - create Admin IVR that allows to Enable/Disable emergency messages. 

I would like to give you an example of how to implement Option 3.


Step 1.

I created Lambda function using Python 3.9 which is called UpdateEmergencyMessage.

It takes 2 input parameters:

  • MessageID  -  ID of Emergency Message
  • Status  - current status of the message
After that, it changes the status of the emergency message from the current one to the opposite (Enabled to Disabled, Disabled to Enabled) and updates DynamoDB EmergencyMessages table

You can download source code from my GitHub:

https://github.com/contactcenterdude/amazon-connect/blob/main/EmergencyMessages/UpdateEmergencyMessage.py


Step 2.

Now we will create a new IVR flow EmergencyMessagesAdmin.

How it works:

1) At first we will ask a user to enter ID of the Emergency Message.

2) After that we will use the existing lambda function CheckEmergencyMessage to check the current status of this message

3) We will play back the user current status of the message

4) After that I offer the user 2 options

  • Press 1 - to change the status of the message
  • Press 2 - to play text of the message (might be helpful to verify if you are actually changing the right thing)
5) If the user pressed 1 - I will call Lambda function UpdateEmergencyMessage to change the status of the message.

6) After that I will call again lambda function CheckEmergencyMessage to verify the new status of the message and playback to user new status



You can download the flow from my GitHub:

https://github.com/contactcenterdude/amazon-connect/blob/main/EmergencyMessages/EmergencyMessagesAdmin_flow.json

Step 3.

Now you just need to assign a phone number to Admin IVR flow.

****************


Ok. Admin IVR is now ready but something seems to be still missing.

Well, right now anyone can dial this Admin IVR and disable/enable emergency messages. There is almost no protection. Stay tuned for part 3 of this article where I would discuss options of adding a security layer to Admin IVR.

 

2021-12-06

Emergency Messages in Amazon Connect (part 1)

In this article, I would like to demonstrate how to add Emergency Messages in Amazon Connect.

Let's say you have an IVR and would like to be able to enable/disable certain messages or certain treatment without changing the whole IVR.

Usually, this is required in case of emergency situations or under some special circumstances.
Emergency Messages can also be called Special Messages.   

I will split this article into 3 parts:
  • Part 1 - how to add emergency messages to IVR menu
  • Part 2 - how to enable/disable emergency messages using Admin IVR
  • Part 3 - adding security to Admin IVR

Also very recently Amazon added new functionality to Amazon Connect - now you can create reusable call flows that are called Modules. In my example below I will use modules because it allows me to reuse the same module multiple times, makes my call flow much cleaner, and is easier to read.

You can learn more about modules in the official Amazon Connect documentation

Another thing that I would like to point out - in my example I use text to speech for emergency messages.
This seems to be straightforward, but If your emergency message is pre-recorded prompt you can still easily do it, just by adding prompt name as one of the attributes in DynamoDB table (step 1) and some extra logic in the module (step 3).

Step 1.

First, we need to create DynamoDB table EmergencyMessages that will be used to store Emergency Messages configuration and would allow to control what should happen after we played Emergency Message.

Here is a list of attributes:

  • id       - unique id of emergency messages. In my case, I use 4-digit long numbers
  • Enabled -  true / false   - status of Emergency Message
  • Description - description field for each emergency message
  • Text -  Actual text of an emergency message that will be played to the client
  • Action - what to do with the call after we played Emergency Message (see table below)
  • ActionTarget - additional property of action (see table below)

Possible values for Action and corresponding ActionTarget:
Action ActionTarget Comment
<EMPTY> <EMPTY> Do nothing. Just play Emergency Message and continue IVR flow as usual
DISCONNECT <EMPTY> Disconnect the call after the message
CALLBACK <QUEUE name> After the message create callback request for <QUEUE name>
TRANSFER_NUMBER <phone number> After the message transfer call to <phone number>
TRANSFER_QUEUE <QUEUE name> After the message transfer call to <Queue name>


Step 2.

Next step - I created Lambda function CheckEmergencyMessage using Python 3.9 that checks the status of Emergency Message and returns all attributes.

Input:
  • MessageID - id of the message
Output:
  • Enabled
  • Text
  • Action
  • ActionTarget


Source code of my lambda function you can see on my GitHub:


Step 3.

Now we will create a module CheckEmergencyMessage. As I previously mentioned modules are the new way to create reusable call flows.

What it does
  1. Invokes Lambda function CheckEmergencyMessage
  2. Checks if an emergency message is Enabled. 
    1. If it is not enabled - exits module
    2. If it is Enabled - plays text using text-to-speech
      • After that uses values of Action and ActionTarget to decide what to do with the call


You can download the source code of this module from my Github.

Step 4.

The last step is to create a demo flow that actually uses Emergency Messages.

What it does:

1. First I play a welcome message, something like "Welcome to customer support"

2. I assign the value of emergency message to attribute MessageID using Set Contact Attributes block

In this example MessageID = 2001

3. After that I invoke module CheckEmergencyMessage that actually checks if this emergency message is Enabled and plays it back to the customer and performs the required Action.


You can download the source code of this module from my GitHub:

https://github.com/contactcenterdude/amazon-connect/blob/main/EmergencyMessages/EmergencyMessagesDemo_flow.json


******

I would like to add that by adding the ability to create modules  Amazon Connect made it much easier to develop solutions like this one. Before that, I would have to add a whole bunch of blocks right directly in the main IVR flow. Now I can just 2 blocks at any place of my IVR to add additional Emergency Messages.

2021-11-20

Post Call Surveys in Amazon Connect

 One of the features of Contact centers is the ability to offer a client Post Call Survey.

In your Post Call Survey, you can ask the client to rate the quality of service or any other related questions.

It can be done in multiple ways - by sending client email form right after the call, by sending an SMS, or by asking the client to stay on the line after the agent disconnects and answer questions in the IVR. In this article, I would like to demonstrate how to build IVR Post Call Survey that is automatically triggered by the system once the agent disconnects from the call.

Step 1.

Create DynamoDB table that we will use to save results of Post Call Survey

Table name - PostCallSurveys

Columns:

  • ContactId  - unique ID of the call
  • answer  -  client's answer to post call survey
  • datetime - timestamp
  • phoneNumber - caller number (CLID) of the client


Step 2.

Now we will create Lambda function using Python 3.9 that is called savePostCallSurvey.

What it does:

1) Takes following attributes from the call

  • ContactId
  • Caller Number (CLID)
  • Client's answer to Survey
2) Saves this information to DynamoDB table PostCallSurveys

Here is the full text of my Lambda function:

import boto3
from botocore.exceptions import ClientError
from datetime import datetime

def lambda_handler(event, context):


    print(event)
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('PostCallSurveys')
    
    ContactId=event['Details']['ContactData']['ContactId']
    CLID=event['Details']['ContactData']['CustomerEndpoint']['Address']
    
    current_date =datetime.now()
    curren_date_string=current_date.strftime("%Y-%m-%d %H:%M:%S")
    
    answer=event['Details']['ContactData']['Attributes']['answer']
    
    try:
        response = table.put_item(
           Item={
                'ContactId':ContactId,
                'phoneNumber': CLID,
                'datetime': curren_date_string,
                'answer': answer
            }
        )
        
        return response

    
            
    except ClientError as e:
        print(e.response['Error']['Message'])
    

You can also download it from my GitHub:


Step 3.

Next,  we will create a call flow that will be used to offer the client Post call survey.

You can download it from my GitHub:



How it works:

1) First we will use Store Customer input block to play "Please rate the quality of our service from 1 to 5" and capture user input.


2) After that we will save result to user defined attributed called "answer".

3) Now we will invoke our lambda function savePostCallSurvey to save results to the database.

Step 4.

The last step will be -  activate our Post Call Survey flow so that it will be automatically offered to the client when the agent disconnects.

In order to do that in our main IVR flow, we need to add Set disconnect flow action that will be called before we transfer call to the queue. 

Set disconnect flow allows to specify a flow that will be executed when the agent disconnect from the call.

In the Set disconnect flow we will select our Post Call Survey flow that we previously created in Step 3.


You can download it from my GitHub:
https://github.com/contactcenterdude/amazon-connect/blob/main/PostCallSurveys/MainFlow_flow.json

BONUS:

As I mentioned at the very beginning of this article Post Call survey can be also offered by sending an email.
It can be achieved by creating another flow that sends an email to a client. The same way we triggered IVR Post Call Survey by using Set disconnect flow we can also trigger flow that sends email.

2021-09-24

How to initiate task from IVR in Amazon Connect

UPDATE from 2021/11/20:

Amazon Connect now allows creating tasks from Contact Flow using a new contact block.

It means that you do not need to use Lambda functions to do that.

The New Create task block is quite intuitive. Now you can also specify if you want to create a task right away or schedule task creation in the future. 

More documentation is available here:

https://docs.aws.amazon.com/connect/latest/adminguide/create-task-block.html

Lambda function that is mentioned below could be still useful if you want to trigger task creation, not from IVR. But for example from another Amazon AWS service.


*********************

Not long time ago Amazon introduced a new type of contacts available in Amazon Connect -  tasks.

In my article, I will show you an example of how to initiate a task from IVR.

How it could be useful?

For example, a client calls your IVR and requests a certain type of service that cannot be fully automated. In that case, you might profit from the ability to automatically create a task that will be then sent to an agent for processing.

Here is a sample scenario:

1) Client calls an IVR of  home internet provider company

2) IVR asks the client to enter the account number for identification

3) After that you ask the client what he wants to do with his current contract

  • option 1- upgrade
  • option 2 - renewal
  • option 3 - cancellation
4) For example client selects renewal 

5) Now we will initiate a task that will be sent to a queue that is responsible for contract renewals.

6) When an agent receives the task he would be able to see: account number, request type, and phone number of the person. 

Here is how it can be done in Amazon Connect:



Step 1.

The first step is to create a simple contact flow that will be used to send tasks to the required queue.


 What it does:
* Set working queue - to define Queue that will be used to receive tasks
* Transfer to queue - to send a task to the queue

Once you created the contact flow click on "Show additional flow information". You will see a long string of Contact Flow ARN. You need to copy the last 36 characters of it starting after contact-flow/. This is your ContactFlowId. You will need it in the next step.


Step 2.

I created Lambda function using Python 3.9 which is called initiateTask.

What it does:

1) Collects the following attributes from the call
* account number
* request type
* caller number
* InstanceARN - it is required to be able to get InstanceID, it is required to initiate task using Amazon Connect API

2) Using Amazon Connect API I initiate a task.

Important: you need to specify Contact Flow Id that will be used to send tasks to the queue.
This is Contact Flow that was created in the previous step.

3) You can also specify the URL that will be displayed in your task description.
It could be link to your CRM system or any other website.

Here is the full text of my Lambda function:

import json
import boto3


def lambda_handler(event, context):
    
    accountNumber=event['Details']['ContactData']['Attributes']['accountNumber']
    requestType=event['Details']['ContactData']['Attributes']['requestType']
    CLID=event['Details']['ContactData']['CustomerEndpoint']['Address']
    InstanceARN=event['Details']['ContactData']['InstanceARN']
    InstanceId = InstanceARN[-36:]

    client = boto3.client('connect')
    
    Name=requestType.upper()
    URL="https://www.your-internet-on-demand.com/?accountNumber="+accountNumber
    Description="Request type ="+requestType+". AccountNumber="+ accountNumber+". Caller number="+CLID
    
    
    response = client.start_task_contact(
        InstanceId=InstanceId,
        ContactFlowId='5b67729d-21e7-4d3c-8a28-c96f881aa1a1',
        Name=Name,
        References={
            'URL': {
                'Value': URL,
                'Type': 'URL'
            }
        },
        Description=Description
    )
    
    # TODO implement
    return {
        'statusCode': 200,
        'body': json.dumps('OK')
    }


Step 3.

Now I will create another Contact flow that initiates the task.





This is how it works

1) Client calls the contact center

2) In the IVR I play the following message 
"Hello. Welcome to Internet on Demand. 
Please enter your 5-digit account number."

3) Client enters an account number

4) I save this information as User Defined attribute accountNumber


5) Now I play another message to the client

"How can we help you?
To request an upgrade press 1. 
To request a renewal without upgrade press 2. 
To cancel account press 3"

6) Depending on what the client selects I save the choice in User-defined attribute requestType

Example: when the client selects option 1 - upgrade


7) After that I invoke my Lambda function

8) At the end I play the following message
"Thank you. Your request was sent for processing. You can expect results in 24 hours."



Step 4.

Here is what the agent will see when the task arrives




2021-09-22

How to send Email from IVR in Amazon Connect

 In my previous article, I gave an example of how to send SMS from IVR in Amazon Connect.

This time I will demonstrate how to send an email.

Why someone might need this feature? For example, you can send instructions to contact center clients when they select a certain option in IVR menu.

The process is similar to sending SMS:

1) Client calls IVR and selects an option to receive information by Email

2) After that you have to identify the client in your database. In my example, I identify client simply by caller number, but in your case, you can ask client to enter  client id.

3) Also database has to identify the email address associated with the client.

4) Once the client is identified and we know the email address we can send an email using Amazon Simple Email Service (SES). Alternatively, you can send an email using Amazon Pinpoint. In my example I use SES.

Here is the full process:

Step 1.

Create DynamoDB table Clients that contains information for each client, including phone number and email address.

Phone number must be in E.164 format.


Step 2.

In order to be able to send emails using Amazon SES you need to add an Email Address to it that you will use as Mail From.

In my next step MailFrom variable contains an email address that I already added to Amazon SES.

Step 3.

I created Lambda function using Python 3.9 which is called sendSMS. 

What it does:

1) gets contact attribute with caller number

2) does query in Clients table and returns Email address of the person

3) If the client is identified and we have his email address we can now send an email message using Amazon SES

Here is the full text of Lambda function:

import json
import boto3
from botocore.exceptions import ClientError
from boto3.dynamodb.conditions import Key

def lambda_handler(event, context):
    
    
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('Clients')
    
    CLID=event['Details']['ContactData']['CustomerEndpoint']['Address']
   
    
    response = table.query(
        KeyConditionExpression=Key('phoneNumber').eq(CLID)
        )
    resp=response['Items']
    
    for item in resp:
            Email=item['Email']
    

    MailFrom = "support@yourcompany.com"
    MailTo = Email
    MailSubject = "New application instructions"
    
    # Non-HTML Body
    MailBody = ("New application instructions\r\n"
                 "Access following link to get installation instructions http://tinyurl.com/AmazonConnectSMS"             
                )
                
    # HTML Body
    MailBodyHTML = """<html>
    <head></head>
    <body>
      <h1>New application instrunctions</h1>
      <p>Access following link to get installation instructions
        <a href='http://tinyurl.com/AmazonConnectSMS'>New application</a>
        </p>
    </body>
    </html>
    """            
    
 
    client = boto3.client('ses',region_name="us-east-1")

    # Sending email
    try:
        #Provide the contents of the email.
        response = client.send_email(
            Destination={
                'ToAddresses': [
                    MailTo,
                ],
            },
            Message={
                'Body': {
                    'Html': {
                        'Charset': "UTF-8",
                        'Data': MailBodyHTML,
                    },
                    'Text': {
                        'Charset': "UTF-8",
                        'Data': MailBody,
                    },
                },
                'Subject': {
                    'Charset': "UTF-8",
                    'Data': MailSubject,
                },
            },
            Source=MailFrom,
        )
 
    except ClientError as e:
        print(e.response['Error']['Message'])
    else:
        print("Email sent! Message ID:"),
        print(response['MessageId'])
        return {
            'statusCode': 200,
            'body': json.dumps('OK')
        }


Step 4.

Here is my sample call flow that sends email.

In the IVR I ask clients:

"Hello. Thank you for calling IT Helpdesk.
Please press 1 to receive an email with instructions on how to setup a new application."

if the client pressed 1 I invoke my Lambda function sendEmail.






2021-09-18

How to send SMS from IVR in Amazon Connect

One great thing about AWS is how easy it is to integrate different services. Here is one of the examples.

Let's say you want to build the following solution:

  • Clients are calling your contact center and when they press a certain option in the IVR you want to send them an SMS message. What this message contains depends on your requirements. In my case, I send an SMS with a link to instructions on how to install a new mobile application.
  • Before sending the message you want to verify if this is a valid client and not just a random person.

You can do that by integrating Amazon Connect with Amazon Simple Notification Service (SNS).

Here is how to do that:

Step 1.

I created DynamoDB table called Clients.

It contains phone numbers for each client and some other information about each client.

Phone numbers must be in E.164 format.


Step 2.

I created Lambda function sendSMS. I use Python 3.9

How it works:

1. I get the contact attribute Customer number to get the phone number of the caller.

2. I run a query and check if this phone number is in Clients tables.

3. If it is found - it means it is a valid client

4. After that I connect to SNS and use action publish to send SMS.


In my example message is hardcoded in my Lambda function but depending on your particular requirements you can make it dynamic.


Here is my Lambda function:

import json
import boto3
from botocore.exceptions import ClientError
from boto3.dynamodb.conditions import Key

def lambda_handler(event, context):
    
    dynamodb = boto3.resource('dynamodb')
    table = dynamodb.Table('Clients')
    
    message="Link on how to setup our new mobile application http://tinyurl.com/AmazonConnectSMS"
    
    CLID=event['Details']['ContactData']['CustomerEndpoint']['Address']

    response = table.query(
            KeyConditionExpression=Key('phoneNumber').eq(CLID)
        )
    resp=response['Items']
    
    for item in resp:
            phoneNumber=item['phoneNumber']

            if phoneNumber==CLID:            
                 # Create an SNS client
                client = boto3.client("sns",region_name="us-east-1")
            
        
                # Send SMS message
                client.publish(
                    PhoneNumber=CLID,
                    Message=message
                )
    
                return {
                    'statusCode': 200,
                    'body': json.dumps('OK')
                }


Step 3.

Now I just need to add my lambda function to Amazon Connect IVR flow.

I created a simple call flow. 

It plays the following message:

"Hello. Welcome to IT Helpdesk. If you are calling from a mobile device about instructions on how to setup a new application please press 1 and we will send you instructions by SMS."

If the client presses 1 I invoke Lambda function sendSMS. Quite simple.







2021-09-15

Estimated Wait Time in Amazon Connect

One of the popular features of the contact center is the ability to play different comfort messages while a call is waiting in the queue.

Out of the box Amazon Connect allows you to play the following information:
  • Number of contacts waiting in the queue
  • How much time oldest contact waiting in the queue
  • Various information about how many agents are available, busy, etc...

What if you want to play Estimated Wait Time (also called Average wait time or Expected wait time in different contact center solutions)? 

It is possible to add this functionality by utilizing Amazon Connect API and Lambda function.


Step 1. 

I created AWS Lambda function getEWT. I used Python 3.9.

What it does?
1) It takes the following attributes from the call
  • statInterval - allows to define time interval that we will use to calculate Estimated Wait Time. It could be last 15 minutes or longer depending on your requirements. If statInterval attribute is missing my function will use 15 minutes as the default value.
  • channel - this parameter identifies the type of contact (Calls, Chat, Tasks) - if your Queue allows receiving different types of contacts normally you would want to have separate Estimated Wait Time for different types of contacts.
  • queueARN - this is identificator of the queue. We need to get the last 36 characters of it to get queueID- we need this parameter to be able to get real-time stats for the queue.
  • InstanceARN - ARN of your Amazon Connect instance. We need it to get InstanceId of your Amazon Connect instance which is required to use Amazon Connect API function

2) after that I connect to Amazon Connect API and use function get_metric_data to get statistical info for the queue during the required interval.

3) I get a metric called QUEUE_ANSWER_TIME - the average time that contacts wait in the queue before being answered by an agent. I use this metric as equivalent for Estimated Wait Time.


You can find the source code of this function on my Github:


Step 2.

Now you can use this Lambda function in your Customer queue flows (flow that is used when a call is waiting in queue).

1) At first you need to assign the required statistical interval to user-defined attribute statInterval using "Set contact attributes" block. 

In my example, I use 15 minutes intervals.





2) After that you can invoke getEWT function

3) It will return the external attribute EWT that contains the estimated wait time value in seconds.

Based on the returned value you can play different messages to clients or make decisions of what to do with the call.





Here is a sample call flow that I use:





Step 3.

You can also use this function in inbound contact flows or modules.

How to do it:

1) Use Set contact attributes block to define statInterval
2) Use Set working queue block to define Queue
3) Now you can use Invoke AWS Lambda function to call getEWT function
4) Use Check contact attribute to check external attribute EWT




2021-08-27

Export users from Amazon Connect to CSV

This article is about exporting users from Amazon Connect to CSV with powershell script.
I also have new article where I use Lambda functions to export users and queues to CSV-files stored on S3.

*****************


So far there is no out-of-the-box method to export users from Amazon Connect to let's say CSV-file.

In order to do that you can use Amazon Connect API.

I created a sample PowerShell script that exports users to CSV file.


How to use it:

1. Install PowerShell module for AWS

Run PowerShell as Administrator

Execute command 

PS > Install-Module -name AWSPowerShell.NetCore


2. Create an access key

In AWS -  go to Identity and Access Management (IAM) 

  • Select Access Management -> Users 
  • Select a user that you will be running your PowerShell script as.
  • Go to "Security credentials" tab and click "Create access key"


3. Add Security Profile to Powershell

In powershell console run this command to create Security Profile

Set-AWSCredential -AccessKey <your access key> -SecretKey <your secret key> -StoreAs <ProfileName>

Example:

Set-AWSCredential -AccessKey AKIA9WFOV27FAFT467AD -SecretKey XwPuuFEWQ7K4zbpkfesr/k/VUbsUP0//DKbroOiV -StoreAs MyProfile

Make it default by running this command:

Initialize-AWSDefaultConfiguration -ProfileName <ProfileName> -Region <Your Amazon Connect region>

Example:

Initialize-AWSDefaultConfiguration -ProfileName MyProfile -Region us-east-1

4. Modify Powershell script for your situation and run it

  • Specify InstanceID of your Amazon Connect
  • Specify ExportPath for CSV file
  • Copy script below to .ps1 file and run it in PowerShell.
Link to ps1 script in my github:



5. Additional info 

  • Remember this is just a sample script, so you can fit it to your own purpose
  • The script is limited to the first 1000 users. If you need to export more - read about NextToken parameter
  • Links to documentation about Powershell tools and Amazon Connect API:
https://docs.aws.amazon.com/powershell/latest/userguide/pstools-welcome.html
https://docs.aws.amazon.com/powershell/latest/reference/items/Connect_cmdlets.html https://docs.aws.amazon.com/connect/latest/APIReference/Welcome.html
  • I also have new article where I use Lambda functions to export users and queues to CSV-files stored on S3.

2021-01-04

Genesys PureConnect tools

 For those who wants to automate some operations in Genesys PureConnect I found those very helpful projects:


1) Directly from official Genesys github site - Command line tool that allows to interact with CIC server using ICWS API.

https://github.com/GenesysPureConnect/cli

Direct link to download version compiled for windows:

https://github.com/GenesysPureConnect/cli/releases/download/v1.1/windows.zip

What you can do with it:

* export user data from CIC server

* check user status

* make calls

* check call status


2) Collection of powershell scripts that also allows to interact with CIC server. It also uses ICWS API.

This one is written by several Genesys employees.

https://github.com/gildas/posh-ic

What you can do with it:

* export data from CIC server

* create users, workgroups

* bulk data creation (users, workgroups, skill etc...)

* update licenses

You can use it as a base to create your own automation scripts. 

I also suggest to check all the available forks of the project. Really nice. For example this one:

https://github.com/plmcgrn/posh-ic


2018-12-11

Amazon Connect

Currently studying Amazon Connect  cloud call center platform.

Very interesting product, definitely would be interesting for many customers.
Ability to build IVR Chatbots out of the box are really impressive.

Available out of the box:

  •     Support for  5000+ agents
  •     DID/Toll-Free numbers provisioning
  •     IVR with graphical editor
  •     Agent Whisper
  •     Customer Whisper 
  •     Integration with external data sources (using Amazon Lambda)
  •     Text To Speech (using Amazon Polly)
  •     Speech recognition / IVR Chatbot (using Amazon Lex)
  •     Skill Based routing
  •     Real-time reporting
  •     Historical reporting
  •     Call recording
  •     Ability for supervisors to listen to calls in realtime
  •     Ability to call each individual extension
  •     Music/messages on hold 
  •     Messages in queue
  •     Basic Callback
  •     Softphone (webrtc)
  •     Or any phone with direct number
  •     Changing agent status from Softphone
  •     Supervisor can change agent status remotely
    
Available (requires development, API available)

  •     Screen Pop
  •     Outbound campaigns
  •     Scheduled callback
  •     Expected wait time messages in queue
  •     Custom reporting


Currently not available:

  •     Email to skillet 
  •     Web-chat to skillet
  •     SMS to skillset
  •     Voicemail
  •     Changing agent selection algorithm (only supports longest idle agents)
  •     Changing priorities of agents within skillsets - possible but painful 
  •     QM  (can integrate with other QM systems)
  •     WFM (can integrate with other WFM systems)
     

2018-01-24

Avaya Aura Contact Center 7.x (AACC) -- SA database passwords

AACC  CCMS
login: ccSA
pass:cCaPpS0820
Namespace: ADMIN


AACC  CCMM
login: mmAdministrator 
pass: mmAdm
Namespace: MULTIMEDIA


AACC  CCT
login: ccSA
pass:cCaPpS0820
Namespace: CCT70


AACC  CCMA   (new database in AACC 7.x, replaces Access DB in AACC 6.x)
login: ccSA
pass:cCaPpS0820
Namespace: CCMA


All these passwords are stored in Windows registry without any encryption.

2017-07-05

AACC: How to change internal variable value from external application


If for some reason you want to change variable value of AACC from external application you can use following web-service (works for any version of AACC).

WSDL:


Method:
SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_Ex

Sample request:
<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:soap="http://SOAPScriptingWrapper.CCMA.Applications.Nortel.com">
   <soapenv:Header/>
   <soapenv:Body>
      <soap:SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_Ex>
                   <!—CCMA admin user -->
                  <soap:ccmaUserName>webadmin</soap:ccmaUserName>
                   <!—IP address of client application -->
                   <soap:clientIP>XXX.XXX.XXX.XXX</soap:clientIP>
                   <!—IP address of AACC server -->
                   <soap:strSIP>ZZZ.ZZZ.ZZZ.ZZZ</soap:strSIP>
                   <!—CCMSU admin username & password -->
                   <soap:strUserName>sysadmin</soap:strUserName>
                   <soap:strPassw>********</soap:strPassw>
       <!— Variable ID -->
                   <soap:intVarID>15849</soap:intVarID>
       <!— Variable name -->
                   <soap:strVarName>int_test001</soap:strVarName>
                   <soap:bRefedByTF>0</soap:bRefedByTF>
                   <soap:intTableID>28</soap:intTableID>
                   <soap:intStatus>2</soap:intStatus>
                   <soap:intVarType>11</soap:intVarType>
                   <soap:intVarClass>30</soap:intVarClass>
                   <soap:intDataType>1</soap:intDataType>
        <!— Change variable to this value -->
                   <soap:strListValue>1</soap:strListValue>
                   <soap:intNumValue>1</soap:intNumValue>
                   <soap:intValueSize>4</soap:intValueSize>
                   <soap:bFreeValue>1</soap:bFreeValue>
      </soap:SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_Ex>
   </soapenv:Body>
</soapenv:Envelope>


Successful response:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <soap:Body>
      <SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResponse xmlns="http://SOAPScriptingWrapper.CCMA.Applications.Nortel.com">
        <SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResult>1</SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResult>
         <strErrMsg/>
      </SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResponse>
   </soap:Body>
</soap:Envelope>



Unsuccessful response:
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
   <soap:Body>
      <SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResponse xmlns="http://SOAPScriptingWrapper.CCMA.Applications.Nortel.com">   <SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResult>0</SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResult>
         <strErrMsg/>
      </SOAPScriptingWrapper_ScriptVarsWS_SetItem_All_ExResponse>
   </soap:Body>
</soap:Envelope>

2015-05-29

AACC 6.2 - How to convert Master_Script from graphical flow back to text

If you occasionally converted your Master_Script to graphical flow and now
realize what a nightmare to use it for day-to-day changes there is a way to convert
it back to text.

Starting from version AACC 6.3 you can do it officially from Orchestration Designer
but for AACC 6.2 and earlier you need some tweaking :)

1) Start Orchestration Designer
2) Select your CCMS server and copy it to Local view
3) Now go to the installation path of OD
C:\Program Files\Avaya\Contact Center\SCE\LocalData
4) Open file LocalWorkBenchModel.xml
5) Search for "Master_Script"
6) Change isFlow from YES to NO
7) close and reopen OD
8) Connect again to your CCMS
9) In Local view open Master_script - and change something (for example - you can add new comment)
10) Synchronize Local view with your CCMS
and you will see that Master_Script flow will be replaced with script version of Master_Script from Local view.

Bingo!

2015-03-08

Avaya CS1000 Outbound calls cheap solution

What could be the cheapest solution for Outbound campaign in Avaya AACC?

Microsoft Excel!

Lots of small/medium companies who doesn't have or need something more sophisticated just do manual outbound calls and use Microsoft Excel lists to track outbound calls statuses.

Next move - if you already have some sort of CDR collector - Avaya CDR Toolkit (see my previous posts) or something else - you can configure additional outbound route on your PBX with for example trunk access code 88 and then configure digit manipulation table to remove first 4 digits.
Now when agent dials 88XX (4 digits) CDR will show that this particular called number has prefix 8801, 8802.

So, logically you can assign each code 8801, 8802 etc to either different outbound campaigns or clients or anything you want..

Now, in your CDRs you will be able to find outbound calls associated with specific outbound campaign.

2015-03-03

Avaya CS1000 CDR collector

Starting from release CS1000 7.5 (maybe even earlier) Avaya offers toolkit that allows you to configure CDR collection ( Avaya CDR/Traffic Toolkit 2.0)

It is available on devconnect:

http://www.devconnectprogram.com/site/global/products_resources/communication_server_1000/interfaces/data_buffering_and_access_cdr/releases/index.gsp

Because it is a toolkit you still need some development to make it work.
I've created a simple script that saves content of the CDR output  text file to MS SQL database.
You need to create a table with format described in bcp.fmt format file and schedule this script to run every 15 minutes (default output time of Avaya CDR collector).

Insert_CDR_to_DB.zip

2015-03-02

Avaya MPS 500 ports logon/logoff script

If you happen to have Avaya MPS 500 IVR with Lineside E1 or T1  cards integrated with AACC, you might find these scripts useful.

They allow to logon/logoff  MPS ports right from windows console.

I know that other uses might use different approach (for example GUI PeriPro application) but I find these scripts quite useful and faster than GUI.

Edit them according to your particular situation:

vsh -C #css.1 csvapi thisdevice 999800 agentid 888141 loginid 888141 ctifunction agentsetlogoff
where 999800 - PositionID of MPS port (KEY 0)
          888141 - AgentID - could be any number
                                 (only restriction they shouldn't conflict with real agents AgentIDs)

mps_logon_logoff.zip

Enjoy it!