Aura – operation

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Bot utilities

Description of aura-bot-utilities

Introduction

aura-bot-utilities is a package belonging to aura-common-utilities that includes utilities for handling different tasks over aura-bot.

Find more information in the Github repository:
https://github.com/Telefonica/aura-common-utilities/tree/master/packages/aura-bot-utilities/

How to install aura-bot-utilities package

$ git clone https://github.com/Telefonica/aura-common-utilities.git

$ cd aura-common-utilities/packages/aura-bot-utilities

How to import an utility from this package

To import an utility from the aura-bot-utilities package, execute the following command:

import { ... } from '@telefonica/aura-bot-utilities/lib/[*utility-name*]';

For example:

import { generateAttachment, getReference, getTextFromResolution } from '@telefonica/aura-bot-utilities/lib/aura-bot-library-util';

Available utilities

List of utilities in the aura-bot-utilities package:

aura-bot-common utility includes useful utilities to handle conversations both in aura-bot and in the dialogs.
aura-bot-kpis utility simplifies how KPI entities are handled in aura-bot and aura-groot.
aura-bot-library-util utility for developing aura-bot libraries and dialogs.
aura-minibot-service utility simplifies how aura-minibot and aura-minigroot are generated.
aura-movistar-libraries utility that contains utilities to be used in dialogs for Movistar channels.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura common utilities

Description of aura-common-utilities

Introduction

aura-common-utilities is a multipackage repository with all the libraries provided by Aura team to make development easier.

aura-common-utilities repository is organized into four packages:

aura-bot-utilities, used for handling different tasks over aura-bot.
aura-utilities, used by other Aura components.
aura-develop-utilities, that include utilities used for different development purposes.
aura-clients referred to tools that make easier to call APIs.

Additionally, there are certain utilities that have not been migrated to these packages yet and are documented outside the packages sections.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Core technologies in Aura

DRAFT DOCUMENT

This document summarizes the core technologies used in both Aura Virtual Assistant and ATRIA, that support their different functionalities and services

Other technologies used for specific issues are referenced in the corresponding documentation

Aura deployment

Aura is deployed in Microsoft Azure
Components packaging is done using Docker
Deployment is hosted on Azure Kubernetes
Deployment is orchestrated using Ansible

Security and privacy

Aura ensures compliance with GDPR regulations
Aura installer relies in Python security practices
The use of ARM templates enhance security of our Azure resources

Operational foundations

Aura Virtual Assistant is based on Microsoft Bot skills architecture
Aura Bot is built over Microsoft BotFramework

Data management

We use MongoDB and Redis as service databases
Databricks handles the optimization of data processing

Languages

Aura backend is developed using Typescript and Python
iOS development is based on Swift
Certain scripts are made with Bash
ATRIA aura-manager web interface is built with React and Typescript

Monitoring tools

Aura metrics are generated in Prometheus
Aura monitoring stack includes Elasticsearch, Grafana and Kibana

Testing tools

Functional tests implemented in Python using:
Toolium
Behave
Selenium
Appium

AI-driven technologies

Azure OpenAI: Embeddings, GPT models
Hugging Face models
Microsoft Conversational Language Understanding (CLU)

Releases management

We apply the Release Train Manager methodology
Github is used as the orchestrator for the RTM
All our CI processes run in Jenkins

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Direct Line flowcharts

Basic flows for Direct Line channels

Request a new accessToken from Direct Line to access Aura

These steps must be executed before starting the user conversation with Aura. The token to access Direct Line must be requested to Aura because one of the admin secrets of the bot Direct Line configuration is used to generate the tokens.

@startuml
    title: Request a DirectLine accessToken for AuraGroot
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99

    Channel -> AuthenticationApi: POST /aura-services/v1/token/wss
    AuthenticationApi -> DirectLine: POST /token
    DirectLine -> AuthenticationApi: 201 Created {token}
    AuthenticationApi -> Channel: 201 Created {token}
    Channel -> DirectLine: Open WebSocket
    Channel -> DirectLine: Start sending user requests
    Channel -> DirectLineWebSocket: Start getting Aura responses
@enduml

New Direct Line message from anonymous users

An anonymous user is the one that has never been authenticated via Kernel and her authentication session has not been stored in aura-authentication-api.

Find more information in the document Channels authentication: anonymous users

@startuml

title: Basic flow for DirectLine anonymous users


    actor User
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 

    Channel -> DirectLineWebsocket: Open WebSocket
    User -> Channel: Send [message]
    Note over Channel,DirectLine: The previously created token of DirectLine must be sent in the Authorization header as Bearer token.
    Channel -> DirectLine: Send {activity[message]}
    DirectLine -> AuraGroot: Send {activity[message]}
    AuraGroot -> DirectLine: 200 OK
    note right of AuraGroot: KPI entities are stored during Middlewares execution in local memory.\nEvery 2 minutes and before closing a POD, they are written in Azure Storage.
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {activity[message]}
    Note over AuraGroot,AuraBot: There are two different conversations: one between the channel and AuraGroot and another one between AuraGroot and the skill.
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuthenticationApi: GET AuraId
    AuthenticationApi -> AuraBot: 404 Not found (Anonymous)
    AuraBot -> AuraBot: Middlewares
    note right of AuraBot: KPI entities are stored during Middlewares execution in local memory.\nEvery 2 minutes and before closing a POD, they are written in Azure Storage.
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute Specific functional Dialog
    AuraBot -> AuraGroot: Send {responseActivity}
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> DirectLine: Send {responseActivity}
    DirectLine -> AuraGroot: 200 OK
    Channel -> DirectLineWebsocket: Read {responseActivity}
    Channel -> User: Show {responseActivity}
@enduml

New Direct Line message from authenticated users

Find information regarding users’ authentication in the document Channels authentication: authenticated users.

@startuml

title: Basic flow for DirectLine authenticated users

    actor User
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF
    
    Channel -> DirectLineWebsocket: Open WebSocket
    User -> Channel: Send [message]
    Note over Channel,DirectLine: The previously created token of DirectLine must be sent in the Authorization header as Bearer token.
    Channel -> DirectLine: Send {activity[message]}
    DirectLine -> AuraGroot: Send {activity[message]}
    AuraGroot -> DirectLine: 200 OK
    Note right of AuraGroot: KPI entities are stored during Middlewares execution in local memory.\nEvery 2 minutes and before closing a POD, they are written in Azure Storage.
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {activity[message]}
    Note over AuraGroot,AuraBot: There are two different conversations: one between the channel\nand AuraGroot and another one between AuraGroot and the skill.
    AuraBot -> AuraGroot: 200 OK
    opt user is not in cache
        AuraBot -> AuthenticationApi: GET AuraId
        AuthenticationApi -> AuraBot: 200 OK {userData}
        AuraBot -> KernelAuthServer: POST /token
        Note over AuraBot,KernelAuthServer: Here, a 3legged accessToken is requested
        KernelAuthServer -> AuraBot: {token}
        AuraBot -> KernelAuthServer: getIntrospect(token)
        opt channel allows UserProfile
            AuraBot -> KernelUserProfileApi: getUserProfile(userId)
            KernelUserProfileApi -> AuraBot: UserProfile
        end
        AuraBot -> AuraBot: store user in cache: userData, userProfile, valid scopes and purposes
    end
    AuraBot -> AuraBot: Middlewares
    Note right of AuraBot: KPI entities are stored during Middlewares execution in local memory.\nEvery 2 minutes and before closing a POD, they are written in Azure Storage.
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: ValidateAuthenticationForDialog
    AuraBot -> AuraBot: Execute Specific functional Dialog
    AuraBot -> AuraGroot: Send {responseActivity}
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> DirectLine: Send {responseActivity}
    DirectLine -> AuraGroot: 200 OK
    Channel -> DirectLineWebsocket: Read {responseActivity}
    Channel -> User: Show {responseActivity}
@enduml

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

General guidelines for locales management

The aim of this document is to describe how locales are handled by Aura Bot services for the following components: aura-groot, aura-authentication-api, aura-bridge, aura-bridge-outbound.

⚠️ Remember that hot swapping of aura-bot locales must be done through the aura-configuration-updater

Introduction

The objective of the current document is to describe the hot swapping process to update POEditor texts in Aura without service outage, both for global and local use cases. Hereinafter, we will refer it as hot swapping process.

For each type of use cases, the process uses different projects and has a different scope, as shown in the following table.

Global use cases	Local use cases
- Aura POEditor global project (owned by Aura Global Team)	- Aura POEditor local project (owned by L-CDO Team)
- Scope: edition of texts	- Scope: edition of texts and definition of resources

In both cases, the texts correspond to PRE and PRO resources in POEditor.

Follow the orderly guidelines in the succeeding sections:

⚠️ If you have local use cases, you must carry out the process included in this document for update POEditor texts each time a new version of your local use cases is deployed.

Previous steps

Previous steps include the management of POEditor itself for the edition of texts and, depending on the use case type, the generation of resources. These tasks are fully defined in the corresponding documents:

Global Use Cases > Edition of POEditor texts
Local Use Cases > Edition of POEditor texts and generation of resources (references)

Generation of POEditor token

Once the texts have been modified in POEditor, it is necessary to have a Read-only API Token in order to import them into aura-bot.

Global Use Cases: developers should request the read-only API Token to the APE Team.
Local Use Cases: developers should request the read-only API Token to the local responsible of POEditor project.

The reading token is obtained from the POEditor website, where the OB edits the texts.

Figure 1. Add readonly API token

Figure 2. API access

Importing locale files with aura-locale-importer tool

We recommend using aura-locale-importer tool, a utility developed by Aura Global Team that allows to handle the importation and exportation of locale files with POEditor.

Install aura-locale-importer tool:
1.1. Log in NPM to download the private NPM package dependencies. You can log in with user/password or using the token:
- User/password -> npm login
- Token -> Add the token to your environment variables on your machine. Follow the guidelines for mac/linux.
1.2. Install the npm application globally in the host. You can use two equivalent commands for installing the latest available version:
npm install –g @telefonica/aura-locale-importer or
npm i @telefonica/aura-locale-importer -g
Copy in a local directory the file containing the locale resources to be updated (JSON file from aura-bot/locale/ directory). If there is no file, the aura-locale-importer tool will generate one.
Get full locale files to be uploaded:
```
$ aura-locale-importer -u -l <language-country> -j <POEditor project> -b <my-library> -d <local-directory> -m library -f –t <token>
```
Where:
- -l <language-country>: country translation e.g., es-es, de-de, en-gb. If this field is empty, the system will import every translation file.
- -j <POEditor project>: POEditor project to be used:
- For global use cases: aura-bot project (global project)
- For local use cases: name of the OB’s local project
- -b <my-library>: specific libraries to be uploaded in the hot swapping process. For example: fill this parameter with authentication for aura-authentication-api, or fill it with bridge for aura-bridge.
- -d <local-directory>: local directory where result files will be imported.
- -f: this parameter forces the files overwriting.
- -m library: it indicates the way of working. For the current release, it must be library.
- -t <token>: read-only API token to access to POEditor.
Here, developers can follow two different processes:

a. Define it in the environment variable $POEDITOR_TOKEN in the host running the process. In this case, this command should not be included here.

b. Add it in the current command within -t <token>

An example for a local use case in Germany is shown below:
- This command will generate all the locale files that fulfil the conditions established in the parameters above:
```
`$ aura-locale-importer -u -l de-de -j Aura-Bot-De -d ./locale -m library -f –t f9023005c8792e57d3593511b69c300e`
```
- This command lists the content of the locale folder in Aura Bot project. $ ls .locale
The output will be: de-de.json

Locale files uploading

This process requires certain previous steps, as all the resources and texts (from the bot core, global use cases or local use cases) must be merged together during the make-up process.

Access the Azure blob container static-resources in your intended environment, where the JSON file with your resources and texts is. This file will be in the following paths, depending on the component:

For aura-authentication-api:
static-resources/authentication/locale/<aura-version>/<language-country>.json
For aura-bridge:
static-resources/aura-bridge/locale/<aura-version>/<language-country>.json

It is recommended to use Azure Storage Explorer in order to easily access this file.

Figure 3. Updating locale files to Azure

Download this file for its edition.
Add the new content from the imported locale files to the downloaded files or replace the specific content.

For example, you can add a new resource from the imported file (Section 4.3.) to the end of the file downloaded from Azure (Step 1). Or you could replace one of the texts appearing in the downloaded file (Step 1) with one of the new texts shown in the imported file.
Validate the JSON format through the online tool JSONLint.
Upload again the JSON file into the corresponding Azure blob container (depending on the component, the locale file must be in a different container as explained in step 1). Depending on the component, the files should be loaded into a different folder. In case the folder in that path does not exist, please create it manually.

⚠️ It is recommended to make a backup copy before overwriting.
If you want to keep previous versions of the JSON files as a backup during testing, you must remove the JSON extension from the file name to prevent these files from also being imported into Aura. For example:
❌ <language-country>.json.backup
✔️ <language-country>.backup

This assures that only one JSON file is present for each language.

Make modifications available

Check LocaleManager configuration

Check the configuration of the component to be updated, aura-authentication-api or aura-bridge, following LocaleManager configuration, for instance:
$ kubectl –n <aura-ns> edit cm <authentication-api|aura-bridge>

⚠️ Firstly, read the document connecting to Kubernetes to know how to operate with Kubernetes in your environment.

Where:

<aura-ns> is aura namespace, with the following format: aura-<OB>-<environment>
The specific value for <aura-ns> is an output for the installation process and can be found in the path _output_install/*info.json, in the field services_namespace.

This will open a text editor (such as vi) showing the whole config map of the specified pod.

The servers aura-authentication-api and aura-bridge count on a series of environment variables that manage the process. Developers should check several items, shown in the following screenshots for both servers.

You have the right Aura version: variable AURA_VERSION.
Verify the values for the Azure Storage account: variable AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT.

Figure 4. Check LocaleManager configuration

The definition of these variables is shown below:

AURA_VERSION: string with the semantic versioning of Aura to be read from the remote blob container. By default, it takes the version packaged originally in the docker image (7.0.0. in the case of Heroes). It is required to put a correct value, to be sure that the container is loading the correct set of files.
AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT: string with the name of the Azure Storage account related to the given aura deployment.

Restart the corresponding pod/pods

For the Kubernetes version 1.15 onwards, the following command must be launched for restarting the corresponding pod/pods.

If developers have modified the locale file for aura-bridge, they will need to restart aura-bridge pods.
The same applies for changes made in aura-authentication-api, its pod should only be restarted in case you modified the locale file in the folder for this component.

kubectl version >= 1.15: 
$ kubectl rollout restart deployment [authentication-api, aura-bridge]

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Get started with Aura Bot

Guidelines including how to create a bot service, different approaches to install Aura Bot and procedure for its configuration

Related documents
📃 Aura Bot Platform descriptive documentation

Introduction

ℹ️ First time using Aura Bot? Go ahead with this section.

aura-bot architecture is a modular one and has been designed in order to fulfil an essential requisite of configurability and extensibility for Aura deployment if a customized Aura behavior is needed.

This section is mainly intended to developers interested in the installation and configuration of aura-bot.

Create a bot service

⚠️ This task must be carried out only once by an aura-bot developer

Follow the guidelines in Microsoft documentation: Create a bot with Azure Bot Service.
Save the value of the following variables from the created bot:

"AURA_MICROSOFT_APP_ID":"YOUR ID", 
"AURA_MICROSOFT_APP_PASSWORD":"YOURPASS",

Install Aura Bot

Developers can install aura-bot following two different approaches:

Aura minibot
Aura minibot is a tool intended for testing purposes in local environment. It is highly recommended to use Aura minibot to get familiar with aura-bot when developing simple use cases. Learn how to install and work with Aura minibot.
Full Aura Bot
If you want to install locally a fully functional working instance of aura-bot, go to the full Aura Bot section.

Configure Aura Bot

How to start a basic Aura Bot configuration

We recommend to use Kubernetes for the management of the environment variables required for the bot configuration.

Developers can use the process explained below:

Access with kubeconfig

The jq JSON processor can be used to decode all the private variables (developers should install it and get sure it is added to the OS PATH).

Set the KUBECONFIG file (provided by DevOps) through the following command: export KUBECONFIG=<name of the file provided>
To check all the available environments, use: kubectl get ns
Download all the environment variables and join them in a unique file:

( kubectl -n <env name> cm aura-bot -o json | jq.exe -r ".data|to_entries|map(\"\(.key)=\(.value|tostring)\")|.[]" ; kubectl -n <env name> get secret aura-bot -o json | jq.exe -r ".data|to_entries|map(\"\(.key)=\(.value|tostring|@base64d)\")|.[]" ) > <env name>

Where: <env name> is the name space selected on step 2 (kubectl get ns)

ℹ️ Base 64 decodification requires a jq version from 1.6 onwards

Copy this file into the project folder (wherever you are storing .env files).
Enable forwarding from your local address (localhost) to the kubernetes aura-configuration-api deployment.

kubectl --namespace <env name> port-forward deployments/aura-configuration-api 8999:8999

Point AURA_CHANNELS_CONFIGURATION_API_ENDPOINT to previously forwarded service: http://localhost:8999/aura-services/v2/configuration.
Highly Recommended: if using Visual Studio Code, you could add these objects to your launch.json file to be able to run the make-up process in debug mode and change certain variables without directly modifying aura-configuration-api channels information and/or (according to AURA_MAKEUP_FILES_DESTINATION variable) the bot-response.json file.

[
  {
    "type": "node",
    "request": "launch",
    "name": "name of the script",
    "program": "${workspaceFolder}/lib/index.js",
    "console": "integratedTerminal",
    "outFiles": [
      "${workspaceFolder}/lib/**/*.js"
    ],
    "env": {
      "CONFIG_FILE": "your .env file path",
      "AURA_MICROSOFT_APP_ID": "YOUR ID",
      "AURA_MICROSOFT_APP_PASSWORD": "YOURPASS",
      "AURA_LOGGING_FORMAT": "dev",
      "AURA_LOGGING_LEVEL": "DEBUG"
    }
  },
  {
    "type": "node",
    "request": "launch",
    "name": "makeup",
    "program": "${workspaceFolder}/lib/make/makeup-cli.js",
    "outFiles": [
      "${workspaceFolder}/lib/**/*.js"
    ],
    "env": {
      "CONFIG_FILE": "your .env file path",
      "AURA_LOGGING_FORMAT": "dev",
      "AURA_LOGGING_LEVEL": "DEBUG",
      "AURA_MAKEUP_MODE": "local"
    },
    "console": "integratedTerminal"
  }
]

In case the adjustment of the value for certain variables is required, modify directly the file launch.json, as explained before.

Example of environment configuration

As an example, the main configuration file (.env.PRO) can be defined as follows:

AURA_DEFAULT_LOCALE=es-ar
AURA_SERVER_PORT=8080

All environment variables with their description can be found at the following link Aura Bot Platform environment variables

In case aura-bot is started using the following command:
CONFIG_FILE=./env/.env.PRO AURA_DEFAULT_LOCALE=es-es npm start
Then, the aura-bot instance would use the following configuration variables and values:

AURA_DEFAULT_LOCALE would take the value es-es since it is set as an environment variable and has the highest priority.
AURA_SERVER_PORT would take the value 8080 since it is set in the main configuration file, and not as an environment variable.
AURA_LOGGING_LEVEL would take the value INFO since it is set in the configuration schema definition and nowhere else (default value).

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Handling user messages in RCS channel

The current document includes the guidelines for handling different types of messages in the RSC channel.

Handling user button responses

Some messages received from RCS channels have a particular behavior and some data is returned to the dialog in a new field of the channelData: channelData.payload.suggestionResponse.

Here is an example of a user response of this type:

{
    "type": "message",
    "id": "d152aee9-1aaa-5b54-95a5-79352eee2e45|MxRCKxirowTtaiNb8-REy9TA",
    "channelId": "f7fd1021-41cd-588a-a461-387cc24be225",
    "from": {
        "id": "34659949469",
        "name": "javiagent_crbwyhqz_agent@rbm.goog"
    },
    "conversation": {
        "id": "c0709653-45f7-4fca-9808-3702d11fc346"
    },
    "channelData": {
        "payload": {
            "suggestionResponse": {
                "postbackData": "{\\"intent\\": \\"intent.factotum-test.rcs-formats\\",\\"entities\\":[{\\"type\\":\\"type\\",\\"entity\\":\\"postback\\"},{\\"type\\":\\"data\\",\\"entity\\":\\"card 1\\"}]}",
                "text": "Card #1",
                "type": "REPLY"
            },
            "bridge": {
                "channelId": "f7fd1021-41cd-588a-a461-387cc24be225"
            },
            "auraGroot": {
                "channelConversationId": "d152aee9-1aaa-5b54-95a5-79352eee2e45",
                "channelId": "f7fd1021-41cd-588a-a461-387cc24be225"
            }
        },
        "version": "3",
        "appContext": {
            "channel": {
                "modality": "text",
                "id": "f7fd1021-41cd-588a-a461-387cc24be225"
            },
            "timestamp": "2024-10-04T16:36:55+02:00",
            "timezone": "Europe/Madrid"
        },
        "correlator": "1be1b360-8cc4-4a4d-845b-bebb47869afd"
    },
    "text": "{\\"intent\\": \\"intent.factotum-test.rcs-formats\\",\\"entities\\":[{\\"type\\":\\"type\\",\\"entity\\":\\"postback\\"},{\\"type\\":\\"data\\",\\"entity\\":\\"card 1\\"}]}",
    "serviceUrl": "http://localhost:8080/api/skills",
    "relatesTo": {
        "serviceUrl": "http://localhost:8045/aura-services/javiagent",
        "activityId": "d152aee9-1aaa-5b54-95a5-79352eee2e45|MxRCKxirowTtaiNb8-REy9TA",
        "channelId": "f7fd1021-41cd-588a-a461-387cc24be225",
        "conversation": {
            "id": "d152aee9-1aaa-5b54-95a5-79352eee2e45"
        },
        "bot": null
    },
    "recipient": {
        "role": "skill"
    },
    "callerId": "urn:botframework:aadappid:3837ac07-50e0-4d4e-993b-1bda1349f25a",
    "locale": "es-cr"
}

The value of text and postbackData was set by the dialog when the card was sent, you can find more info in building Aura response

Handling suggestion responses

Buttons in cards, prompts or suggestions, return a REPLY response as the following suggestionResponse:

"suggestionResponse": {
    "postbackData": "Rock",
    "text": "Rock",
    "type": "REPLY"
}

If prompts are created as specified in building Aura response, they will be handled properly without any extra steps, because postbackData will be the text field of the activity and will be recognized by the prompt as an option.

Handling actions responses

Actions return an ACTION response as the following ones:

"suggestionResponse": {
    "postbackData": "{\\"intent\\": \\"intent.factotum-test.rcs-formats\\",\\"entities\\":[{\\"type\\":\\"type\\",\\"entity\\":\\"postback\\"},{\\"type\\":\\"data\\",\\"entity\\":\\"la ubicación\\"}]}",
    "text": "View map",
    "type": "ACTION"
}

"suggestionResponse": {
    "postbackData": "{\\"intent\\": \\"intent.factotum-test.rcs-formats\\",\\"entities\\":[{\\"type\\":\\"type\\",\\"entity\\":\\"postback\\"},{\\"type\\":\\"data\\",\\"entity\\":\\"llamar\\"}]}",
    "text": "Call",
    "type": "ACTION"
}

Ignoring responses

Every button sent to the user must have the postbackData field included:

            'contentMessage': {
                'text': 'Call technical service',
                'suggestions': [
                    {
                        'action': {
                            'text': 'Call us!',
                            'postbackData': '{"intent": "intent.factotum-test.rcs-formats","entities":[{"type":"type","entity":"postback"},{"type":"data","entity":"call"}]}',
                            'fallbackUrl': 'https://www.google.com/contact/',
                            'dialAction': {
                                'phoneNumber': '+66666666666'
                            }
                        }
                    }
                ]
            }

And this postbackData will be returned as a message to aura-bot when the user clicks the button. If you want to ignore this message or only write a log, you should implement a specific dialog to handle these actions and send every action response to this dialog with an aura-command:

{
                    contentType: 'application/vnd.telefonica.aura.rcs.message', content: {
                        'contentMessage': {
                            'text': 'Location message',
                            'suggestions': [
                                {
                                    'action': {
                                        'text': 'View map',
                                        'postbackData': '{"intent": "intent.ignore-user-postback.example-dialog","entities":[]}',
                                        'fallbackUrl': 'https://www.google.com/maps/place/40%C2%B021\'39.5%22N+4%C2%B020\'01.8%22W/@40.3609722,-4.3338333,17z',
                                        'viewLocationAction': {
                                            'latLong': {
                                                'latitude': '40.36085110',
                                                'longitude': '-4.33394257'
                                            },
                                            'label': 'Pelayos de la presa, pedacito de cielo'
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura operational flowcharts

The current section includes certain key operational flows in Aura

Introduction

Find the following flowcharts for Aura operational processes:

Basic Direct Line flowcharts for anonymous and authenticated users
User Authentication flowcharts, that show how users’ authentication is handled depending on how the channel is integrated in Aura
Use cases flowcharts for basic use case execution flows
WhatsApp flowcharts for basic processes, Terms & Conditions management and authentication in this channel
Auraline flowcharts, containing the messages flow for this communication protocol

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Start a conversation in RCS channel

Sending messages through aura push

Introduction

Due to the design of the RCS protocol, the conversation with the user must be started by the server, who always sends the first message. To send this first message or other messages without being in a conversation, the plugin aura push is used.

Sending text messages to the user

To send a simple text message to the user, a body like the following should be sent to the aura push endpoint:

{
  "url":"https://svc-ap-next.auracognitive.com/aura-services/v1/aurapush/messages?channelId=f7fd1021-41cd-588a-a461-387cc24be225&apikey=XXX",
  "channelId":"f7fd1021-41cd-588a-a461-387cc24be225",
  "from":"+34666666666",
  "id":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
  "text":"Hi! I'm Aura",
  "type":"rcs",
  "notificationId":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
  "notificationType":"not declared",
  "checkContact":true
}

Sending complex messages to the user

If you need to send a more complex RCS message to the user, like a file, a card or any other type of RCS message, you need to add the rcsContentMessage field, that corresponds with the contentMessage field of RCS messages:

  {
        "url":"https://svc-ap-next.auracognitive.com/aura-services/v1/aurapush/messages?channelId=f7fd1021-41cd-588a-a461-387cc24be225&apikey=XXX",
        "channelId":"f7fd1021-41cd-588a-a461-387cc24be225",
        "from":"34666666666",
        "id":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "text":"This text will be ignored",
        "type":"rcs",
        "notificationId":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "notificationType":"not declared",
        "checkContact":true,
        "rcsContentMessage": {
            "contentInfo": {
                "fileUrl": "https://media.tenor.com/3VSWB_GIkqwAAAAe/wololo-age-of-empires.png",
                "forceRefresh": "false"
            }
        }
    }

Also, if you want to send all the messages in the same way, text messages can be sent with this format:

  {
        "url":"https://svc-ap-next.auracognitive.com/aura-services/v1/aurapush/messages?channelId=f7fd1021-41cd-588a-a461-387cc24be225&apikey=XXX",
        "channelId":"f7fd1021-41cd-588a-a461-387cc24be225",
        "from":"34666666666",
        "id":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "text":"This text will be ignored",
        "type":"rcs",
        "notificationId":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "notificationType":"not declared",
        "checkContact":true,
        "rcsContentMessage": {
            "text": "Hi! I'm Aura"
        }
    }

Sending messages through aura-bot

The previous messages are sent directly from aura-bridge to the user, but if you need to send a more complex message with data that can only be accessed by a bot dialog, you can send a message to a bot dialog setting the type field to directline-rcs like this:

    {
        "url":"https://svc-ap-next.auracognitive.com/aura-services/v1/aurapush/messages?channelId=f7fd1021-41cd-588a-a461-387cc24be225&apikey=XXX",
        "channelId":"f7fd1021-41cd-588a-a461-387cc24be225",
        "from":"34666666666",
        "id":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "text":"{\"intent\": \"intent.rcs.template\"}",
        "type":"directline-rcs",
        "notificationData":{
            "brand":"Vivo",
            "anotherCustomParam": "anotherCustomValue"
        },
        "notificationId":"a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "notificationType":"not declared",
        "checkContact":true,
        "rcsContentMessage": {
          "text": "Hi {{customerName}}! I'm Aura, the AI assistant from {{brand}}"
        }
    }

Sending a message like the previous example, the bot will receive an activity like this, with the fields notificationData, rcsContentMessage, uuid, notificationType and notificationId forwarded inside the channelData.payload.bridge.customData field of the activity:

{
    "type": "message",
    "id": "d152aee9-1aaa-5b54-95a5-79352eee2e45|a1be40d0-b8de-4c2a-8a26-8740a739675e",
    "channelId": "f7fd1021-41cd-588a-a461-387cc24be225",
    "from": {
        "id": "34666666666",
        "name": "javiagent_crbwyhqz_agent"
    },
    "conversation": {
        "id": "1f6b5e0e-a5e1-4567-a39d-ba239d7d6d14"
    },
    "channelData": {
        "version": "3",
        "appContext": {
            "channel": {
                "modality": "text",
                "id": "f7fd1021-41cd-588a-a461-387cc24be225"
            },
            "timestamp": "2024-10-14T13:40:54+02:00",
            "timezone": "Europe/Madrid"
        },
        "payload": {
            "bridge": {
                "customData": {
                    "uuid": "a1be40d0-b8de-4c2a-8a26-8740a739675e",
                    "notificationType": "not declared",
                    "notificationId": "a1be40d0-b8de-4c2a-8a26-8740a739675e",
                    "notificationData": {
                      "brand":"Vivo",
                      "anotherCustomParam": "anotherCustomValue"
                    },
                    "rcsContentMessage": {
                      "text": "Hi {{customerName}}! I'm Aura, the AI assistant from {{brand}}"
                    }
                }
            },
            "auraGroot": {
                "channelConversationId": "d152aee9-1aaa-5b54-95a5-79352eee2e45",
                "channelId": "f7fd1021-41cd-588a-a461-387cc24be225"
            }
        },
        "correlator": "078ee5cf-2b9d-4fb6-9268-c9c5685232f8"
    },
    "text": "{\\"intent\\": \\"intent.rcs.template\\"}",
    "serviceUrl": "http://localhost:8080/api/skills",
    "relatesTo": {
        "serviceUrl": "http://localhost:8045/aura-services/javiagent",
        "activityId": "d152aee9-1aaa-5b54-95a5-79352eee2e45|a1be40d0-b8de-4c2a-8a26-8740a739675e",
        "channelId": "f7fd1021-41cd-588a-a461-387cc24be225",
        "conversation": {
            "id": "d152aee9-1aaa-5b54-95a5-79352eee2e45"
        },
        "bot": null
    },
    "recipient": {
        "role": "skill"
    },
    "callerId": "urn:botframework:aadappid:3837ac07-50e0-4d4e-993b-1bda1349f25a",
    "locale": "es-cr"
}

With this data you can create your custom dialog. The easiest way to reach your dialog is sending an aura-command with the desired intent in the text field as you have seen in the previous example. In the rcsContentMessage you can send your pre-formated RCS body to be filled by the bot, and if you need more extra params can be sent in the notificationData field.

Checking the contact availability

RCS is enabled in Android since version 5, and in iOS since version 18, but some customers couldn’t have it disabled or not available in their phones. To avoid errors sending messages to phones that doesn’t allow RCS, you can check with the api if this phone is available, and then, send the message. To do this check, the field checkContact should be sent to true. Take into account that this extra call consumes time, so if you have a list of already available RCS phones, you can skip this step.

If checkContact is set to true and the api returns an error because this phone doesn’t allow RCS, an error 403 will be returned.

Aura line api

You can send a text message directly to the user using the aura push endpoint /aura-services/v1/aurapush/messages. All the information about the aura push endpoint could be found in the bridge swagger file:

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura KPIs uploader user guide

Guidelines including the orderly steps to use aura-kpis-uploader

1. Prepare your `CONFIG_FILE`

First, review and prepare your environment variables in order to create your CONFIG_FILE.

An example is shown below:

AURA_AUTHORIZATION_HEADER=${AURA_AUTHORIZATION_HEADER}
AURA_CHANNELS_CONFIGURATION_API_ENDPOINT=${AURA_CHANNELS_CONFIGURATION_API_ENDPOINT}
AURA_DEFAULT_LOCALE=${AURA_DEFAULT_LOCALE}
AURA_ENVIRONMENT_NAME=${AURA_ENVIRONMENT_NAME}
AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCESS_KEY=${AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCESS_KEY}
AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT=${AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT}
AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY_DESTINATION}
AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT_DESTINATION}
AURA_MICROSOFT_AZURE_STORAGE_CONTAINER_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_CONTAINER_DESTINATION}
AURA_VERSION=${AURA_VERSION}

2. Launch Aura KPIs uploader

There are two methods for launching the aura-kpis-uploader

Directly with the source code: to launch it in your local environment
As a docker container: to use it with the already generated Docker image.

2.1. Launch the tool directly with the source code

$ cd aura-kpis-uploader
$ npm install
$ export CONFIG_FILE=[PATH_TO_MY_CONFIG_FILE]
$ npm run start

2.2. Launch the tool as a docker container

2.2.1. Pull image from repository

This method needs login first.

docker pull auraregistry.azurecr.io/aura/aura-kpis-uploader

2.2.2. Run Docker container

There are two options for running the Docker container:

With .env file:

Change $VERSION accordingly, exporting it or changing the string in the commands.

If $VERSION is not present, it will use the latest default tag.

docker run --rm -e CONFIG_FILE=/opt/aura-kpis-uploader/env/config_file.env \
        -v $(pwd):/opt/aura-kpis-uploader/env \
        auraregistry.azurecr.io/aura/aura-kpis-uploader:$VERSION

With environmental variables in command:

Note that host.docker.internal only works for MACOS/Windows systems:

docker run -e AURA_AUTHORIZATION_HEADER=${AURA_AUTHORIZATION_HEADER} \
        -e AURA_CHANNELS_CONFIGURATION_API_ENDPOINT=${AURA_CHANNELS_CONFIGURATION_API_ENDPOINT} \
        -e AURA_DEFAULT_LOCALE=${AURA_DEFAULT_LOCALE} \
        -e AURA_ENVIRONMENT_NAME=${AURA_ENVIRONMENT_NAME} \
        -e AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCESS_KEY=${AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCESS_KEY} \
        -e AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT=${AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT} \
        -e AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY_DESTINATION} \
        -e AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT_DESTINATION} \
        -e AURA_MICROSOFT_AZURE_STORAGE_CONTAINER_DESTINATION=${AURA_MICROSOFT_AZURE_STORAGE_CONTAINER_DESTINATION} \
        -e AURA_VERSION=${AURA_VERSION} \
        -v ${HOST_DIRECTORY}:/opt/aura-kpis-uploader/logs \
        auraregistry.azurecr.io/aura/aura-kpis-uploader:$VERSION

3. Execution Dependencies

With the addition of the new component aura-databricks-jobs, now for Avro entities, the execution of aura-kpis-uploader depends on aura-databricks-jobs being executed correctly.

This is done to avoid duplicating KPIs when they are processed by aura-databricks-jobs, and an error has occurred.

3.1 Evaluation of conditions for execution

If avro-to-dataset-job-cli has been executed correctly, it will write a file to the default avro folder containing a date. If this file exists and the date it contains does not exceed the time set for the scheduled run in Databricks, aura-kpis-uploader-cli will run its processes.

If avro-to-dataset-job-cli has generated any error in its execution, it will generate a file in the same folder containing internally the error(s) that have occurred.

Environment variables involved:

AURA_KPIS_AVRO_DESTINATION_PATH: Default value is avro.
AURA_DATABRICKS_ERROR_FILENAME: Default value is databricks.ERROR.
AURA_DATABRICKS_EXECUTION_PERIOD: Default value is 24 hours.

The flow that Aura KPIs Uploader follows to validate if it is going to be executed is as follows:

4 Generate Reports

By default, aura-kpis-uploader generates reports if any error has occurred in the upload process.

These reports are available in the Azure Storage defined in AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT, path aura-kpis/reports/.

If you want to change the behavior and generate reports of all uploaded files or disable their generation, you can do it by changing the environment variable AURA_KPIS_REPORTS_MODE. If the value is set to all, it will generate a report for each of the processed files and if it is set to none, it will not generate any report. The default value is error.

4.1 Report upload Files

When an error occurs, the system will send an event to Prometheus to alert about the error.

 this.prometheusHandler.addSummary(
                        { 
                        metricId: PrometheusMetrics.auraKpisUploaderReportErrorSummary, 
                        start: this.startTimer 
                        },
                        { 
                        reportError: reportLink },
                        this.corr
                        );

The event will contain the metricId auraKpisUploaderReportErrorSummary, when an error occurs and a link to the report containing the error.

4.1.1 Report Model

A report will contain the following template in JSON format:

numberOfFiles: Number of files processed.
numberOfFilesSkipped: Number of files that have been skipped because they have not yet been processed.
NumberOfFilesMovedToProcessed: Number of files that have been moved to the processed folder.
numberOfFilesUploaded : Number of files that have been successfully uploaded.
NumberOfFilesDeleted: Number of files that have been deleted from the main folder.
numberOfFilesUploadValidated: Number of files that have been verified as successfully uploaded.

If errors have occurred, it will contain an errors property with the files that have failed, arranged as properties:

key: Name of the file that has failed.
step: It indicates in which phase it has failed. The possible ones are “UPLOADING”, “CHECK_IF_UPLOADED”, “MOVING_TO_PROCESSED” AND “REMOVING”.
error: Error message obtained.
corr: Associated correlator.

Example:

{
 "numberOfFiles": 43,
 "numberOfFilesSkipped": 0,
 "numberOfFilesMovedToProcessed": 41,
 "numberOfFilesUploaded": 41,
 "numberOfFilesDeleted": 41,
 "numberOfFilesUploadValidated": 41,
 "errors": {
   "BOT_da5df187-8aa9-55b7-94d6-50586bd6b0b8_CR_API_20240216T080000Z.txt": {
     "step": "UPLOADING",
     "error": "getaddrinfo ENOTFOUND aurautils-test.blob.core.windows.net",
     "corr": "ec4978ee-0021-4633-a28f-a933759d0250"
   },
   "BOT_b8efccfd-f2bd-5ef0-a19d-b2414ab94dc8_CR_API_20240215T160000Z.txt": {
     "step": "UPLOADING",
     "error": "getaddrinfo ENOTFOUND aurautils-test.blob.core.windows.net",
     "corr": "ec4978ee-0021-4633-a28f-a933759d0250"
   }
 }
}

4.2 Report Generating Avro KPIs

When an error occurs, the system will send an event to Prometheus to alert about the error.

 this.prometheusHandler.addSummary(
                        { 
                        metricId: PrometheusMetrics.auraKpisGeneratedReportErrorSummary, 
                        start: this.startTimer 
                        },
                        { 
                        reportError: reportLink },
                        this.corr
                        );

The event will contain the metricId auraKpisGeneratedReportErrorSummary, when an error occurs and a link to the report containing the error.

4.2.1 Report Model

A report will contain the following template in JSON format.

numberBlobsLoaded: Number of blobs loaded.
numberDataRowsLoaded: Number of total lines loaded from blobs.
numberDataRowsGenerated: Number of Avro registers generated.
numberEntitiesGenerated: Number of entities generated.
numberDimensionalGenerated: Number of dimensional files generated.

If errors have occurred, it will contain an errors property with the files that have failed, arranged as properties:

key: The id of the source. Example: ‘AUDIT’.
error: Error message obtained.
corr: Associated correlator.

Example:

{
 "numberBlobsLoaded": 13,
 "numberDataRowsLoaded": 0,
 "numberDataRowsGenerated": 141,
 "numberEntitiesGenerated": 2,
 "numberDimensionalGenerated": 7,
 "errors": {
   "GATEWAY": {
     "error": "Error parsing data. Field name does not exist in source",
     "corr": "ec4978ee-0021-4633-a28f-a933759d0250"
   },
   "AUDIT": {
     "error": "Error parsing data. Field id cannot be empty",
     "corr": "ec4978ee-0021-4633-a28f-a933759d0250"
   }
 }
}

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Context architecture and operation

Discover Aura Context functional architecture and its operational process

Functional architecture

Aura Context v1 functional architecture contains the following components:

Context broker & server API
Server API in Aura Context for uploading, updating and recovering context data by different Aura sub-systems.
Aura Context Service
Core module of Aura Context in charge of gathering data from the context API, uploading it into de context database and data recovery.
Aura Context cache/database
Temporary high-performance database placed inside the Aura instance that is able to storage user’s data corresponding to the user’s previous experiences or environment. Data is available in the context database for a limited period of time and it cannot be recovered once this period expires.
The key features of Aura Context database are shown below:
- 360 approach: Aura Context aims to gather all type of information from an Aura interaction, including data coming from channels.
- High-available database: real-time recovery during the user’s interaction, with no lateness.
- Temporary data storage: data available only for an established period of time.
- Data persistence in Kernel for historical data exploitation purposes.
Context Kernel persistence mechanism
First basic version of the Kernel persistence mechanism. Within a one-direction flow, context data stored in the database is sent to Kernel for an unlimited period of time. Data on Kernel can be checked or processed following the same procedure as for Aura data.

Aura Context performance

The following steps schematically shows the process carried out by Aura Context:

Context data is sent to Kernel where it is stored for an unlimited period of time.
This information can be retrieved by an external stakeholder just by calling the corresponding API.
Developers can consume data in the Aura Context database when developing a use case. For this purpose, the aura-bot dialog must call the corresponding API in order to retrieve context data and include it in the response to the user.

Aura Context operational flowchart

Before facing this section, it is recommended to read the document Aura Context components.

Considering the Aura Context components, the following flowchart shows the operational process carried out by the context:

An external component makes a request to Aura Context API (POST HTTP request) for carrying out a specific operation:
- Create: creation of a data entry in Aura Context
- Upsert: modification of a data entry in Aura Context
- Fetch: data recovery from Aura Context
The context API sends the request to Aura Context service.
The request transform converts input data into data suitable with the Aura Context global data model.
The specific operation is performed: Create / Upsert / Fetch.
Output data from the operation is converted into data compatible with the user’s data model through the response transform.
The response is sent back to the context API and provided to the external component.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Bot make-up process

The current section describes the make-up processes that take place within Aura Bot

Introduction

The make-up process in aura-bot runs by using the following command:
npm run makeup

All the processes that are executed during the aura-bot make-up are detailed in the following sections.

Environments variables for Aura Bot make-up

Mandatory variables

Name
AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY
AURA_DEFAULT_LOCALE
AURA_STATIC_RESOURCE_ENDPOINT
AURA_STATIC_RESOURCE_SAS_TOKEN
AURA_VERSION

Optional variables

These optional variables, together with their default values, are shown below. However, it can use some other optional variables, which can be checked out in the aura-bot make-up script in Github.

Name	Default value
AURA_MAKEUP_FILES_ORIGIN	blob
AURA_MAKEUP_FILES_DESTINATION	blob
AURA_AUTHORIZATION_HEADER
AURA_RESOURCES_PREFIX	’libraries'
AURA_SERVICE_ENVIRONMENT
AURA_MAKEUP_MODE	‘full’
AURA_CHANNELS_CONFIGURATION_API_ENDPOINT
AURA_CONFIGURATION_CONTAINER	‘aura-configuration’
AURA_CHANNELS_CONFIGURATION_API_ENDPOINT
AURA_CHANNELS_CONFIGURATION_BLOB	‘bot-response.json’
AURA_DIALOG_CONFIG_FILENAME	‘merged-dialog-config.json’
AURA_LOCAL_RESOURCES_PATH	’local-resources'
AURA_LOCAL_RESOURCES_PORT	3000

Load External Libraries

In this process, which is fully automated, the instance will be made-up, joining general configuration and i18n with library-specific ones.

The external libraries loaded by aura-bot are the different dialogs assigned to the use cases. This list of libraries is listed in the plugin-config.json file.

plugin-config.json

[
    "@telefonica/aura-bot-common-library",
    "@telefonica/aura-bot-disambiguation-library",
    "@telefonica/aura-bot-generic-library",
    {
        "exclude": [
            "./handover-genesys/handover-bypass-dialog",
            "./handover-genesys/handover-status-dialog"
        ],
        "packagePath": "@telefonica/aura-bot-handover-library"
    },
    "@telefonica/aura-bot-miscellaneous-library",
    "@telefonica/aura-bot-none-library",
    "@telefonica/aura-bot-onboarding-library",
    "@telefonica/aura-bot-tv-library",
    {
        "exclude": [
            "./wifi-check-connectivity-dialog",
            "./wifi-connect-to-guest-dialog",
            "./wifi-enable-disable-guest-dialog"
        ],
        "packagePath": "@telefonica/aura-bot-wifi-library"
    },
    "@telefonica/aura-bot-la-amazon",
    "@telefonica/aura-bot-la-iberia",
    "@telefonica/mi-movistar-beta",
    "@telefonica/generic-faq"
]

The make-up process is in charge of loading all these libraries and unifying the different resources they contain. Each environment contains the libraries associated with the required use cases.

Manage MongoDB Indexes

The indexes configuration file is in /settings/makeup/aura-bot-mongodb-indexes.json.

aura-bot-mongodb-indexes.json (partial)

{
  "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      },
      "aura-caches": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_item_caches",
            "keys": {
              "item": 1
            },
            "unique": true
          },
          {
            "version": 1,
            "name": "idx_ttl_caches",
            "keys": {
              "lastAccess": 1
            },
            "expireAfterSeconds": 3600
          }
        ]
      },
      "aura-context": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_aura_last_access",
            "keys": {
              "lastAccess": 1
            },
            "expireAfterSeconds": 3600
          }
        ]
      },
      "aura-external-kpi":
      .....

Once the make-up is executed, this file will be uploaded to the assigned repository [AURA-STORAGE]/aura-configuration/[AURA_VERSION]/aura-bot-mongodb-indexes.json. If this remote file exists, it has priority over the local file.

This configuration is assigned in the make-up process by means of the following model:

  const options: MakeupMongoIndexManagerOptions = {
        mongodbConfiguration: {
            AURA_MONGODB_URI: configuration.AURA_MONGODB_URI,
            AURA_MONGODB_DB_NAME: configuration.AURA_MONGODB_BOT_DATABASE,
            AURA_MONGODB_USERNAME: configuration.AURA_MONGODB_USERNAME,
            AURA_MONGODB_PASSWORD: configuration.AURA_MONGODB_PASSWORD,
            AURA_MONGODB_POOL_SIZE: configuration.AURA_MONGODB_POOL_SIZE,
            AURA_MONGODB_SSL: configuration.AURA_MONGODB_SSL
        },
        fileConfiguration: {
            containerName: 'aura-configuration',
            localPath: 'settings/makeup',
            remotePath: '',
            files: [{ name: 'aura-bot-mongodb-indexes.json', mimeType: 'application/json' }]
        },
        replaceLocalWithRemote: true,
        storageCredentials: {
            storageKey: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY,
            storageName: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
        },
        uploadFromLocalToRemote: true,
        auraVersion: configuration.AURA_VERSION,
        ignoreDownloadErrors: true,
        ignoreUploadErrors: true,
        dataBaseSuffix: configuration.AURA_ENVIRONMENT_NAME
    }

Prepare Locale Resources

Each library may contain a settings/locale folder, with one or more i18n locale files (settings/locale/<lang>.json).

These locale files will be merged by language (in case of conflict, the latest loaded library overrides the previous one), and then merged with global locale files in aura-bot/locale/<lang>.json, taking precedence the global version in case of conflict.

All keys are sorted in resulting JSON files, to increase the readability.

For these local files to be merged, it is required to expose them in the locale property when registering the plugin. This will be done within the file index.ts, as shown in the following example:

import * as libraryUtil from '@telefonica/aura-bot-utilities/lib/aura-bot-library-util';
(...)
const settingsPath = path.resolve(__dirname, '..', 'settings');
register(null, {
    my_library: {
        locale: libraryUtil.readLocaleFolder(path.resolve(settingsPath, 'locale')),
        (...)
    }
});

The language resources in aura-bot are located in /locale/:

 de-de.json
 en-gb.json
 es-es.json
 pt-br.json

When starting aura-bot, these files are loaded remotely from [AURA-STORAGE]/static-resources/[AURA_VERSION]/locale/.

In the make-up process, the language resources of each loaded external library are merged into one file per language and then uploaded to Azure Storage using uploadFile method.

File example:

{
    "common:common.error.main": [
        "Aura no está disponible en estos momentos. Por favor, inténtalo un poco más tarde"
    ],
    "common:common.goodbyes.main": [
        "¡Hasta la vista!",
        "¡Hasta pronto! Espero haber podido ayudarte"
    ],
    "common:common.greetings.main": [
        "Hola, buenas",
        "Hola, estoy aquí para ayudarte"
    ]
}

Note that all the keys should start with the name of the library followed by a colon (":"). In the bot, this library name will be appended automatically, so only the last part of the key must be used in the dialogs.

Set Environment Variables

Each library may contain .env files within the folder settings or settings/{DEV|PRE|PRO} (some vars could have a specific value per environment).

If the AURA_SERVICE_ENVIRONMENT environment variable is set, the settings/.env file will be merged with settings/<AURA_SERVICE_ENVIRONMENT>/.env (taking precedence the env-specific values in case of conflict).

Every file is optional. After that, the resulting .env file from each library will be merged together and written down in aura-bot/.env.libraries. Note that this file has the lowest precedence when loading environmental variables in aura-bot.

Multiline values are escaped in order to allow the dotenv library to successfully read the values, even though it is recommended not using them.

For these .env files to be merged, it is required to expose them in the env property when registering the plugin. This will be done within the file index.ts, as shown in the following example:

import * as libraryUtil from '@telefonica/aura-bot-utilities/lib/aura-bot-library-util';
(...)
const settingsPath = path.resolve(__dirname, '..', 'settings');
register(null, {
    my_library: {
        env: libraryUtil.readEnv(settingsPath),
        (...)
    }
});

All the environment variables of each external library are merged together with the aura-bot environment variables and assigned as environment variables to the container or containers that will be in charge of raising their corresponding Pods in Kubernetes.

File example:

MYLIBRARY_VERSION=1.2.3
MYLIBRARY_ENDPOINT=https://my-library.test/v1
Note that to avoid conflicts, the env vars specific for a library should start with the library name in uppercase followed by an underscore ("_").

Prepare Remote Channel Config

Each library may contain dialog-config.json files or dialog-config.<AURA_BOT_DEFAULT_LOCALE>.json files.

The AURA_DEFAULT_LOCALE environment variable is required while AURA_SERVICE_ENVIRONMENT is optional. If AURA_SERVICE_ENVIRONMENT is set, these 4 files will be fetched and configuration is merged (the highest in the list means more priority in case of conflict):

(1) settings/<AURA_SERVICE_ENVIRONMENT>/dialog-config.<AURA_BOT_DEFAULT_LOCALE>.json
(2) settings/<AURA_SERVICE_ENVIRONMENT>/dialog-config.json
(3) settings/dialog-config.<AURA_DEFAULT_LOCALE>.json
(4) settings/dialog-config.json

In case AURA_SERVICE_ENVIRONMENT is not set, only #3 and #4 files are fetched and merged.

After that, the resulting dialog config from each library will be merged together. Then, the config is added to every channel in the config file pointed out by AURA_CHANNEL_CONFIGURATION_ENDPOINT (except the dialogs containing an only_in string array property, that are not added to channels not present in that property) replacing dialog_libraries from each channel. Then the resulting file is uploaded to Azure, replacing the previous one.

For these files to be merged, it is required to expose them in the config property when registering the plugin. This will be done within the file index.ts, as shown in the following example:

import * as libraryUtil from '@telefonica/aura-bot-library-util';
(...)
const settingsPath = path.resolve(__dirname, '..', 'settings');
register(null, {
    my_library: {
        config: libraryUtil.readDialogConfig(settingsPath),
        (...)
    }
});

Use onlyIn property

In some cases, the dialog configuration can differ among channels for the same country. In these cases, the onlyIn property must be used in the dialog-config.<AURA_DEFAULT_LOCALE>.json file:

{
    "name": "tv",
    "authorization": {
        "purposes": "customer-self-service",
        "scopes": "subscribed-products-user-read"
    },
    "dialogs": [
        {
            "id": "tv-carousel-info",
            "suggestions": false,
            "triggerConditions": [
                {
                    "intent": "intent.carousel.info"
                },
                {
                    "intent": "intent.tv.details"
                }
            ],
            "onlyIn": [
                "movistar-plus"
            ]
        }
   ]
}

This configuration file is built by merge each channel configuration from each external library and uploaded to [AURA-STORAGE]/aura-configuration/bot-response.json using uploadStringAsBlob and/or (according to AURA_MAKEUP_FILES_DESTINATION) uploading channel information in aura-configuration-api.

bot-response.json (partial)

[
  {
    "channel_id": "45494a5b-835a-4fff-a813-b3d2be529dbe",
    "fpa_auth_purposes": "customer-self-service detect-abnormal-usage device-recommendations-v3 sim-upgrade-suggestion aura-read-insight-events identify-customer bolt-on-suggestion",
    "fpa_auth_scopes": "device-catalog:devices-read device-stock:stock-read",
    "name": "novum-mytelco",
    "nlp": {
      "enabled": true,
        "enabled": true
      }
    },
    "prefix": "nov",
    "dialogLibraries": [
      {
        "name": "generic",
        "dialogs": [
          {
            "id": "get-generic",
            "triggerConditions": [
              {
                "intent": "intent.greetings"
              }
            ]
          }
        ]
      },
      {
        "name": "bill",
        "dialogs": [
          {
            "id": "balance-check",
            "suggestions": true,
            "authorization": {
              "purposes": "customer-self-service",
              "scopes": "mobile-balance-read"
            },
            "triggerConditions": [
              {
                "intent": "intent.balance.check",
                "contextFilters": [
                  {
                    "name": "Anonymous redirect to linking",
                    "type": "type",
                    "conditions": "/type eq 'anonymous'",
                    "true": {
                      "name": "Anonymous redirect to linking",
                      "breakDialogExecution": true,
                      "breakFilterEval": true,
                      "redirectToIntent": "intent.account.linking",
                      "suggestions": false
                    }
                  },
                  {
                    "name": "user_type_multimsisdn_not_allowed",
                    "type": "user_type_filter",
                    "conditions": "/type eq 'multimsisdn'",
                    "true": {
                      "name": "user_type_not_allowed_action_true",
                      "breakDialogExecution": true,
                      "breakFilterEval": true,
                      "resource": "context-filter:multimsisdn-users-intent-not-allowed.text",
                      "suggestions": false
                    }
                  },
...

Process Resources

Each library may contain a resources folder with images or any other binary files. If present, those files are uploaded to Azure container pointed by AURA_SERVICE_ENVIRONMENT env var, within libraries/<library> virtual path.

This uploading process could last longer than the other make-up steps, so the process could throw errors after showing that the make-up process is finished (with pending uploading processes).

The following snippet shows how to use those files within the dialogs (it will take AURA_STATIC_RESOURCE_ENDPOINT and AURA_STATIC_RESOURCE_SAS_TOKEN env vars from the environment):

import * as libraryUtil from '@telefonica/aura-bot-library-util';
(...)
const wholeUrl = getResourcePath('my_library', 'icon.png');

If we need to retrieve an image with specific device resolution as coming in the imageSettings resolution field of activity channelData, we should use getImageUrl method as follows:

import { getImageUrl } from '@telefonica/aura-bot-library-util';
[...]
const wholeUrlWithResolution = getImageUrl(stepContext.context, 'my_library', 'icon.png', configuration);

In libraries, the resources path must be exposed in the resources property when registering the plugin. This will be done within the file index.ts, as shown in the following example:

register(null, {
    my_library: {
        resources: path.resolve(__dirname, '..', 'resources'),
        (...)
    }
});

In the aura-bot make-up process the resources of each external library are uploaded to Azure Storage so that they can be later consumed by them. Remote path: [AURA-STORAGE]/static-resources/libraries/[LIBRARY_NAME].

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura utilities

Description of aura-utilities

Introduction

aura-utilities is a package belonging to aura-common-utilities that includes utilities used by other Aura components.

Find more information in the Github repository: https://github.com/Telefonica/aura-common-utilities/tree/master/packages/aura-utilities/

How to install aura-utilities package

$ git clone https://github.com/Telefonica/aura-common-utilities.git

$ cd aura-common-utilities/packages/aura-utilities

How to import an utility from this package

To import an utility from the aura-utilities package, execute the following command:

import { ... } from '@telefonica/aura-utilities/lib/[*utility-name*]';

For example:

import { ... } from '@telefonica/aura-utilities/lib/aura-channel-data-handler';

Available utilities

List of utilities in the aura-utilities package:

aura-channel-data-handler utility that allows managing channelData content
aura-configuration utility for loading configuration and models related to channels
aura-crypto-adapter utility for encrypting and decrypting user tokens
file-validator utility, used by aura-file-manager to validate files.
aura-locale-manager utility for the management of text resources
aura-models utility that stores common interfaces in Aura projects
aura-mongo-handler utility, a tool for handling MongoDB database
aura-orchestrator utility for the management of text resources by aura-bot
aura-redis-handler utility, in charge of connecting and using Redis. request-utils
aura-server-common utility allows code sharing between Aura server applications
aura-storage-file-manager utility in charge of uploading or downloading remote files
aura-validate-apikey utility for the validation of APIKeys in incoming requests
aura-makeup-index-manager utility

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Manage locales for canonical phrases of intents

The aim of this document is to describe how to manage locales to include canonical phrases in intents

Introduction

Intents must have a canonical phrase to be able to disambiguate among them.

For this purpose, it is required to include canonical phrases for CLU intents in POEditor, within a section named “intent” and upload them to aura-bot deployment.

Two scenarios can arise here, distinguishing between global use cases and local ones.

Global use cases

a. Generate the locales in POEditor:

Access the POEditor global project.
Look for the specific resource of the global use case intent, that will have the format: intent:[intent_name].
Edit the text of the specific resource for the global intent including the canonical phrase for this intent.

b. Upload the locales to aura-bot deployment

The “intent” section of the global POEditor project is imported into the bot deployment by the global library:
telefonica/aura-bot-library-disambiguation
If the intent is handled by a global dialog, it must be added in the locale-changes file to be deployed after every local deployment. It must also be notified to the Global Team to add it to the global POEditor, so it can be included in the succeeding aura-bot release.

Local use cases

For local use cases (intents handled by a local dialog), OBs should include resources for the all the intents’ canonical phrases. Aura Global recommends to use local POEditor, although this is not mandatory. The main request for those local resources is to be included in the library in a format compatible with the bot, as explained below.

a. Generate the locales in POEditor:

Access the POEditor local project
Create the specific resource with the mandatory format: intent:[intent_name].
For example, intent:intent.billing.check
Edit the text of the resource with the canonical phrase for this intent

b. Upload the locales to aura-bot deployment

To deploy these resources in the environment, it is required to upload them only from a library. Therefore, the ideal process would be either to use a library that is always deployed in the environment or to create an ad-hoc library to manage common processes and load into this library the section “intent” of the local POEditor project.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Guidelines for the connection of a skill to Aura Root

Detailed process for the connection of a skill to Aura Root

Introduction

The process for the connection of a skill to Aura Root is common for the three types of skills defined before.

⚠️ It is only important to take into account that, for third-party bots, constructors must previously develop a third-party adapter to communicate the bot with Aura Root (that is, to make it compatible with Microsoft Bot Framework protocol). After doing that, the connection of the bot with Aura Root follows the same common steps as for other types of skills.

Prerequisites

The following previous tasks are required for the further connection of a skill with Aura Root:

We have a skill already developed and published
There is a channel routed by Aura Root to this skill

1. Register a skill in Aura

In order to activate a skill in Aura, make a POST request to the skills module of aura-configuration-api through the corresponding swagger.

https://<environment>.auracognitive.com/aura-services/v2/configuration/skills

The fields in the request are shown below:

id: Unique identifier of the skill. It can be generated with UUID Generator Tool by OB operator.
name: name of the skill by OB operator.
channels: array of strings including the name of the channel(s) associated with the skill.
appId: Microsoft appId
skillEndpoint: endpoint where the skill is published
external: Boolean value indicating if the skill is deployed in the same environment as aura-groot or not.
- If true, the skill is deployed in a different environment.
- If false or this parameter is not existing, then the skill is deployed in the same environment.

ℹ️ NOTE: Both the id and the name of the skill must be assigned by the OB operator, and they must ensure that they are unique in order to avoid collisions.

Check the following example of a request body:

{
    "id": "544bf5c0-9f31-45e3-9f08-89230315e520",
    "name": "skill-name",
    "channels": [
        "channel-name"
    ],
    "appId": "ms-azure-app-id",
    "skillEndpoint": "http://url-to-skill-bot/api/messages",
    "external": true //Only present if the skill is not in the same environment of Aura Groot
}

2. Make changes available in Aura Groot

In order to update Aura Groot configuration with the modifications carried out, at this stage it is required to restart this component. Depending on the enviroment, there are two possible scenarios.

2.1. Connect to skill in a local environment

In these cases, it only will be neccessary to restart aura-groot component in local enviroment to connect to new skill. The instance can be started using the following command for running aura-groot in local environment: npm start

2.2. Connect to skill in a production environment

In Aura production environments, it will not be necessary to restart the component to update the skills configuration. This connection is done automatically through the config-watcher.

The config-watcher runs periodically (every 5 minutes) and, when it detects that the configuration has been modified in aura-configuration-api, it will automatically restart the pods.

Alternative: Use the /refresh endpoint

⚠️ Use this manual process only if you cannot wait for the automatic execution of the config-watcher

In order to connect the skill in production environment in a manual way (only in the above-mentioned scenario), the /refresh endpoint of aura-groot allows the update of the new configuration without restarting the component.

Two different scenarios can arise here:

Update all configuration parameters

Make a port-forward to both aura-groot pods (one request per pod)

kubectl port-forward aura-groot-#### -n <namespace> 8080:8080

The request to the endpoint with post-forward is shown below:

curl --location --request POST 'localhost:8080/refresh'

Update ONLY skills/channels information

If we only want to update skills and/or channels information, send the parameters in the message body:

    curl --location --request POST 'localhost:8080/refresh' \
    --header 'Content-Type: application/json' \
    --data-raw '{
        "changes": ["skills", "channels"] // use "skills" and/or "channels" or neither of them
    }'

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Jenkins pipelines definition

Understand how the Continuous Integration system works in Aura system in detail

Introduction

During the refactor phase, the way to declare the configuration of the different repositories has been redefined by trying to simplify the delivery/pipelines/Jenkinsfile file statement.

The main objective of the refactor is “to simplify”. This is attempted to achieve as follows:

All repositories must execute the same stages (predefined).
Repositories with a specific language should execute the same tasks in stages.
Scripts to execute tasks should be common and defined in jenkins-libraries-aura repository to be reused.

General structure project

The files associated with the continuous integration system are found in the delivery folder, which has the following structure:

delivery/
├── docker                          # Folder to Dockerfile
├── pipelines/Jenkinsfile.aura      # Jenkinsfile
└── scripts                         # Utility script for pipelines

Scripts added to the delivery/scripts folder should be specific tasks for this repository. Otherwise, the scripts should be in the resources/org/aura/script folder and that can be reused.

Add script to delivery/scripts only if it is completely necessary.

Jenkinsfile example

@Library(['aura']) _

auraPipeline {
    language = 'node'
}

The previous definition is sufficient for a nodeJS type repository to execute the default continuous integration tasks defined for an Aura nodejs project.

Definition of pipelines

Common libraries

Although it is possible to directly define the tasks to be executed with groovy here, there are a number of predefined scripts to run common tasks that can be used by including the aura and devops libraries:

@Library(['aura','devops']) _

Pipeline configuration

auraPipeline {
    slave,          // Slave where pipeline will be executed. Default: 'aura-bot-platform-14'
    nature,         // Pipeline nature: Default: 'standard' (the refactor nature)
    language,       // Language used by the pipeline
    artifacts,      // List of artifacts that need to be generated.
    stages,         // List of stages. Default: default stages
    modifiedStages, // List of modified stages.
    options,        // Pipeline options.
    postJobs        // Post execution jobs.
}

slave property

Slave property indicates the slave where Jenkins stages will be executed.

If a slave is not specified explicitly, aura-bot-platform-14 will be finally used.

nature property

The nature property indicates the definition of pipeline that will be executed on the list defined in ‘jenkins-libraries-aura’ project.

The simplification in the definition of pipelines has reduced the list to a single generic pipeline defined as standard.

It is still possible to execute existing pipelines, previous to refactor. Simply, the value of nature should indicate the pipeline to be executed.

This is deprecated in favor of the new standard pipeline.

language property

The language property helps the standard pipeline to execute the appropriate tasks depending on the language of the repository itself.

The system is prepared to handle repositories whose source code is written in a single main language.

artifacts property

List of artifacts that will be generated.

stages property

Although the standard pipeline defines a series of default stages depending on the type of ‘push’ that is done on the repository, this field allows you to define the stages manually.

modifiedStages property

In some cases, it is necessary to modify the configuration of some default stage in standard pipeline, without defining all the stages again (as we would do on the stages property).

For example, we can modify the test stage for the ‘pr’ type:

modifiedStages = [
    'pr': [
        new Stage(name: 'test', description: 'Test', options: [ skipLint: true] )
    ]
]

or modify the test stages for all types (pr, release, etc):

modifiedStages = [
    '*': [
        new Stage(name: 'test', description: 'Test', options: [ skipLint: true] )
    ]
]

options property

The following options are available:

Option	Description	type	Default
deleteBuildOnSkip	Delete build on skip	boolean	true
uploadGeneratedArtifacts	Upload generated artifacts from ‘artifacts’ directory	boolean	false

postJobs property

Jenkins jobs that will be executed once the current job ends.

Defining artifacts

The artifacts are components that we can generate during the execution of the pipeline. All artifacts must extend from the Artifact class and depending on its type will generate one component or another.

Currently, there are only two types of components (although it can grow in the future): AuraComponent and AuraLibrary.

AuraComponent

A type component AuraComponent is used to generate a Docker image with the following configuration options:

Option	Description	type	Default
name	Component name	String
version	Version for the docker image	String
envVersionVar	Environment version variable (as `AURA_BOT_VERSION`)	String
scripts	List of names of configuration scripts	List
initScripts	List of names of initialization scripts	List
buildArguments	Docker build arguments	List
dockerImageName	Docker image name	String
dockerFile	Docker file name	String	‘Dockerfile’
dockerPromotionTag	Docker promotion tag	String	’latest’

Example:

    artifacts = [
        new AuraComponent(
            name: "aura-bot", 
            version: "\$BOT_UC_VERSION", 
            dockerImageName: "aura/aura-bot-uc", 
            dockerFile: "Dockerfile", 
            scripts: ["librariesListFile.sh", "cfBotPlatformVersion.sh"], 
            buildArguments: ["BOT_BASE_VERSION=\$BOT_BASE_VERSION", "UC_VERSION=\$UC_VERSION", "UC_REVISION=\$PRODUCT_REVISION"]),
    ]

AuraLibrary

A type component AuraLibrary is used in repositories containing several libraries (multi-repository). In this way, it is possible to execute the pipeline for each of the libraries defined in the list of components.

If a multi-repository follows the structure of adding each library within the “packages” directory, the stages in standard pipeline are able to automatically get the library list, so in most cases it is not necessary to define configuration by hand.

In case you need to define the library list, the following options are available:

Option	Description	type	Default
name	Component name	String
path	Component path (Ex. packages/my-library)	String
versionStrategy	Version strategy: distag, old	String	distag

Example:

    artifacts = [
        new AuraLibrary( name: "aura-json-schema-generator", path: "packages/aura-json-schema-generator")
    ]

How to define my own stages?

The standard pipeline defines the following stages by default:

// Default stages
'default': [
    'pr'     : [
        new Stage(name: 'decrypt', description: 'Decrypt'),
        new Stage(name: 'initialization', description: 'Initialization'),
        new Stage(name: 'build', description: 'Build'),
        new Stage(name: 'test', description: 'Test')
    ],
    'release': [
        new Stage(name: 'checkSkip', description: 'Checkout skip'),
        new Stage(name: 'decrypt', description: 'Decrypt'),
        new Stage(name: 'initialization', description: 'Initialization'),
        new Stage(name: 'build', description: 'Build'),
        new Stage(name: 'test', description: 'Test'),
        new Stage(name: 'versioning', description: 'Versioning'),
        new Stage(name: 'publish', description: 'Publish'),
        new Stage(name: 'promote', description: 'Promote'),
        new Stage(name: 'deploy', description: 'Deploy')
    ]
]

Although the standard pipeline supplies the previous list of stages by default, it is possible to define stages manually, indicating in the repository that stages will be executed for each type.

There are two different ways to do this:

Modify or add stages on the standard pipeline. For this you must use the modifiedStages property. If a stage is defined with the name of an existing one, it is becoming overwritten. In case the added stage has a name different from the existing default stage, the new stage will be added in the execution.
Refine completely the list of stages to be executed. As indicated above in the options, the stages property allows you to define the list of stages that will be executed.

Example to execute only the test stage in the ‘pr’ type:

stages = [
    'pr': [
        new Stage(name: 'test', description: 'Test')
    ]
]

What tasks are executed for each stages?

Each Stage executes a series of task based on the value of the language property.

Node

Stage	Description
checkSkip*	Perform a check to know if it can do skip of the build.
decrypt*	Decrypt files that need it.
initialization	Gets versions for AuraComponent type artifacts.
build	Run `node/build.sh` script for all `Library` type components (the scripts can get libraries automatically).
test	Run `node/test.sh` script for all `Library` type components (the scripts can get libraries automatically). After execution, reports are generated for: Test, Coverage and LiNT.
versioning	Run `node/versioning.sh` script for all `Library` type components (the scripts can get libraries automatically).
publish	If the `onlyPack` option is added, the `npmPack.sh` script will be executed. Otherwise, the `publish.sh` script will be executed.
promote*	For each `AuraComponent` type artifact performs a docker `tag` and `push` command
deploy*	For each `AuraComponent` type artifact performs a deployment for the component

The value * at the end of stage’s name indicates that it is a default stage and it has not been modified for the node language.

Scripts used in the execution process for the node language:

node
├── build.sh        # Execute "npm install".
├── npmPack.sh      # Execute "npm install", "npm pack" and move the generated packages to the _artifacts_ folder.
├── publish.sh      # Check if it is not published and runs "npm install" and "npm publish".
├── test.sh         # Execute "npm run coverage-jenkins" and "npm run lint-jenkins".
└── versioning.sh   # Detects changes in the library to increase version (only if publishConfig exists in package.json)

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura make-up processes

The current section describes the make-up processes that take place within Aura

Introduction

Make-up is a set of operations to prepare an environment once a module has been deployed, but before it starts. There is a different make-up job per module, that executes the operations needed before the module starts. The operations that a make-up process can perform are the following, although not all modules have to perform all these tasks.

The current document includes general definitions needed to understand this process.
The make-up specific processes for each module are specified in its corresponding document:
Learn how to manage the indexes of a MongoDB database in the make-up index manager

General definitions

Load External Libraries

This process is in charge of loading external modules, called libraries, which contain their own resources, locale, environment variables, code.

Manage MongoDB Indexes

Indexes in MongoDB are managed by a module called Make-up Index Manager documentation.

It relies on a versioned index configuration file to apply the indexes. Only those indexes whose version has not been applied before will be applied. The configuration file can be loaded from a remote repository. By default, all components with MongoDB access have one index configuration file.

There is a tool within each module called makeup-cli to run the make-up process as a stand-alone task.

Prepare Locale Resources

This process is responsible for collecting all the language resources and uploading them to a remote repository, so that they can be changed on the fly if necessary.

If external libraries have been loaded, this process unifies the language resources. See Locale Manager Documentation.

Set Environment Variables

This process is executed when the module loads external libraries that contain its own environment variables, unifying all these environment variables in a single file.

Prepare Remote Channel Config

It is responsible for unifying the different configurations assigned by each external library to the channels.

Process Resources

This process manages the different resources of each external library and promotes them so that they are accessible when the main program is running.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

NLP as a Service operational workflow

ATRIA technical operational flow corresponding to the operation of the NLP as a Service capability

Operational flowchart

The sequence diagram of the process executed by the NLP Apps capability is shown below:

@startuml
title NLP resolution API diagram
participant Application
participant Kernel #1add4d
participant AuraGatewayApi #76bbe7
Application -> Kernel: Create two-legged token with scope aura-ai-services:nlp-messaging:write
Note right of Kernel: this token needs refreshing
Kernel -> Application: Response two-legged token
Application -> Kernel: Request to aura-aiservices/nlp/query with token
Kernel -> AuraGatewayApi: Request to aiservices/nlp/query with token-info header
AuraGatewayApi -> AuraGatewayApi: Validate request
AuraGatewayApi -> AuraNLPApp: Request recognition
AuraGatewayApi -> AuraGatewayApi: generate response
AuraGatewayApi -> Kernel: response 200 and message
Kernel -> Application: response 200 and message
@enduml

NLP Apps operational sequence diagram

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA Model Gateway operational overview

Overview of the atria-model-gateway operation

Operational workflow

The operational flow between an application (for the communication with aura-gateway-apì), atria-model-gateway, atria-rag-server and atria-rag-generate-db is schematically shown in the following figure:

Application
- Constructors must configure an application for a channel, skill or service to communicate with aura-gateway-api.
- In the application, the constructor must set the access grants for this application and all the presets that this application can use, from the ones configured in atria-model-gateway.
atria-model-gateway It contains:
- The different accesses that are defined here for each preset.
- The available presets. Each of them is associated to an AI model with specific parameters.
- The available AI models.
atria-rag-server
- When using RAG (Retrieval Augmented Generation), atria-rag-server is in charge of managing the requests made to the RAG model.
- The available projects that contain information required for the execution of the RAG pipeline are included here.
atria-rag-generate-db
- atria-rag-generate-db is in charge of feeding the databases the RAG works with.
- The available projects that contain the data required for reading the information sources and feed the databases are included here.

Configuration

atria-model-gateway includes a default configuration. Constructors can use it as is or they can modify it to be adapted to their requirements or business models: Go to document ATRIA configuration.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA RAG Server operational overview

Overview of the atria-rag-server operation

Operational workflow

The operational flow between an application (for the communication with aura-gateway-api), atria-model-gateway, atria-rag-server and atria-rag-generate-db is schematically shown in the document atria-model-gateway: operational flow.

Configuration

atria-rag-server includes a default configuration. Constructors can use it as is or they can modify it to be adapted to their requirements or business models: Go to document ATRIA configuration.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura QA Tool execution guide

Guidelines for the configuration and execution of the QA global test set (QA Tool)

Configure the QA Tool

Four main steps are required for the QA Tool configuration, which are described in the following sections.

Test properties file encryption

Configuration of environment credentials

For the configuration of the QA Tool, certain credentials are required, which are included in a JSON file. Ask for this file to the team that carries out the deployment: Global Deployment Team or OB’s Local Deployment Team.

⚠️ The credentials file is confidential. If the Local QA Team needs to share it through GitHub, they can use git-crypt for file encryption, as a suggestion.
Unencrypt the credentials file, whose name is:
[country_code]-[env]_info.json
Otherwise, an error message will appear: “No JSON object could be decoded”.
Place the file in the following folder:
~/[project_folder]/aura-tests/acceptance/settings/[country_code]/
Where:
- [country_code]: code of the corresponding country br, de, es, uk

Configuration of Kubernetes

Ask the corresponding Deployment Team for the kubernetes config file: [env].yml
Unencrypt the file. Otherwise, an error message will be shown:
“‘utf8’ codec can’t decode byte #xee: invalid continuation byte”
Place the unencrypted file in the following path:
~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[env].yml

ℹ️ After installing an Aura platform release, you will find these two files needed for running the QATool in the output_install folder:

Once infrastructure is created, the kubeconfig file is generated.
Once the full installation is finished, a [country_code]-[environment]_info.json file is found.

Please, check the Aura Deployment documentation for further details:

Users’ configuration

For the configuration of users, create a new file in the following path: ~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[country_code]-[environment]-users.json

It is important to follow the above mentioned syntax: [country_code]-[environment], where:

[country_code]: code of the corresponding country: br, de, es, uk
[environment]: environment name located in the properties file.

For example, for UK: (uk-dev-local-properties.json):

"environment": {
  "name": "uk-dev-local"
}

For the previous example, the path and file should be:
~/[project_folder]/aura-tests/acceptance/settings/uk/uk-dev-local-users.json

Afterwards, the file must be filled in with the different users’ configuration.

The detailed procedure is included in the document Configuration of users’ data.

This JSON file must include two differentiated sections:

users_definition: definition of the different type of users and their associated parameters: type, msisdn, userid, subscription, etc.
user: different use cases attached to the users defined in the previous section.

An extract of this file for UK is shown below: uk-pre-users.json

Extract of `uk-pre-users.json` file

"users_definition": {
    "user1": {
       "subscription_type": "prepaid",
       "user_type": "monomsisdn",
       "msisdn": "+44xxxxxxxx",
       "userid": "42058633",
       "uid": "325851",
       "email": user1@GMAIL.COM,
       “password”: “****”
    },
    "user2": {
       "subscription_type": "postpaid",
        "user_type": "monomsisdn",
       "msisdn": "+ +44xxxxxxxx ",
        "userid": "126529396",
        "uid": "509652361",
       "email": user2@GMAIL.COM
       “password”: “****
    },
"users": {
"default": "user1",
"common":{
     "prepaid":"user1",
     "postpaid":"user2"
       },
       "data_usage":{
            "prepaid_monomsisdn_single":"user1",
            "prepaid_monomsisdn_multiple":"",
            "postpaid_monomsisdn_single":"user2",
            "prepaid_monomsisdn_multiple":"",
            "prepaid_multimsisdn_single":"",
            "postpaid_ multimsisdn _multiple":"",
            ….
       },
"billing":{
            "prepaid_one_bill":"user1",
            "postpaid_no_bills":"user2",
            ….
       },
"bundle":{
...
}

Moreover, some examples are included in the Github repository for the Local QA Teams that can be checked:
~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[country_code]-[environment]-users.json

The mandatory authorization_id is supported by the QA Tool. This parameter is included in the properties file and can have the values optional or mandatory. The default value for authorization_id is optional.

"4p": {
  "authorization_id": "mandatory"
}

There are three different ways through which the user can authenticate:

MSISDN
Uid + password
Email + password

Detailed information can be found in Configuration of users’ data.

Input yaml resources and translation of input sentences for each use case

The ~/[project_folder]/aura-tests/acceptance/resources/language/ path, contains yaml files with the texts of the resources used in the tests, depending on the configured language.

Each yaml file will contain a different section for each [language_code]: es-es, en-gb, pt-bror de-de. See the example below.

At this stage, it is required to check these resources (statements) and update them in case it is necessary.

As an example, for the data_usage resource, the file questions_novum.yaml placed in the above mentioned path contains the label for the country and the texts for each language:

data_usage:
  question:
    en-gb: why do i experience slower speed when i browse?
    pt-br: Quantos dados celulares tenho disponíveis?
    de-de: Zeig mir meinen Verbrauch vom Datenvolumen
    es-es: Consumo de datos actual

Find below two examples where this file should be updated:

Test failure with result: “I can’t understand” or similar. Check the text inside the yaml file and update it if it is not appropriate for the specific use case.
Test failure with result: “es-es do not exist”. This means that the label for the country does not exist in the yaml file. Add the label and text for that resource.

Generate and export POEditor resources

The expected answers for a specific use case provided by aura-bot are generated in POEditor (both aura-bot resources and its associated texts).

At this stage, you should follow these steps:

Export from POEditor the JSON file containing resources and texts.
- Ask the Aura Platform Team or Delivery Team for the file exported from POEditor containing the above-mentioned resources and texts. However, if the OB has admin credentials, the file can be directly downloaded from POEditor.
- Select the “Export” option in the POEditor project.

Select the JSON icon and press “Export”.

Rename this file as poeditor_terms.json and put it in the following path: ~/[project_folder]/aura-tests/acceptance/resources/poeditor/poeditor_terms[language_code].json_
Where [language_code] can be: es-es, en-gb, pt-br, de-de.

If you need to modify these resources or create new ones, do it directly in the JSON file.

An example of POEditor resource in poeditor_terms.json file is shown below:

   {
        ... 
    },     
    {
       "term": "Currently you do not have data services",
       "definition": "Currently you do not have data services",
       "context": "data_usage",
       "term_plural": "",
       "reference": "services:services.usage.noData",
       "comment": ""
    },
    {
        ... 
    }

Execute the QA Tool

The current section includes the stages for the execution of the QA Tool from DEV-LOCAL, PRE and PRO environments.

⚠️ For the execution of tests, it is required to activate VPN full.

The following figure schematically shows this process for the execution of the QA test set:

Set and check global variables

Environment variables

Firstly, it is required to set ENV as global variable. The format depends on the specific environment:

For DEV-LOCAL environments: [country_code]-dev-local-[channel]
For PRE environments: [country_code]-pre-[channel]
For PRO environments: [country_code]-pro

Where:

[country_code]: code of the corresponding country: br, de, es, uk.

For setting the ENV variable within the activated virtualenv, execute the following command:

$ export ENV=<country_code>-<environment>
For example, for Brazil and del DEV-LOCAL environment: 
$ export ENV=br-dev-local

Properties file

The properties.json file is located in the following paths, depending on the environment.

DEV-LOCAL environments:
~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[country_code]-dev-local-[channel]-properties.json
PRE environments: ~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[country_code]-pre-[channel]-properties.json
PRO environments:
~/[project_folder]/aura-tests/acceptance/settings/[country_code]/[country_code]-pro-[channel]-properties.json

⚠️ Local QA Teams should not modify this file.

Execute QA Tool smoke tests

Remember that smoke tests are a sub-set of tests from the QA Tool that can be executed in PRE / PRO environments

Follow the instructions below for launching specific smoke tests.

$ cd <project_folder>/aura-tests
$ ./acceptance/scripts/run_tests_ob.sh -f <features> -t <feature_tag> -e ‘-D behave_additional_tags=@smoke’

Where:

-f [features]: parameter for the execution of an individual or a specific set of features. This set can be specified using the relative path to the folder that contains the desired feature files.
For example:
- -f features/end_to_end/novum/general
The features are allocated in this folder:
~/[project_folder]/aura-tests/acceptance/features/
-t [feature_tag]: optional parameter that can have different values for several subsets of tests. The list of current allowed values is:
- -t bugs: to execute the tests about bugs.

Some examples are shown below:

Execution of smoke test cases for data_usage feature:

./acceptance/scripts/run_tests_ob.sh -f features/end_to_end/novum/simplify/data_usage.feature -e ‘-D behave_additional_tags=@smoke’

⚠️ Check if the _output folder is not previously created. In the opposite case, it is necessary to ensure that this folder has the correct permissions:

$ ls -lrth <project_folder>/aura-tests/acceptance | grep _output
drwxr-xr-x  25 my_user  staff   800B 30 ene 13:30 _output
If the folder is returned in the previous command, set the correct permissions:
$ chmod –R 755 <project_folder>/aura-tests/acceptance/_output

Execute QA Tool end-to-end tests

Remember that E2E tests include a complete QA Tool test set and are executed in `DEV-LOCAL` environment.

For the end-to-end test execution, launch the following commands:

$ cd <project_folder>/aura-tests
$ ./acceptance/scripts/run_tests_ob.sh -f [path to feature folder or file]

Where:

-f [features]: parameter for the execution of an individual or a specific set of features. This set can be specified using the relative path to the folder that contains the desired feature files.
For example:
- -f features/end_to_end/novum/general

The features are allocated in this folder:
~/[project_folder]/aura-tests/acceptance/features/

Each feature file can be launched alone using the its relative path. For example:

-f features/end_to_end/novum/general/alfred.feature

Different examples are shown below:

Execution of end-to-end tests for Novum channel:
~/[project_folder]/aura-tests/acceptance/scripts/run_tests_ob.sh -f features/end_to_end/novum
Execution of data_usage feature:
~/[project_folder]/aura-tests/acceptance/scripts/run_tests_ob.sh -f features/end_to_end/novum/simplify/data_usage.feature

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

User authentication

Basic flows for users authentication in Aura

Non-integrated channels

For this kind of channels, the users always start as authenticated. The channel is responsible for authenticating the user in the OB and Kernel and for generating the auraId needed to prepare a valid request to Aura.

Further information about non-integrated channels can be found in Channels Authentication: non-integrated authentication.

This diagram must be executed just before sending messages to Aura for authenticated users.

⚠️ The request from Channel to IDP is not fully explained in the diagram. Follow Kernel documentation for a deep dive on how it works.

@startuml
title: Users authentication flow for non-integrated channels

    participant Channel #bdf492
    participant AuthenticationApi #FFFF99
    participant IdP #99FFFF
    participant KernelAuthServer #99FFFF
    participant KernelAuraServicesApi #99FFFF

    Channel -> IdP: POST /authorize
    IdP -> Channel: 200 OK {UserAuthenticationContext}
    Channel -> KernelAuthServer: POST /token
    Note over Channel,KernelAuthServer: Here a 3-legged accessToken is requested
    KernelAuthServer -> Channel: {token}
    Channel -> KernelAuraServicesApi: GET /users/aura-id
    KernelAuraServicesApi -> AuthenticationApi: GET /aura-services/v1/users/aura-id
    AuthenticationApi -> KernelAuraServicesApi: 200 OK {AuraUser}
    KernelAuraServicesApi -> Channel: 200 OK {AuraUser}
    Note over KernelAuraServicesApi,Channel: AuraUser contains the auraId needed to fulfil the requests to Aura.
@enduml

Integrated or federated channels

For this kind of channels, the users always start as anonymous and they can consume some generic questions use cases, those that do not need knowing who the user is to be resolved, such as FAQs or small talk use cases.

Once the user requests one use case that needs knowing her identity, then the authentication flow is launched by a dialog available in aura-bot. The auraId, in this case, is decided by the channel. Usually, its own user identifier is used. For instance, in the case of WhatsApp or Facebook, their own users identifier are received and used as auraId.

Further information about integrated channels can be found in Channels Authentication: integrated authentication.

This diagram substitutes the Specific functional Dialog step in the diagram New Direct Line message from anonymous user, assuming that the user has requested an authenticated use case. Not all the steps of this diagram have been included again in the sake of clarity of the diagram.

User authentication by redirection

Find further details about how this mechanism works in Kernel here.

@startuml
title: Users authentication flow for integrated channels with URL redirection

    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant AuraBridge #1add4d
    participant IdP #99FFFF
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF

    AuraBot -> AuraBot: Executing a user message that raises a dialog that needs authentication
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: ValidateAuthenticationForDialog
    AuraBot -> AuraBot: AuthenticationDialog
    AuraBot -> IdP: OPEN in webserver /authorize?state&redirectUri
    Note over AuraBot,IdP: At this moment, a web page with the login form is open
    IdP -> KernelAuthServer: Authentication status
    Note over KernelAuthServer,AuthenticationApi: In Aura, the redirectUri points to our AuthenticationApi
    KernelAuthServer -> AuthenticationApi: POST /aura-services/v1/users/auraid/integrated?code&state
    AuthenticationApi -> AuthenticationApi: validate(state)
    AuthenticationApi -> KernelAuthServer: POST /token {code}
    KernelAuthServer -> AuthenticationApi: 200 OK {token}
    AuthenticationApi -> KernelAuthServer: POST /introspect {token}
    KernelAuthServer -> AuthenticationApi: 200 OK {plainToken}
    AuthenticationApi -> AuthenticationApi: store(AuraUser)
    AuthenticationApi -> KernelAuthServer: 200 OK
    AuthenticationApi -> AuraBridge: sendAsyncCallback(AuraUser)
    AuraBridge -> AuraGroot: Send {UserCreatedActivity}
    AuraBridge -> AuthenticationApi: 200 OK
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {UserCreatedActivity}
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Middlewares
    Note right of AuraBot: KPI entities are stored during Middlewares execution in local memory.\nEvery 2 minutes and before closing a POD, they are written in Azure Storage.
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: ValidateAuthenticationForDialog
    AuraBot -> AuraBot: Execute Specific functional Dialog
    AuraBot -> AuraGroot: Send {responseActivity}
    AuraGroot -> AuraBot: 200 OK

User authentication using WhatsApp

Access these documents for further detail:

WhatsApp LoA2 authentication

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Agent AI operational workflow

ATRIA technical operational flow corresponding to the operation of the Agents AI capability

Operational flowchart

The sequence diagram of the process executed by the agents AI capability is shown below:

@startuml
title Agent API diagram
participant Application
participant Kernel #1add4d
participant AuraGatewayApi #76bbe7
participant AgentsManager #0796f5
participant MongoDeviceRecommender #11f5cf
participant AtriaModelGateway #f58e11
participant AzureOpenAI #9476e7
Application -> Kernel: Create two-legged token with scope aura-ai-services:agents-messaging:write
Note right of Kernel: this token needs refreshing
Kernel -> Application: Response two-legged token
Application -> Kernel: Request to aura-aiservices/agents/messages with token and correlatorId (x-correlator)
Kernel -> AuraGatewayApi: Request to aiservices/agents/messages with token-info header and correlatorId
AuraGatewayApi -> AuraGatewayApi: Validate request
AuraGatewayApi -> AgentsManager: Send Request to an agent
AgentsManager -> AgentsManager: Check if the context exists && retrieves it
AgentsManager -> AgentsManager: routing to the agents
AgentsManager -> MongoDeviceRecommender: Send Request to an agent with the context
MongoDeviceRecommender -> MongoDeviceRecommender: process the Request
group Agents process
  loop XX times
    MongoDeviceRecommender -> AtriaModelGateway: Send prompt to atria-model-gateway
    AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
    AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
    AtriaModelGateway -> MongoDeviceRecommender: Response prompt
    MongoDeviceRecommender -> MongoDeviceRecommender: Analyze the response
  end
end
MongoDeviceRecommender -> AgentsManager: response 200 and message
AgentsManager -> AgentsManager: Store the context
AgentsManager --> AuraGatewayApi: response 200 and message
AuraGatewayApi -> AuraGatewayApi: process response
AuraGatewayApi -> AuraGatewayApi: generate response
AuraGatewayApi -> Kernel: response 200 and message
Kernel -> Application: response 200 and message
@enduml

Agents AI operational sequence diagram

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Bridge make-up process

The current section describes the make-up processes that take place within Aura Bridge

Environment variables for Aura bridge make-up

Mandatory environment variables

AURA_ENVIRONMENT_NAME
AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY
AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
AURA_MONGODB_PASSWORD
AURA_MONGODB_URI
AURA_MONGODB_USERNAME
AURA_VERSION

Optional environment variables

These optional variables, together with their default values, are shown below.

AURA_LOCALE_FOLDER                      # Default: ./locale
AURA_LOCALE_REMOTE_CONTAINER            # Default: 'static-resources
AURA_LOCALE_REMOTE_CONTAINER_PREFIX     # Default: aura-bridge/locale
AURA_MAKEUP_MODE                        # Default: full
AURA_MICROSOFT_AZURE_STORAGE_CONFIGURATION_CONTAINER  # Default: aura-configuration
AURA_MONGODB_POOL_SIZE                  # Default: 60
AURA_MONGODB_SSL                        # Default: false
AURA_SWAGGER_LOCAL_CORE_PATH            # Default: swagger-core.yaml
AURA_SWAGGER_LOCAL_PATH                 # Default: swagger.yaml
AURA_SWAGGER_REMOTE_CONTAINER_PREFIX    # Default: swagger
BRIDGE_MONGODB_DATABASE_CACHE           # Default: aura-bridge

Manage MongoDB Indexes

In this task, the make-up is responsible for creating the necessary indexes in the MongoDB database. These indexes will only be created if the AURA_MAKEUP_MODE variable is configured to “full”.

The indexes configuration file is in /settings/makeup/aura-bridge-mongodb-indexes.json. An example of this file is shown below.

{
    "version":2.3,
    "databases": {
        "aura-bridge-caches": {
            "directline-cache": {
                "version": 1,
                "indexes": [
                    {
                        "version": 1,
                        "name": "idx_item_caches",
                        "keys": {
                            "item": 1
                        },
                        "unique": true
                    },
                    {
                        "version": 1,
                        "name": "idx_ttl_caches",
                        "keys": {
                            "lastAccess": 1
                        },
                        "expireAfterSeconds": 3600
                    }
                ]
            },
            "dev-behavior-cache": {
                "version": 2,
                "indexes": [
                    {
                        "version": 2,
                        "name": "idx_ttl_caches",
                        "keys": {
                            "lastAccess": 1
                        },
                        "expireAfterSeconds": 3600
                    }
                ]
            },
            "bridge-message-queue": {
                "version": 2.3,
                "indexes": [
                    {
                        "version": 2.2,
                        "name": "idx_ttl_caches",
                        "keys": {
                            "expiresAt": 1
                        },
                        "expireAfterSeconds": 0,
                        "force": true
                    },
                    {
                        "version": 2.2,
                        "name": "idx_queue_search",
                        "keys": {
                            "conversationId": 1,
                            "requestId": 1
                        },
                        "force": true,
                        "unique": false
                    },
                    {
                        "version": 2.2,
                        "name": "idx_first_message",
                        "keys": {
                            "conversationId": 1,
                            "requestTimestamp": 1,
                            "responseTimestamp": 1
                        },
                        "unique": false,
                        "force": true
                    },
                    {
                        "version": 2.2,
                        "name": "idx_ack_find",
                        "keys": {
                            "responseId": 1
                        },
                        "unique": false,
                        "force": true
                    },
                    {
                        "version": 2.3,
                        "name": "idx_ack_find_async_id",
                        "keys": {
                            "asyncResponseId": 1
                        },
                        "unique": false,
                        "force": true
                    }
                ]
            }
        }
    }
}

Once the make-up is executed, this file will be uploaded to the assigned repository [AURA-STORAGE]/aura-configuration/[AURA_VERSION]/aura-bridge-mongodb-indexes.json. If this remote file exists, it has priority over the local file.

This configuration is assigned in the make-up process by means of the following model:

    const options: MakeupMongoIndexManagerOptions = {
        mongodbConfiguration: {
            AURA_MONGODB_URI: configuration.AURA_MONGODB_URI,
            AURA_MONGODB_DB_NAME: configuration.BRIDGE_MONGODB_DATABASE_CACHE,
            AURA_MONGODB_USERNAME: configuration.AURA_MONGODB_USERNAME,
            AURA_MONGODB_PASSWORD: configuration.AURA_MONGODB_PASSWORD,
            AURA_MONGODB_POOL_SIZE: configuration.AURA_MONGODB_POOL_SIZE,
            AURA_MONGODB_SSL: configuration.AURA_MONGODB_SSL
        },
        fileConfiguration: {
            containerName: 'aura-configuration',
            localPath: 'settings/makeup',
            remotePath: '',
            files: [{ name: 'aura-bridge-mongodb-indexes.json', mimeType: 'application/json' }]
        },
        replaceLocalWithRemote: true,
        storageCredentials: {
            storageKey: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY,
            storageName: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
        },
        uploadFromLocalToRemote: true,
        auraVersion: configuration.AURA_VERSION,
        ignoreDownloadErrors: true,
        ignoreUploadErrors: true,
        dataBaseSuffix: configuration.AURA_ENVIRONMENT_NAME
    }

Prepare Locale Resources

This task will only be created if the AURA_MAKEUP_MODE variable is configured to full.

The language resources in aura-bridge are located in /locale/:

 en-gb.json
 es-es.json

When starting an aura-bridge, these files are loaded remotely from [AURA-STORAGE]/static-resources/aura-bridge/[AURA_VERSION]/locale/.

In the make-up process, the language resources are uploaded to Azure Storage.

Prepare unified swagger

aura-bridge is composed of a set of plugins in which each one is responsible for a single task. Processor or API plugins can have a swagger that defines the complete definition of the service.

In this task, the make-up process is responsible for unifying all these swaggers defined in each plugin in a single and unified swagger. This swagger is used by the oastool in the server’s start-up phase.

To create this unified swagger, the make-up process uses a swagger-core.yaml file that defines the base of the final swagger file.

The process for the creation of this unified swagger is as follows:

The swagger-core.yaml file is used as a base.
Each swagger.yaml file of each plugin is merged with the swagger-core.yaml:
- Fields 'components.schemas', 'components.securitySchemes' and 'paths' are merged using Object.assign.
- Field 'tags' is added using Array.push.

graph LR
    subgraph Unified swagger from plugins and swagger-core.yaml
      A[swagger-core.yaml] --> Z[swagger.yaml]
      B[swagger.yaml -> admin-plugin] --> Z[swagger.yaml]
      C[swagger.yaml -> whatsapp-incoming-processor] --> Z[swagger.yaml]
      D[swagger.yaml -> genesys-directline-processor] --> Z[swagger.yaml]
    end

It is important to know that entities with the same name defined in different plugins will be overwritten and the last processing will be used during the Swagger unification process (as in paths and securityschemes).

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura authentication server make-up process

The current section describes the make-up processes that take place within Aura authentication server

Manage MongoDB Indexes

The indexes configuration file is in /settings/makeup/aura-authentication-mongodb-indexes.json.

Once the make-up is executed, this file will be uploaded to the assigned repository [AURA-STORAGE]/aura-configuration/[AURA_VERSION]/aura-authentication-mongodb-indexes.json. If this remote file exists, it has priority over the local file.

This configuration is assigned in the make-up process by means of the following model:

   const options: MakeupMongoIndexManagerOptions = {
        mongodbConfiguration: {
            AURA_MONGODB_URI: configuration.AURA_MONGODB_URI,
            AURA_MONGODB_DB_NAME: configuration.AURA_MONGODB_USER_DB,
            AURA_MONGODB_USERNAME: configuration.AURA_MONGODB_USERNAME,
            AURA_MONGODB_PASSWORD: configuration.AURA_MONGODB_PASSWORD,
            AURA_MONGODB_POOL_SIZE: configuration.AURA_MONGODB_POOL_SIZE,
            AURA_MONGODB_SSL: configuration.AURA_MONGODB_SSL
        },
        fileConfiguration: {
            containerName: 'aura-configuration',
            localPath: 'settings/makeup',
            remotePath: '',
            files: [{ name: 'aura-authentication-mongodb-indexes.json', mimeType: 'application/json' }]
        },
        replaceLocalWithRemote: true,
        storageCredentials: {
            storageKey: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY,
            storageName: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
        },
        uploadFromLocalToRemote: true,
        auraVersion: configuration.AURA_VERSION,
        ignoreDownloadErrors: true,
        ignoreUploadErrors: true,
        dataBaseSuffix: configuration.AURA_ENVIRONMENT_NAME
    };

Prepare Locale Resources

The language resources in Aura Authentication Service are located in /locale/:

de-de.json
en-gb.json
es-es.json

When starting an Aura Authentication Service, these files are loaded remotely from [AURA-STORAGE]/static-resources/authentication/locale/[AURA_VERSION]/.

In the make-up process, the language resources are uploaded to Azure Storage.

Process Resources

In the make-up process of Aura Authentication Service, the resources are loaded from /settings/resources/ and upload to [AURA-STORAGE]/static-resources/authentication/resources/[AURA_VERSION]/.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Check Hugging Face embedding models downloading

Guidelines to check if the Hugging Face models used in ATRIA are downloaded during the generate-db process

Introduction

The free embedding templates we are currently using in ATRIA are paraphrase-multilingual-MiniLM-L12-v2 and multi-qa-distilbert-cos-v1 both from Hugging Face. (These models are the ones used with the following embeddings by default available in ATRIA: Local Sentence Transformer and Distilbert-based Local Sentence Transformer).

During the generate-db process, these models are loaded into memory and the process may fail if there is a connection problem with Hugging Face. In this error scenario, the only solution is to wait until the service is again up and running.

In the current document, we include the instructions to check if the embedding models can be downloaded, in order to detect the process failure.

Prerequisites

Install huggingface-cli
```
pkgx install huggingface-cli
```

Check if the Hugging Face models are downloaded properly

The way to check if the service is up is by launching the following command:

huggingface-cli download sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2

If the download starts, the service is up, and you can restart the generate-db process.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Guidelines for the connection of a skill to Aura Minigroot

Detailed process for the connection of a skill to Aura Minigroot

Introduction

After the development of a skill, it can be tested easily using a tool created by Aura Global Team: Aura Minigroot.

⚠️ Aura Minigroot works together with the already existing Aura minibot, in fact constituting a unique tool. Both will be provided as docker images and must be installed jointly.

The following sections show the detailed guidelines for the connection of a skill to Aura Minigroot.

Prerequisites

The following previous tasks are required for the further connection of a skill with Aura Minigroot:

There is a skill already developed and running (in this example the skill will be running in localhost)
Aura minibot is already configured and running. You can follow the steps in Aura Minibot user guide.

1. Configure your new skill

To allow aura-groot to redirect activities to a new skill, configure it in:
/mock-configuration/mocks/mock-files/skills-configuration-mock.json.

In this example, we are going to redirect the channel novum-mytelco (you can use a new channel if you want, but you will have to add it to channels-configuration-mock.json):

To do this, the following steps were taken:

Delete the channel novum-mytelco from the first skill (Aura minibot) channels list and add it to our new skill called aura-bot-ext.
Configure the Microsoft appId of our skill, a new skill id (random uuid) and the skillEndpoint.
To access localhost from a docker container, we use host.docker.internal instead localhost.

NOTE: If you use linux, maybe you should also add extra_hosts: "host.docker.internal:host-gateway" to aura-groot in your docker-compose file.

2. User mock configuration

To access this skill, we are going to use anonymous users.

As Aura Minigroot also mocks anonymous users, we need to update the mock data to redirect the mocked anonymous user to our skill setting his channel to 45494a5b-835a-4fff-a813-b3d2be529dbe (the channelId of novum-mytelco):

With this change, all the users not mocked in authentication-mock.json will be redirected to our new skill.

3. Restart the mini-groot

After these changes, you have to restart your Aura Minigroot container to refresh the configurations.

When the container restarts, you should have your new skill working with Aura Minigroot.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Create/update an API client

Guidelines for the generation or the update of an API client in Aura

Introduction

There are two main ways to create or update a new API client, both based on a swagger OpenAPI schema:

Create a new client based on a swagger
Update an already available client by re-creating it based on the next version of the published swagger

API clients are generated automatically from the swagger file delivered by the API constructor, usually Telefónica Kernel. Aura uses a custom code generator based on the OpenAPI initiative in order to generate TypeScript clients, which is compatible with JavaScript. Two different types of clients live together in the current Aura release:

Clients generated directly from the swagger with the original code generator described on the swagger documentation.
Clients generated directly from the swagger based on the custom code generator. ℹ️ Recommended way.

A copy of the swagger generator tools is available in the repository in the folder called tools, to be used directly from the scripts of the client. In the current version, we are using aura-code-generator/packages/aura-client-generator/tools/openapi/openapi-generator-cli-6.2.1.jar as the custom code generator.

Procedures for generating or updating clients

There are three different processes, depending on the type of client and purpose:

Create a new external client for a brand-new API
Create a new internal client for a brand-new API
Update a client to a breaking change version

Moreover, if implementing a minor change version, check how the original client was created and follow the same procedure. Otherwise, there can be uncontrolled breaking changes.

Previous to the creation of a client, it is required to install the library: @telefonica/aura-develop-utilities

Create a new external client

We have integrated Hygen as a way to boost the process of creating new API clients.

To create a new API client template, please follow the next steps:

In your project install the client generator: $ @telefonica/aura-client-generator
Create a new branch with a descriptive name: $ git branch -b feat/new-api-client
Execute the following commands to create or update API:
- $ aura-client-generator, $ aucg or $ aura-cg: Generate new API with base files, model files and API files.
- $ aucg-update: Generate only API files.
- $ aucg-model: Generate only model files.
Send answers for aucg.
- Hygen: Answer the questions requested by the Hygen for the generation of the new client. Hygen will ask you for the name of the new API, the location of the swagger, the location where you want to generate the client (by default, it is generated in the root directory with the name of client), the version, the enumeration, the projectType and the tag to be set.
- Flags options: Add flags options with the answers.
  - $ -V, --version: output the version number
  - $ --clientName: Which is the name of the new API (ex.: Admin, User Authentication, etc.)?
  - $ --swaggerFile: Path of the swagger
  - $ --clientDirectory: In which directory do you want to generate the client (default: “client”)
  - $ --versionNumber: Client version
  - $ --tagName: Tag used in the publishConfig configuration (default: “”)
  - $ --enumeration: Enumeration format (choices: “Unchange”, “Unify”, “Particularize”, default: “Unchange”)
  - $ --projectType: Destination project type (choices: “client”, “server”, default: “client”)
  - $ -h, --help: display help for command

Enumeration question

It is a list of options from which you can choose the specific way the models are generated.

Unchange: No modification is applied to names, enums or interfaces themselves. (If the swagger has several schemas with the same name, they will step on each other).
Unify: This option unifies in a single enum or interface the schemas that may have the same name. (Recommended option).
Particularize: This option separates all enums that have the same name by assigning the name of the enum + the name of the schema it belongs to.

projectType question

It is a list from which you can choose the type of client: external client (client) or internal client (server). This question is asked since the aura-code-generator is used to generate these two types of clients and certain elements change in the generation of each type.

client: make reference to the external client.
server: make reference to the internal client.

Note that when Hygen asks for the location for the new client, the format of this folder name must be a dash-separated name similar to name-of-your-api or ./package/name-of-your-api only in external clients.

In the background, the aura-client-generator command carries out the following steps:

Create a new package for the new API client at the indicated address directory.
Create the .gitignore, .npmignore, .npmrc, package.json, README.md and tsconfig.json files in the new API client package directory.
Create a new src/ folder in the new API client package directory.
Create the index.ts, models.ts files and a folder called api inside this API folder.
The provided Swagger API specification file is copied to the swagger directory of the new API client package directory.

At this stage, developers are ready to start working on the new API client from the newly created API client template:

Write a description of the new client and a minimal usage example in the README file.
Commit your changes and push them to Github.
Make a Pull Request to merge your changes in master/main branch.
After approved, merge the PR into master/main branch.
Then, the new version of the client is published in the private npm registry and available to be used.

Once the creation of the new client is finished, follow the guidelines to contribute your changes according to Contributing code to the repository section.

Create a new internal client

In order to create an internal client, execute the following command:
$ npm run create-client

This will execute the process that will generate a new client, internal clients do not execute hygen as in external clients since all the information they need is passed to them through the flags that are explained below.

The complete command executed is the following:
$ npx aucg --clientName \"server name\" --swaggerFile \"swagger path\" --projectType \"server\"

Where:

npx aucg: command that executes the aucg
--swaggerFile: Location of the server swagger.
--projectType: Type of project, among the ones defined in enumeration projectType. In this case, it is server because it is an internal client. (Remember that this same generator is also used for external clients selecting the projectType client).

Steps to upload changes:

Write a description of the new client and a minimal usage example in the README file.
Commit your changes and push them to Github.
Make a Pull Request to merge your changes in master/main branch.
After approved, merge the PR into master/main branch.
Then, the new version of the client is published in the private npm registry and available to be used.

Once the creation of the new client is finished, follow the guidelines to contribute your changes according to Contributing code to the repository section.

Update a client

ℹ️ This procedure is valid both for external and internal clients

Due to the superagent HTTP library migration of all clients, a new procedure to update those clients has been implemented.

In addition, this new implementation depends on templates, which can be found here. If there are changes in the template that need to be reflected in a client, before continuing with this procedure, you should create a PR with those changes in templates and merge them into master/main branch.

The procedure to update a client with an updated template is as follows:

Create a new branch for the new code:
git checkout -b feat-or-fix-or-chore-depending-on-the-update/the-name-of-your-branch
If needed, add a tag or, if it has already been added, increase the numeric version in the package.json version:
"version": "2.1.0-superagent.x",
Execute the following command to update the client APIs:
npm run swagger-generate-client
Execute the following command to update the client models:
npm run swagger-generate-model
Commit your changes and push them to Github.
Make a Pull Request to merge your changes in master.
After approved, merge the PR into master.
Then, the new version of the client is published in the private npm registry and available to be used.

Authentication methods

All clients are generated using a common template for OpenAPI generator, so they have similar structure: all of them have a generic constructor to set a basePath endpoint: constructor(basePath?: string);

If no basePath is defined, which is not recommended, the default basePath defined on swagger file is used.

The current client generator supports several authentication methods based on swagger security definitions. The available authentication methods are described in the following sections.

Basic authentication

This authentication method is based on user and password.

Credentials can be set by different forms:

Using constructor. Credentials can be set on constructor using this method:

constructor(basePathOrUsername: string, password?: string, basePath?: string)

Using setters. Credentials can be set using username and password setters:

clientInstance.username = 'myuser'; clientInstance.password = 'mypassword';

Bearer authentication

This authentication method is based on a bearer token standard. It injects an Authorization header on HTTP request.

It can be set using the setter:
accessToken: clientInstance.accessToken = 'token'

The token can contain a bearer prefix or not. If no bearer prefix is included, the setter method adds it automatically.

Oauth authentication

This authentication method is based on oauth authentication standard. It is similar to bearer authentication method, so an authorization header is injected on HTTP request.

It can be set using the setter:
accessToken: clientInstance.accessToken = 'token'

The token can contain a Bearer prefix or not. If no Bearer prefix is included, the setter method adds it automatically.

Apikey authentication

This authentication method is based on APIKey authentication standard. It injects a generic header with key and value.

It can be set by using setApiKey method with the key and value parameters:
clientInstance.setApiKey(key: string, value:string);

None

If no security schema is defined in the API definition file or the security methods do not follow any OpenAPI standards, a generic accessToken setter is provided. This setter works as bearer and it injects an authorization header on HTTP request.

It can be set using the setter:
accessToken: clientInstance.accessToken = 'token'

The token can contain a bearer prefix or not. If no bearer prefix is included, the setter method adds it automatically.

Contributing code to the repository

To contribute your code to the repository, follow the next steps:

Once the code is satisfactory, stash changes into your branch.
Push your branch to the remote repository (this step runs the unit tests of all the packages and does not let the process continue until of all them have passed):
```
git push origin feat-or-fix-or-chore-depending-on-the-update/name-of-your-branch
```
From Github, send a new Pull Request from the branch with your code to master.
Ask for revision from any of the main contributors of the project.
Once the code has been reviewed and accepted, merge your code into master.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

General operational guidelines

This section includes general-purpose guidelines for the operation of Aura that are transversal to different Aura components

Index

Aura operational flows: Flowcharts related to Direct Line, use cases and key channels in Aura
Description of Aura make-up processes
Hot swapping processes in Aura
Procedure for managing locales in Aura
Guidelines for the elimination of expired Aura users
Information regarding Aura Continuous Integration

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Generative AI operational workflow

ATRIA technical operational flow corresponding to the operation of the Generative AI capability

Operational flowchart

The sequence diagram of the process executed by the Generative AI capability is shown below:

@startuml
title Generative API diagram
participant Application
participant Kernel #1add4d
participant AuraGatewayApi #76bbe7
participant AtriaModelGateway #f58e11
participant AzureOpenAI #9476e7
Application -> Kernel: Create two-legged token with scope aura-aiservices:messaging:write
Note right of Kernel: this token needs refreshing
Kernel -> Application: Response two-legged token
Application -> Kernel: Request to aura-aiservices/generative/prompts with token and correlatorId (x-correlator)
Kernel -> AuraGatewayApi: Request to aiservices/generative/prompts with token-info header and correlatorId
AuraGatewayApi -> AuraGatewayApi: Validate request
AuraGatewayApi -> AuraGatewayApi: Generate prompt
AuraGatewayApi -> AtriaModelGateway: Send prompt to atria-model-gateway
AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
AtriaModelGateway -> AuraGatewayApi: Response prompt
AuraGatewayApi -> AuraGatewayApi: process atria-model-gateway response
AuraGatewayApi -> AuraGatewayApi: generate response
AuraGatewayApi -> Kernel: response 200 and message with session_id
Kernel -> Application: response 200 and message with session_id
@enduml

Generative AI operational sequence diagram

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Analytics 2.0.0 operation

Discover Aura Analytics 2.0.0 operation at a glance

Introduction

Based on Aura Analytics 2.0.0 architecture, the current documents provides an overview of its global operation.

Take the Aura Analytics 2.0.0 architecture flowchart as a reference to follow each step of the dataflow described below:

Aura logs generated in local instance are converted to datasets and transferred to local Kernel via the standard procedure and with the established frequency (typically, daily). Once there, the Active listening process flow fires up daily.
PPD-Creator: This is the first process that runs, and it is the only one executed in the OBs’ environment. It retrieves Kernel data, anonymizes all sensitive data that could identify users, and then transfers this data to an environment shared with the Aura Global team.
Manage-PPD-Raw: This is the first process executed from the global environment. It solely stores the paths of the data transferred by the PPD-Creator into a PostgreSQL database to keep a record of which data has been transferred.
PPD-Clean: This process runs from the global environment. Once the data is anonymized, it is processed to extract additional features (such as user frustration or the extraction of n-grams from user phrases about iterations that do not have an intent).
Once the data is processed, a path is saved in the environment and also in ElasticSearch to create dashboards that tracks Aura usage by its customers.
User-Dynamics: This is the last process, also executed in global environment. It is responsible for extracting statistics about users’ recurrence and the number of users per day. Among that, it identifies new users, recurring users (those making iterations every day), recovered users (those who have stopped using Aura at some point and have returned to the system) and lost users (those who have stopped using Aura in 3 months).

Examples of different dashboards are included below:

Figure 1. Users dashboard

Figure 2. Daily users dashboard

Figure 3. Weekly users dashboard

Figure 4. Trends dashboards

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Gateway API operational overview

Description of Aura Gateway API operation and communication protocol

Communication protocol

aura-gateway-api communication protocol is synchronous, depending on the endpoint.

A new component comes here into play: application, defined as an entity used by a channel, service or skill to connect with aura-gateway-api.

An application has a specific configuration and will be the entry point to the aura-gateway-api flow, previous pass through Kernel, meaning that the input parameters for aura-gateway-api come from the application, and no specific information regarding the channel, service or skill is required.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Output from QA Tool: logs and reports

Learn how to manage the content of logs and results reports generated after the execution of the QA global test set

QA Tool general results reports

After the QA Tool execution, the results of the tests are copied to the local folder:
📁 ~/[project_folder]/aura-tests/acceptance/_output/

Four general files are generated for every test executed:

Logs file

📁 ~/[project_folder]/aura-tests/acceptance/_output/acceptance_int.log

This is a pass/fail test. When a test fails, a bug is generated and it is required to evaluate its criticity level. The logs will detail the errors that have occurred and the specific part of the code which is failing.

Example of logs file

INFO    2019-07-11 09:50:59,576 [commons] Installed versions in co-pre environment:
Aura: 3.5.0
Bot: 7.14.1
Authentication API: 3.0.0
Configuration API: None
User Helper: 3.2.0.214
NLP: 1.0.9 (container), 1.116.0 (pipelines)
.......
>>>>>>>>>>>>>>>>>>>>> Request >>>>>>>>>>>>>>>>>>>
	> Method: POST
	> Url: https://auth.co-pre.baikalplatform.com/token?grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImM0MmFjMWM0NmYxZDRlMjExYzczNWNjN2RmYWQ0ZmY4MzkxMTEwZTkifQ.eyJzdWIiOiI1MDczOSIsImlzcyI6Imh0dHBzOi8vYWktc2VydmljZXMtcHJlLWNvLmF1cmFjb2duaXRpdmUuY29tL2F1cmEtc2VydmljZXMvdjEvb3BlbmlkL2lzc3Vlci8iLCJwdXJwb3NlIjoiY3VzdG9tZXItc2VsZi1zZXJ2aWNlIGRldGVjdC1hYm5vcm1hbC11c2FnZSBkZXZpY2UtcmVjb21tZW5kYXRpb25zLXYzIHNpbS11cGdyYWRlLXN1Z2dlc3Rpb24gYXVyYS1yZWFkLWluc2lnaHQtZXZlbnRzIGlkZW50aWZ5LWN1c3RvbWVyIiwiZXhwIjoxNTYyODM1MDYyLCJpYXQiOjE1NjI4MzE0NjIsInNjb3BlIjoiIiwiYXVkIjoiaHR0cHM6Ly9hdXRoLmNvLXByZS5iYWlrYWxwbGF0Zm9ybS5jb20vIn0.Zqsc16RZYFFr-GGTTDSAGgb3numx9bhSgdpT0OOCJudJsm20nyXXLxj-MUITK4Pxhnmkc7zwFd0WHJkt955C6NxygwUpURYpxcN2vq7ISewATi-QnYzfcgUUeYXxGTCOb6wWdpYbviOnU_5g1KfaVtC8noYtYkRuspQCBLH8Ao4ZCPuTdCFJdJRb49ujIuL821qTJxrqkDTpzoFH-2_xdVfx_c2OdeCObFWIVFmXMfFW3X_5K0EIP0beBh4yyRoIsWdKFpGWWQ4Ebrx0tawtTTp8Sob42sSxyP4ADN83GpjodPtv-g4KJDoch3LSqDkbvFKzTnt1v2NVY1nqNPtV_w
	> Query params: [(u'grant_type', u'urn:ietf:params:oauth:grant-type:jwt-bearer'), (u'assertion', u'eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImM0MmFjMWM0NmYxZDRlMjExYzczNWNjN2RmYWQ0ZmY4MzkxMTEwZTkifQ.eyJzdWIiOiI1MDczOSIsImlzcyI6Imh0dHBzOi8vYWktc2VydmljZXMtcHJlLWNvLmF1cmFjb2duaXRpdmUuY29tL2F1cmEtc2VydmljZXMvdjEvb3BlbmlkL2lzc3Vlci8iLCJwdXJwb3NlIjoiY3VzdG9tZXItc2VsZi1zZXJ2aWNlIGRldGVjdC1hYm5vcm1hbC11c2FnZSBkZXZpY2UtcmVjb21tZW5kYXRpb25zLXYzIHNpbS11cGdyYWRlLXN1Z2dlc3Rpb24gYXVyYS1yZWFkLWluc2lnaHQtZXZlbnRzIGlkZW50aWZ5LWN1c3RvbWVyIiwiZXhwIjoxNTYyODM1MDYyLCJpYXQiOjE1NjI4MzE0NjIsInNjb3BlIjoiIiwiYXVkIjoiaHR0cHM6Ly9hdXRoLmNvLXByZS5iYWlrYWxwbGF0Zm9ybS5jb20vIn0.Zqsc16RZYFFr-GGTTDSAGgb3numx9bhSgdpT0OOCJudJsm20nyXXLxj-MUITK4Pxhnmkc7zwFd0WHJkt955C6NxygwUpURYpxcN2vq7ISewATi-QnYzfcgUUeYXxGTCOb6wWdpYbviOnU_5g1KfaVtC8noYtYkRuspQCBLH8Ao4ZCPuTdCFJdJRb49ujIuL821qTJxrqkDTpzoFH-2_xdVfx_c2OdeCObFWIVFmXMfFW3X_5K0EIP0beBh4yyRoIsWdKFpGWWQ4Ebrx0tawtTTp8Sob42sSxyP4ADN83GpjodPtv-g4KJDoch3LSqDkbvFKzTnt1v2NVY1nqNPtV_w')]
	> Headers:
{
    "Authorization": "Basic YXVyYS1ib3Q6U2pVVTdLY2dWdEllOWdGMHVjanlJakJJRA=="
}
DEBUG   2019-07-11 09:51:02,262 [connectionpool] Starting new HTTPS connection (1): auth.co-pre.baikalplatform.com
DEBUG   2019-07-11 09:51:02,950 [connectionpool] https://auth.co-pre.baikalplatform.com:443 "POST /token?grant_type=urn%3Aietf%3Aparams%3Aoauth%3Agrant-type%3Ajwt-bearer&assertion=eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCIsImtpZCI6ImM0MmFjMWM0NmYxZDRlMjExYzczNWNjN2RmYWQ0ZmY4MzkxMTEwZTkifQ.eyJzdWIiOiI1MDczOSIsImlzcyI6Imh0dHBzOi8vYWktc2VydmljZXMtcHJlLWNvLmF1cmFjb2duaXRpdmUuY29tL2F1cmEtc2VydmljZXMvdjEvb3BlbmlkL2lzc3Vlci8iLCJwdXJwb3NlIjoiY3VzdG9tZXItc2VsZi1zZXJ2aWNlIGRldGVjdC1hYm5vcm1hbC11c2FnZSBkZXZpY2UtcmVjb21tZW5kYXRpb25zLXYzIHNpbS11cGdyYWRlLXN1Z2dlc3Rpb24gYXVyYS1yZWFkLWluc2lnaHQtZXZlbnRzIGlkZW50aWZ5LWN1c3RvbWVyIiwiZXhwIjoxNTYyODM1MDYyLCJpYXQiOjE1NjI4MzE0NjIsInNjb3BlIjoiIiwiYXVkIjoiaHR0cHM6Ly9hdXRoLmNvLXByZS5iYWlrYWxwbGF0Zm9ybS5jb20vIn0.Zqsc16RZYFFr-GGTTDSAGgb3numx9bhSgdpT0OOCJudJsm20nyXXLxj-MUITK4Pxhnmkc7zwFd0WHJkt955C6NxygwUpURYpxcN2vq7ISewATi-QnYzfcgUUeYXxGTCOb6wWdpYbviOnU_5g1KfaVtC8noYtYkRuspQCBLH8Ao4ZCPuTdCFJdJRb49ujIuL821qTJxrqkDTpzoFH-2_xdVfx_c2OdeCObFWIVFmXMfFW3X_5K0EIP0beBh4yyRoIsWdKFpGWWQ4Ebrx0tawtTTp8Sob42sSxyP4ADN83GpjodPtv-g4KJDoch3LSqDkbvFKzTnt1v2NVY1nqNPtV_w HTTP/1.1" 200 None
DEBUG   2019-07-11 09:51:02,952 [logger]
# Response 
	< Response code: 200
	< Headers:
{
    "Access-Control-Allow-Origin": "*",
    "Cache-Control": "no-cache, no-store, max-age=0, must-revalidate",
    "Content-Security-Policy": "script-src 'sha256-F+lLIWNuYKlUuNZaPUz2Et6V08PYVCIgGrSCOOLPEGc='",
    "Content-Type": "application/json;charset=UTF-8",
    "Date": "Thu, 11 Jul 2019 07:51:02 GMT",
    "Expires": "0",
    "Pragma": "no-cache",
    "Referrer-Policy": "no-referrer",
    "Strict-Transport-Security": "max-age=315360000; includeSubdomains; preload",
    "Transfer-Encoding": "chunked",
    "X-Content-Type-Options": "nosniff",
    "X-Frame-Options": "SAMEORIGIN",
    "X-Xss-Protection": "1; mode=block"
}
	< Payload received:
{"access_token":"eyJraWQiOiI0ZjI0MzM3NTI2NThmYTBjMTg4ZDM2MTdmNmNjNDY5ZjQ5NzJiOWYiLCJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.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.OMLA5T8AMp8oSPZON8NcK6lvfWjI6beyXc8tGe7kKf9ZZLqTWK6b4I3ccS4IJ4uIVOi6KG53ueqojKBK4toHCAKnVMpLthiQlP4tG34Nd5TW21dRhqokX4a48LpQDZFadQVZq5wwGtiy9HIN3wxNGNje6FabX8NAnTAzVQuVHphtG5UoXHJDJ3LsUZ04pRLKRw6Vuza7Ct1igxYf7VkircwSszbVjGYuFFr23cwCY9YEDUbtACl68JUlUJLCWGUHTvasiGOAalf_-3EykEM8an7gMLyCXMYqJn2zPNgLJvmfiBBch_zNc-Qz7f8FeDdWJGwOgrXEkdCqwA0xSweroA","token_type":"Bearer","expires_in":3599,"scope":"event-low-data-read insights-data-usage-result-read auraid-read mobile-balance-transfer-write webviews-phone-number-read amount-due-phone-number-read event-subscription-type-migration-read authentication-information-read product-management-offers-user-read product-management-orders-read event-no-data-read timeline-phone-number-read mobile-balance-read subscribed-products-read event-no-balance-read subscribed-products-user-read invoicing-phone-number-read event-appointment-reminder-read issues-user-read issues-user-create consumption-user-read unusual-data-usage-read mobile-quota-read issues-phone-number-create event-unusual-balance-read event-high-spend-alert-read mobile-balance-top-up-write invoicing-user-read insights-setup-4g-ready-read issues-create product-management-offers-read event-invoice-retained-read event-invoice-charge-read product-management-orders-phone-number-read insights-device-recommender-phone-number-read userprofile-read insights-balance-result-read webviews-user-read event-low-voice-read product-management-offers-phone-number-read insights-billing-queries-result-read product-management-orders-user-read event-unusual-data-usage-read event-bar-alert-read product-management-orders-write event-invoice-debit-read event-payment-alert-read auraid-write amount-due-user-read subscribed-products-phone-number-read event-no-voice-read event-unusual-billing-read notifications-read timeline-read product-management-orders-user-write notification-email-write event-disconnection-alert-read event-invoice-payment-due-read event-low-balance-read product-management-orders-phone-number-write notification-email-read insights-device-recommender-user-read consumption-phone-number-read timeline-user-read amount-due-read mobile-balance-top-up-read invoicing-read issues-read issues-phone-number-read","purpose":"identify-customer device-recommendations-v3 aura-read-insight-events sim-upgrade-suggestion detect-abnormal-usage customer-self-service"}
DEBUG   2019-07-11 09:51:02,962 [connectionpool] Starting new HTTPS connection (1): api.co-pre.baikalplatform.com
DEBUG   2019-07-11 09:51:09,139 [connectionpool] https://api.co-pre.baikalplatform.com:443 "GET /userprofile/v3/users/50739 HTTP/1.1" 200 1144
INFO    2019-07-11 09:51:09,142 [data_4p] >>>>>>>>>>>>>>>>>>>>> Request 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:09,142 [data_4p] curl -s -H "Authorization: Bearer eyJraWQiOiI0ZjI0MzM3NTI2NThmYTBjMTg4ZDM2MTdmNmNjNDY5ZjQ5NzJiOWYiLCJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpZGVudGlmaWVyX2JvdW5kX3Njb3BlIjpbXSwiYXVkIjoiaHR0cHM6XC9cL2FwaS5jby1wcmUuYmFpa2FscGxhdGZvcm0uY29tIiwic3ViIjoiNTA3MzkiLCJwdXJwb3NlIjoiaWRlbnRpZnktY3VzdG9tZXIgZGV2aWNlLXJlY29tbWVuZGF0aW9ucy12MyBhdXJhLXJlYWQtaW5zaWdodC1ldmVudHMgc2ltLXVwZ3JhZGUtc3VnZ2VzdGlvbiBkZXRlY3QtYWJub3JtYWwtdXNhZ2UgY3VzdG9tZXItc2VsZi1zZXJ2aWNlIiwic2NvcGUiOiJldmVudC1sb3ctZGF0YS1yZWFkIGluc2lnaHRzLWRhdGEtdXNhZ2UtcmVzdWx0LXJlYWQgYXVyYWlkLXJlYWQgbW9iaWxlLWJhbGFuY2UtdHJhbnNmZXItd3JpdGUgd2Vidmlld3MtcGhvbmUtbnVtYmVyLXJlYWQgYW1vdW50LWR1ZS1waG9uZS1udW1iZXItcmVhZCBldmVudC1zdWJzY3JpcHRpb24tdHlwZS1taWdyYXRpb24tcmVhZCBhdXRoZW50aWNhdGlvbi1pbmZvcm1hdGlvbi1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtdXNlci1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtcmVhZCBldmVudC1uby1kYXRhLXJlYWQgdGltZWxpbmUtcGhvbmUtbnVtYmVyLXJlYWQgbW9iaWxlLWJhbGFuY2UtcmVhZCBzdWJzY3JpYmVkLXByb2R1Y3RzLXJlYWQgZXZlbnQtbm8tYmFsYW5jZS1yZWFkIHN1YnNjcmliZWQtcHJvZHVjdHMtdXNlci1yZWFkIGludm9pY2luZy1waG9uZS1udW1iZXItcmVhZCBldmVudC1hcHBvaW50bWVudC1yZW1pbmRlci1yZWFkIGlzc3Vlcy11c2VyLXJlYWQgaXNzdWVzLXVzZXItY3JlYXRlIGNvbnN1bXB0aW9uLXVzZXItcmVhZCB1bnVzdWFsLWRhdGEtdXNhZ2UtcmVhZCBtb2JpbGUtcXVvdGEtcmVhZCBpc3N1ZXMtcGhvbmUtbnVtYmVyLWNyZWF0ZSBldmVudC11bnVzdWFsLWJhbGFuY2UtcmVhZCBldmVudC1oaWdoLXNwZW5kLWFsZXJ0LXJlYWQgbW9iaWxlLWJhbGFuY2UtdG9wLXVwLXdyaXRlIGludm9pY2luZy11c2VyLXJlYWQgaW5zaWdodHMtc2V0dXAtNGctcmVhZHktcmVhZCBpc3N1ZXMtY3JlYXRlIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtcmVhZCBldmVudC1pbnZvaWNlLXJldGFpbmVkLXJlYWQgZXZlbnQtaW52b2ljZS1jaGFyZ2UtcmVhZCBwcm9kdWN0LW1hbmFnZW1lbnQtb3JkZXJzLXBob25lLW51bWJlci1yZWFkIGluc2lnaHRzLWRldmljZS1yZWNvbW1lbmRlci1waG9uZS1udW1iZXItcmVhZCB1c2VycHJvZmlsZS1yZWFkIGluc2lnaHRzLWJhbGFuY2UtcmVzdWx0LXJlYWQgd2Vidmlld3MtdXNlci1yZWFkIGV2ZW50LWxvdy12b2ljZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtcGhvbmUtbnVtYmVyLXJlYWQgaW5zaWdodHMtYmlsbGluZy1xdWVyaWVzLXJlc3VsdC1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtdXNlci1yZWFkIGV2ZW50LXVudXN1YWwtZGF0YS11c2FnZS1yZWFkIGV2ZW50LWJhci1hbGVydC1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtd3JpdGUgZXZlbnQtaW52b2ljZS1kZWJpdC1yZWFkIGV2ZW50LXBheW1lbnQtYWxlcnQtcmVhZCBhdXJhaWQtd3JpdGUgYW1vdW50LWR1ZS11c2VyLXJlYWQgc3Vic2NyaWJlZC1wcm9kdWN0cy1waG9uZS1udW1iZXItcmVhZCBldmVudC1uby12b2ljZS1yZWFkIGV2ZW50LXVudXN1YWwtYmlsbGluZy1yZWFkIG5vdGlmaWNhdGlvbnMtcmVhZCB0aW1lbGluZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtdXNlci13cml0ZSBub3RpZmljYXRpb24tZW1haWwtd3JpdGUgZXZlbnQtZGlzY29ubmVjdGlvbi1hbGVydC1yZWFkIGV2ZW50LWludm9pY2UtcGF5bWVudC1kdWUtcmVhZCBldmVudC1sb3ctYmFsYW5jZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtcGhvbmUtbnVtYmVyLXdyaXRlIG5vdGlmaWNhdGlvbi1lbWFpbC1yZWFkIGluc2lnaHRzLWRldmljZS1yZWNvbW1lbmRlci11c2VyLXJlYWQgY29uc3VtcHRpb24tcGhvbmUtbnVtYmVyLXJlYWQgdGltZWxpbmUtdXNlci1yZWFkIGFtb3VudC1kdWUtcmVhZCBtb2JpbGUtYmFsYW5jZS10b3AtdXAtcmVhZCBpbnZvaWNpbmctcmVhZCBpc3N1ZXMtcmVhZCBpc3N1ZXMtcGhvbmUtbnVtYmVyLXJlYWQiLCJpc3MiOiJodHRwczpcL1wvYXV0aC5jby1wcmUuYmFpa2FscGxhdGZvcm0uY29tXC8iLCJhY3RpdmUiOnRydWUsImV4cCI6MTU2MjgzNTA2MiwiaWF0IjoxNTYyODMxNDYyLCJjbGllbnRfaWQiOiJhdXJhLWJvdCIsImp0aSI6ImM0Y2NhN2M4LTdiMWUtNDMyMi1iNTFjLWRhYjQxOGEwNTgwMSJ9.OMLA5T8AMp8oSPZON8NcK6lvfWjI6beyXc8tGe7kKf9ZZLqTWK6b4I3ccS4IJ4uIVOi6KG53ueqojKBK4toHCAKnVMpLthiQlP4tG34Nd5TW21dRhqokX4a48LpQDZFadQVZq5wwGtiy9HIN3wxNGNje6FabX8NAnTAzVQuVHphtG5UoXHJDJ3LsUZ04pRLKRw6Vuza7Ct1igxYf7VkircwSszbVjGYuFFr23cwCY9YEDUbtACl68JUlUJLCWGUHTvasiGOAalf_-3EykEM8an7gMLyCXMYqJn2zPNgLJvmfiBBch_zNc-Qz7f8FeDdWJGwOgrXEkdCqwA0xSweroA" --proxy http://proxytid.hi.inet:8080 "https://api.co-pre.baikalplatform.com/userprofile/v3/users/50739"
INFO    2019-07-11 09:51:09,142 [data_4p] >>>>>>>>>>>>>>>>>>>>> Response 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:09,142 [data_4p] status: 200, reason: OK
INFO    2019-07-11 09:51:09,142 [data_4p] data: {u'id_document': {u'country': u'CO', u'type': u'CC', u'value': u'1049615041'}, u'identities': [{u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573182529375', u'roles': [u'owner']}, {u'services': [u'mobile_prepaid'], u'type': u'phone_number', u'id': u'+573142182110', u'roles': [u'owner']}, {u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573132709928', u'roles': [u'owner']}, {u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573005271795', u'roles': [u'owner']}, {u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573114591615', u'roles': [u'owner']}, {u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573167412035', u'roles': [u'owner']}, {u'services': [u'mobile_postpaid'], u'type': u'phone_number', u'id': u'+573166905565', u'roles': [u'owner']}, {u'services': [u'internet', u'landline'], u'type': u'phone_number', u'id': u'+5787457006', u'roles': [u'owner', u'user']}, {u'services': [u'dth'], u'type': u'uid', u'id': u'TV_93994162_2', u'roles': [u'owner', u'user']}, {u'services': [u'dth'], u'type': u'uid', u'id': u'TV_108879147_2', u'roles': [u'owner', u'user']}, {u'services': [u'email'], u'type': u'email', u'id': u'jcamiloct-9412@hotmail.com', u'roles': [u'owner']}], u'id': u'50739', u'name': u'ERIKA JURIETH VASQUEZ MARTINEZ'}
DEBUG   2019-07-11 09:51:09,155 [connectionpool] Starting new HTTPS connection (1): api.co-pre.baikalplatform.com
DEBUG   2019-07-11 09:51:11,094 [connectionpool] https://api.co-pre.baikalplatform.com:443 "GET /subscribed_products/v2/phone_numbers/+573167412035/products HTTP/1.1" 200 2999
INFO    2019-07-11 09:51:11,097 [data_4p] >>>>>>>>>>>>>>>>>>>>> Request 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:11,097 [data_4p] curl -s -H "Authorization: Bearer eyJraWQiOiI0ZjI0MzM3NTI2NThmYTBjMTg4ZDM2MTdmNmNjNDY5ZjQ5NzJiOWYiLCJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.eyJpZGVudGlmaWVyX2JvdW5kX3Njb3BlIjpbXSwiYXVkIjoiaHR0cHM6XC9cL2FwaS5jby1wcmUuYmFpa2FscGxhdGZvcm0uY29tIiwic3ViIjoiNTA3MzkiLCJwdXJwb3NlIjoiaWRlbnRpZnktY3VzdG9tZXIgZGV2aWNlLXJlY29tbWVuZGF0aW9ucy12MyBhdXJhLXJlYWQtaW5zaWdodC1ldmVudHMgc2ltLXVwZ3JhZGUtc3VnZ2VzdGlvbiBkZXRlY3QtYWJub3JtYWwtdXNhZ2UgY3VzdG9tZXItc2VsZi1zZXJ2aWNlIiwic2NvcGUiOiJldmVudC1sb3ctZGF0YS1yZWFkIGluc2lnaHRzLWRhdGEtdXNhZ2UtcmVzdWx0LXJlYWQgYXVyYWlkLXJlYWQgbW9iaWxlLWJhbGFuY2UtdHJhbnNmZXItd3JpdGUgd2Vidmlld3MtcGhvbmUtbnVtYmVyLXJlYWQgYW1vdW50LWR1ZS1waG9uZS1udW1iZXItcmVhZCBldmVudC1zdWJzY3JpcHRpb24tdHlwZS1taWdyYXRpb24tcmVhZCBhdXRoZW50aWNhdGlvbi1pbmZvcm1hdGlvbi1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtdXNlci1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtcmVhZCBldmVudC1uby1kYXRhLXJlYWQgdGltZWxpbmUtcGhvbmUtbnVtYmVyLXJlYWQgbW9iaWxlLWJhbGFuY2UtcmVhZCBzdWJzY3JpYmVkLXByb2R1Y3RzLXJlYWQgZXZlbnQtbm8tYmFsYW5jZS1yZWFkIHN1YnNjcmliZWQtcHJvZHVjdHMtdXNlci1yZWFkIGludm9pY2luZy1waG9uZS1udW1iZXItcmVhZCBldmVudC1hcHBvaW50bWVudC1yZW1pbmRlci1yZWFkIGlzc3Vlcy11c2VyLXJlYWQgaXNzdWVzLXVzZXItY3JlYXRlIGNvbnN1bXB0aW9uLXVzZXItcmVhZCB1bnVzdWFsLWRhdGEtdXNhZ2UtcmVhZCBtb2JpbGUtcXVvdGEtcmVhZCBpc3N1ZXMtcGhvbmUtbnVtYmVyLWNyZWF0ZSBldmVudC11bnVzdWFsLWJhbGFuY2UtcmVhZCBldmVudC1oaWdoLXNwZW5kLWFsZXJ0LXJlYWQgbW9iaWxlLWJhbGFuY2UtdG9wLXVwLXdyaXRlIGludm9pY2luZy11c2VyLXJlYWQgaW5zaWdodHMtc2V0dXAtNGctcmVhZHktcmVhZCBpc3N1ZXMtY3JlYXRlIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtcmVhZCBldmVudC1pbnZvaWNlLXJldGFpbmVkLXJlYWQgZXZlbnQtaW52b2ljZS1jaGFyZ2UtcmVhZCBwcm9kdWN0LW1hbmFnZW1lbnQtb3JkZXJzLXBob25lLW51bWJlci1yZWFkIGluc2lnaHRzLWRldmljZS1yZWNvbW1lbmRlci1waG9uZS1udW1iZXItcmVhZCB1c2VycHJvZmlsZS1yZWFkIGluc2lnaHRzLWJhbGFuY2UtcmVzdWx0LXJlYWQgd2Vidmlld3MtdXNlci1yZWFkIGV2ZW50LWxvdy12b2ljZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vZmZlcnMtcGhvbmUtbnVtYmVyLXJlYWQgaW5zaWdodHMtYmlsbGluZy1xdWVyaWVzLXJlc3VsdC1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtdXNlci1yZWFkIGV2ZW50LXVudXN1YWwtZGF0YS11c2FnZS1yZWFkIGV2ZW50LWJhci1hbGVydC1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtd3JpdGUgZXZlbnQtaW52b2ljZS1kZWJpdC1yZWFkIGV2ZW50LXBheW1lbnQtYWxlcnQtcmVhZCBhdXJhaWQtd3JpdGUgYW1vdW50LWR1ZS11c2VyLXJlYWQgc3Vic2NyaWJlZC1wcm9kdWN0cy1waG9uZS1udW1iZXItcmVhZCBldmVudC1uby12b2ljZS1yZWFkIGV2ZW50LXVudXN1YWwtYmlsbGluZy1yZWFkIG5vdGlmaWNhdGlvbnMtcmVhZCB0aW1lbGluZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtdXNlci13cml0ZSBub3RpZmljYXRpb24tZW1haWwtd3JpdGUgZXZlbnQtZGlzY29ubmVjdGlvbi1hbGVydC1yZWFkIGV2ZW50LWludm9pY2UtcGF5bWVudC1kdWUtcmVhZCBldmVudC1sb3ctYmFsYW5jZS1yZWFkIHByb2R1Y3QtbWFuYWdlbWVudC1vcmRlcnMtcGhvbmUtbnVtYmVyLXdyaXRlIG5vdGlmaWNhdGlvbi1lbWFpbC1yZWFkIGluc2lnaHRzLWRldmljZS1yZWNvbW1lbmRlci11c2VyLXJlYWQgY29uc3VtcHRpb24tcGhvbmUtbnVtYmVyLXJlYWQgdGltZWxpbmUtdXNlci1yZWFkIGFtb3VudC1kdWUtcmVhZCBtb2JpbGUtYmFsYW5jZS10b3AtdXAtcmVhZCBpbnZvaWNpbmctcmVhZCBpc3N1ZXMtcmVhZCBpc3N1ZXMtcGhvbmUtbnVtYmVyLXJlYWQiLCJpc3MiOiJodHRwczpcL1wvYXV0aC5jby1wcmUuYmFpa2FscGxhdGZvcm0uY29tXC8iLCJhY3RpdmUiOnRydWUsImV4cCI6MTU2MjgzNTA2MiwiaWF0IjoxNTYyODMxNDYyLCJjbGllbnRfaWQiOiJhdXJhLWJvdCIsImp0aSI6ImM0Y2NhN2M4LTdiMWUtNDMyMi1iNTFjLWRhYjQxOGEwNTgwMSJ9.OMLA5T8AMp8oSPZON8NcK6lvfWjI6beyXc8tGe7kKf9ZZLqTWK6b4I3ccS4IJ4uIVOi6KG53ueqojKBK4toHCAKnVMpLthiQlP4tG34Nd5TW21dRhqokX4a48LpQDZFadQVZq5wwGtiy9HIN3wxNGNje6FabX8NAnTAzVQuVHphtG5UoXHJDJ3LsUZ04pRLKRw6Vuza7Ct1igxYf7VkircwSszbVjGYuFFr23cwCY9YEDUbtACl68JUlUJLCWGUHTvasiGOAalf_-3EykEM8an7gMLyCXMYqJn2zPNgLJvmfiBBch_zNc-Qz7f8FeDdWJGwOgrXEkdCqwA0xSweroA" --proxy http://proxytid.hi.inet:8080 "https://api.co-pre.baikalplatform.com/subscribed_products/v2/phone_numbers/+573167412035/products"
INFO    2019-07-11 09:51:11,097 [data_4p] >>>>>>>>>>>>>>>>>>>>> Response 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:11,098 [data_4p] status: 200, reason: OK
INFO    2019-07-11 09:51:11,098 [data_4p] data: [{u'phone_number': u'+573167412035', u'product_type': u'bundle', u'subscription_type': u'postpaid', u'price': {u'currency': u'COP', u'amount': 98990.0}, u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Mas Gigas: 28GB para navegar en internet+Min y sms ilimitados a todo destino nal+500 min LDI USA, Canada y Pto Rico+FamiliayAmigos+Movistar play lite+Cloud'}], u'sub_products': [{u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Movistar Play'}], u'display_name': u'Movistar play', u'id': u'GMEHPLP4PE3NTFG9F8'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Waze'}], u'display_name': u'Waze', u'id': u'XBKIIAUUKCH7R75PWH'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'PAQUETE CHAT FACEBOOK INCLUIDO 10MB'}], u'display_name': u'Facebook', u'id': u'E61F2UBOMK7NUDYIII'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'250 MB'}], u'display_name': u'Whatsapp', u'id': u'CMF7NEFWLRAGNP5VCA'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'cloud '}], u'display_name': u'Movistar Cloud ', u'id': u'JYRESC775YDJYN2KUD'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'5 x 1 Familia Movistar'}], u'display_name': u'5 x 1 Familia Movistar', u'id': u'C3P6PA9QCNA90CKIZ8'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'120 MB'}], u'display_name': u'Twitter', u'id': u'WLN3NHWR9W0C9XUMS8'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Movistar m\ufffd\ufffdsica'}], u'display_name': u'Movistar Musica', u'id': u'NDZOB87DVQI0681VMP'}, {u'phone_number': u'+573167412035', u'product_type': u'value_added_service', u'subscription_type': u'postpaid', u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Movistar play lite'}], u'display_name': u'Movistar play Lite', u'id': u'19V0VDYPRIGTM3HLK4'}, {u'phone_number': u'+573167412035', u'product_type': u'mobile', u'subscription_type': u'postpaid', u'quota': {u'max_sms': -1, u'data_max_bytes': 29360128000, u'voice_max_seconds': -1}, u'start_date': u'2017-01-05T19:00:00Z', u'descriptions': [{u'text': u'Mas Gigas: 28GB para navegar en internet+Min y sms ilimitados a todo destino nal+500 min LDI USA, Canada y Pto Rico+FamiliayAmigos+Movistar play lite+Cloud'}], u'display_name': u'SIN CONTROL MIN + DATOS_2016', u'id': u'2016'}], u'display_name': u'SIN CONTROL MIN + DATOS_2016', u'id': u'2016'}]
DEBUG   2019-07-11 09:51:11,107 [connectionpool] Starting new HTTPS connection (1): api.co-pre.baikalplatform.com
DEBUG   2019-07-11 09:51:13,657 [connectionpool] https://api.co-pre.baikalplatform.com:443 "GET /mobile_balance/v2/phone_numbers/+573167412035/balance HTTP/1.1" 500 53
INFO    2019-07-11 09:51:39,975 [data_4p] >>>>>>>>>>>>>>>>>>>>> Request 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:39,975 [data_4p] curl -s -H "Authorization: Bearer eyJraWQiOiI0ZjI0MzM3NTI2NThmYTBjMTg4ZDM2MTdmNmNjNDY5ZjQ5NzJiOWYiLCJ0eXAiOiJKV1QiLCJhbGciOiJSUzI1NiJ9.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.OMLA5T8AMp8oSPZON8NcK6lvfWjI6beyXc8tGe7kKf9ZZLqTWK6b4I3ccS4IJ4uIVOi6KG53ueqojKBK4toHCAKnVMpLthiQlP4tG34Nd5TW21dRhqokX4a48LpQDZFadQVZq5wwGtiy9HIN3wxNGNje6FabX8NAnTAzVQuVHphtG5UoXHJDJ3LsUZ04pRLKRw6Vuza7Ct1igxYf7VkircwSszbVjGYuFFr23cwCY9YEDUbtACl68JUlUJLCWGUHTvasiGOAalf_-3EykEM8an7gMLyCXMYqJn2zPNgLJvmfiBBch_zNc-Qz7f8FeDdWJGwOgrXEkdCqwA0xSweroA" --proxy http://proxytid.hi.inet:8080 "https://api.co-pre.baikalplatform.com/mobile_quota/v2/phone_numbers/+573167412035/quota"
INFO    2019-07-11 09:51:39,976 [data_4p] >>>>>>>>>>>>>>>>>>>>> Response 4TH PLATFORM >>>>>>>>>>>>>>>>>>>
INFO    2019-07-11 09:51:39,976 [data_4p] status: 200, reason: OK
INFO    2019-07-11 09:51:39,976 [data_4p] data: {u'phone_number': u'+573167412035', u'sms': [], u'voice': [{u'time_bands': [u'all'], u'description': u'LDI', u'end_date': u'2038-01-02T04:59:59Z', u'consumed_seconds': 0, u'origins': [u'home'], u'max_seconds': 30000, u'start_date': u'2018-05-24T11:08:43Z', u'destinations': [u'national']}], u'data': [{u'time_bands': [u'all'], u'consumed_bytes': 2040109465, u'description': u'Datos', u'end_date': u'2038-01-02T04:59:59Z', u'origins': [u'home'], u'max_bytes': 30064771072, u'start_date': u'2018-10-06T01:11:29Z'}]}
DEBUG   2019-07-11 09:51:39,985 [connectionpool] Starting new HTTPS connection (1): api.co-pre.baikalplatform.com
DEBUG   2019-07-11 09:51:40,519 [connectionpool] https://api.co-pre.baikalplatform.com:443 "GET /insights/data_usage_result/v2/users/50739 HTTP/1.1" 404 47
..........
DEBUG   2019-07-11 09:51:40,552 [connectionpool] Starting new HTTPS connection (1): ai-pre-co.auracognitive.com
DEBUG   2019-07-11 09:51:41,122 [connectionpool] https://ai-pre-co.auracognitive.com:443 "GET /v1/kv/config/pre_co/aura-bot/FPA_SUBSCRIBED_PRODUCTS_ENDPOINT HTTP/1.1" 200 218
ERROR   2019-07-11 09:51:41,130 [configuration] Mapping chain not found in the configuration properties file or given json structure. 'mock.url'
INFO    2019-07-11 09:51:41,150 [authentication] JWT: {'nonce': '1fa324asxqdsf', 'acr': '3', 'sub': u'50739', 'name': 'QA user', 'iat': 1562831501, 'iss': u'https://ai-services-pre-co.auracognitive.com/aura-services/v1/openid/issuer/', 'exp': 1562832501, 'amr': ['sms'], 'authentication_context': [{'identifier': u'+573167412035', 'type': u'phone_number'}], 'aud': [u'https://api.co-pre.baikalplatform.com']}
INFO    2019-07-11 09:51:43,834 [configuration] Mapping language param 'data_usage.question' to its configured value '{'en-gb': 'why do i experience slower speed when i browse?', 'es-ar': u'\xbfComprobar el uso actual de mi plan de datos m\xf3viles?', 'de-de': 'Zeig mir meinen Verbrauch vom Datenvolumen', 'es-cl': 'Consumo de datos', 'es-co': 'Consumo de datos actual', 'pt-br': u'Quantos dados celulares tenho dispon\xedveis?'}'
DEBUG   2019-07-11 09:51:43,837 [activities] Question asked: Consumo de datos actual
DEBUG   2019-07-11 09:51:43,866 [logger]
>>>>>>>>>>>>>>>>>>>>> Request >>>>>>>>>>>>>>>>>>>
	> Method: POST
	> Url: https://directline.botframework.com/v3/directline/conversations/Je9bvMoUJQa6qWPKf89xCd-j/activities
	> Headers:
{
    "Authorization": "Bearer ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogIkJPVC1hdXJhLXByZS1jbyIsDQogICJzaXRlIjogIjRndnB0b29xZTBZIiwNCiAgImNvbnYiOiAiSmU5YnZNb1VKUWE2cVdQS2Y4OXhDZC1qIiwNCiAgIm5iZiI6IDE1NjI4MzE1MDIsDQogICJleHAiOiAxNTYyODM1MTAyLA0KICAiaXNzIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyIsDQogICJhdWQiOiAiaHR0cHM6Ly9kaXJlY3RsaW5lLmJvdGZyYW1ld29yay5jb20vIg0KfQ.iQD6tVTKV2EYH70fBJIl10WwNh3h-1zM4ZTivsT4kZCfLDf67nG8-kmrLkcqme-ZaWDkkoPcJFLMLdthJo26Ef0KkVc9-eFZ7B5Su4z_m2vEiDWAuEP7AF7dQuYNBncMQ2PSq5jaeWz2xtbOwjbVOE2KeakkiaJhLvhQnZCRF7a7Jm7qXaH49VB3EQEef4cHjb6fY22YRMYhTPm8eCR_H4VcKAsff-Zw4qxUCShZ36FQRu1psZ1bbTBlgYyv04j0ix_0eUtGnA7a1aDFc5W9f2umcO-2TE3HBUmRtJcUcYnaqtEQIXoVe83ltBq_MvzXxJvyo3Hy5P6ZHWs8irMCdQ",
    "Content-Type": "application/json"
}
	> Payload sent:
{"text": "Consumo de datos actual", "channelData": {"imageMaxWidth": 480, "version": "0.3", "auraMode": {"fullAura": {"cards": "none", "voice": false}}, "allowed": ["commands", "handover"]}, "from": {"id": "26e29273-e928-4408-add1-b6bf0b499240", "name": "+573167412035"}, "type": "message", "timestamp": "Thu Jul 11 09:51:43 GMT+0200 2019"}
DEBUG   2019-07-11 09:51:43,867 [connectionpool] Starting new HTTPS connection (1): directline.botframework.com
DEBUG   2019-07-11 09:51:44,502 [connectionpool] https://directline.botframework.com:443 "POST /v3/directline/conversations/Je9bvMoUJQa6qWPKf89xCd-j/activities HTTP/1.1" 200 48
DEBUG   2019-07-11 09:51:44,512 [logger]
# Response 
	< Response code: 200
	< Headers:
{
    "Cache-Control": "no-cache",
    "Content-Length": "48",
    "Content-Type": "application/json; charset=utf-8",
    "Date": "Thu, 11 Jul 2019 07:51:44 GMT",
    "Expires": "-1",
    "Pragma": "no-cache",
    "Server": "Microsoft-IIS/10.0",
    "Strict-Transport-Security": "max-age=31536000",
    "x-ms-request-id": "|9cee4d1ebbcba0498d98da30e7c97348.9f932b10_"
}
	< Payload received:
{
  "id": "Je9bvMoUJQa6qWPKf89xCd-j|0000000"
}
INFO    2019-07-11 09:51:44,519 [activities] Getting bot response calling to activities endpoint
DEBUG   2019-07-11 09:52:08,347 [helpers]
# Response 
	< Response code: 200
	< Headers:
{
    "Cache-Control": "no-cache",
    "Content-Length": "5902",
    "Content-Type": "application/json; charset=utf-8",
    "Date": "Thu, 11 Jul 2019 07:52:06 GMT",
    "Expires": "-1",
    "Pragma": "no-cache",
    "Server": "Microsoft-IIS/10.0",
    "Strict-Transport-Security": "max-age=31536000",
    "x-ms-request-id": "|0afa06490259db4eaa4e31e8692fe060.2854829f_"
}
	< Payload received:
{
    "activities": [
        {
            "channelData": {
                "allowed": [
                    "commands",
                    "handover"
                ],
                "auraMode": {
                    "fullAura": {
                        "cards": "none",
                        "voice": false
                    }
                },
                "imageMaxWidth": 480,
                "version": "0.3"
            },
            "channelId": "directline",
            "conversation": {
                "id": "Je9bvMoUJQa6qWPKf89xCd-j"
            },
            "from": {
                "id": "26e29273-e928-4408-add1-b6bf0b499240",
                "name": "+573167412035"
            },
            "id": "Je9bvMoUJQa6qWPKf89xCd-j|0000000",
            "serviceUrl": "https://directline.botframework.com/",
            "text": "Consumo de datos actual",
            "timestamp": "2019-07-11T07:51:43.9546337Z",
            "type": "message"
        },
        {
            "channelData": {
                "hasMoreMessages": true
            },
            "channelId": "directline",
            "conversation": {
                "id": "Je9bvMoUJQa6qWPKf89xCd-j"
            },
            "from": {
                "id": "BOT-aura-pre-co",
                "name": "BOT-aura-pre-co"
            },
            "id": "Je9bvMoUJQa6qWPKf89xCd-j|0000001",
            "inputHint": "ignoringInput",
            "localTimestamp": "2019-07-11T07:51:48.562+00:00",
            "replyToId": "Je9bvMoUJQa6qWPKf89xCd-j|0000000",
            "text": "Te quedan 26.10 GB de datos de tu plan de 28 GB, hasta el 01/01/2038",
            "timestamp": "2019-07-11T07:51:48.6310043Z",
            "type": "message"
        },
        {
            "attachmentLayout": "carousel",
            "attachments": [
                {
                    "content": {
                        "actions": [
                            {
                                "title": "M\u00e1s detalles",
                                "type": "Action.OpenUrl",
                                "url": "https://web.movistar.com.co/_/account/redirect.php?target=subscription-dashboard"
                            }
                        ],
                        "body": [
                            {
                                "columns": [
                                    {
                                        "items": [
                                            {
                                                "type": "Image",
                                                "url": "https://stgfunctionspreco.blob.core.windows.net/static-resources/images/icn_assistant_data.png?sr=c&si=static-resources-policy-pre-co&sig=MkKm0NeX8MXcOU1qUtDqtepQusrnHh4YMDmOEvrUS4U%3D&sv=2018-03-28"
                                            }
                                        ],
                                        "type": "Column",
                                        "width": "auto"
                                    },
                                    {
                                        "items": [
                                            {
                                                "size": "medium",
                                                "text": "Datos",
                                                "type": "TextBlock",
                                                "weight": "bolder"
                                            }
                                        ],
                                        "type": "Column",
                                        "width": "auto"
                                    }
                                ],
                                "type": "ColumnSet"
                            },
                            {
                                "columns": [
                                    {
                                        "items": [
                                            {
                                                "altText": "74636f87-e35b-41f7-9d87-b73ca72ba9fa",
                                                "horizontalAlignment": "center",
                                                "id": "74636f87-e35b-41f7-9d87-b73ca72ba9fa",
                                                "type": "Image",
                                                "url": "https://stgfunctionspreco.blob.core.windows.net/aura-temporal-resources19071107/progress2Circles_1562831507956.png?st=2019-07-11T06%3A11%3A48Z&se=2019-07-11T08%3A16%3A48Z&sp=r&sv=2018-03-28&sr=b&sig=c3kKW26iwMwzGun%2FJ453FmmzA3mbc%2FWKc3QxTMRtgWU%3D"
                                            }
                                        ],
                                        "type": "Column"
                                    }
                                ],
                                "separator": true,
                                "spacing": "medium",
                                "type": "ColumnSet"
                            }
                        ],
                        "type": "AdaptiveCard",
                        "version": "1.0"
                    },
                    "contentType": "application/vnd.microsoft.card.adaptive"
                }
            ],
            "channelData": {
                "customData": {
                    "data": [
                        {
                            "74636f87-e35b-41f7-9d87-b73ca72ba9fa": [
                                {
                                    "max": {
                                        "amount": 28,
                                        "unit": "GB"
                                    },
                                    "of": "de",
                                    "progress": 0.06785714283718594,
                                    "remaining": {
                                        "amount": 26.100000000558794,
                                        "unit": "GB"
                                    },
                                    "usage": {
                                        "amount": 1.8999999994412065,
                                        "unit": "GB"
                                    }
                                },
                                {
                                    "endDate": "2038-01-02T04:59:59Z",
                                    "max": {
                                        "amount": 7028,
                                        "unit": "d\u00edas"
                                    },
                                    "progress": 0.039698349459305636,
                                    "remaining": {
                                        "amount": 6749,
                                        "unit": "d\u00edas"
                                    },
                                    "remainingText": "restante",
                                    "startDate": "2018-10-06T01:11:29Z",
                                    "usage": {
                                        "amount": 279,
                                        "unit": "d\u00edas"
                                    }
                                }
                            ]
                        }
                    ],
                    "type": "graphData"
                },
                "hasMoreMessages": false
            },
            "channelId": "directline",
            "conversation": {
                "id": "Je9bvMoUJQa6qWPKf89xCd-j"
            },
            "from": {
                "id": "BOT-aura-pre-co",
                "name": "BOT-aura-pre-co"
            },
            "id": "Je9bvMoUJQa6qWPKf89xCd-j|0000002",
            "inputHint": "acceptingInput",
            "localTimestamp": "2019-07-11T07:51:48.727+00:00",
            "replyToId": "Je9bvMoUJQa6qWPKf89xCd-j|0000000",
            "timestamp": "2019-07-11T07:51:48.7509824Z",
            "type": "message"
        }
    ],
    "watermark": "2"
}
...

Report XML file

📁 ~/[project_folder]/aura-tests/acceptance/_output/reports/1_[language]-[country]-[feature].xml

This file provides more general and complementary information regarding the QA Tool results: it identifies the step that is failing and in which feature (high level evaluation).

The result of this test can have three different status:

pass: tests are satisfactory.
skip: this status is achieved for tests that are not executed due to different internal reasons.
fail: tests are not satisfactory.

This test has the following general structure:

<?xml version='1.0' encoding='UTF-8'?>
<testsuite errors="0" failures="3" hostname="..." name="1_es-co_data_usage.Data Usage - Check data usage" skipped="28" tests="32" time="90.071549" timestamp="2019-07-30T13:23:19.913963">

Examples for the different status are shown below:

Example of FAIL test

<testcase classname="1_es-co_data_usage.Data Usage - Check data usage" name="Get the data usage of a postpaid user -- @1.1 users.data_usage.postpaid user logged with phone_number - [LANG:data_usage.question]" status="failed" time="29.682661"><failure message="Question asked: &quot;Consumo de datos actual&quot;&#10;Current response &quot;Te quedan 21.50 GB de datos de tu plan de 33 GB, hasta el 02/02/2029&quot; doesn´t match any of the &#10;Expected responses: [u'Conoce los servicios que tienes contratados']" type="AssertionError">
<![CDATA[
Failing step: And Message number "1" contains a text matching one of "services:services.usage.generic" ... failed in 0.014s
Location: features/end_to_end/novum/simplify/data_usage.feature:18
Assertion Failed: Question asked: "Consumo de datos actual"
Current response "Te quedan 21.50 GB de datos de tu plan de 33 GB, hasta el 02/02/2029" doesn´t match any of the 
Expected responses: [u'Conoce los servicios que tienes contratados']]]>
</failure><system-out>
<![CDATA[
@scenario.begin
  @smoke @TL.AUR-6748 @ap @ap_nov @ar @ar_nov @gb @gb_nov @br @br_nov @co @co_nov
  Scenario Outline: Get the data usage of a postpaid user -- @1.1 users.data_usage.postpaid user logged with phone_number - [LANG:data_usage.question]
    Given I have a users.data_usage.postpaid msisdn logged with phone_number ... passed in 21.850s
    And I have a valid AURA ID ... passed in 1.215s
    And I have started a conversation ... passed in 0.975s
    When I am prepared to ask a question ... passed in 0.009s
    And The following question is asked: "[LANG:data_usage.question]" ... passed in 0.746s
    Then The bot response is completed, that is, contains "3" messages ... passed in 4.867s
    And The response complies with the activities schema ... passed in 0.007s
    And Message number "1" contains a text matching one of "services:services.usage.generic" ... failed in 0.014s
    And Message number "2" contains a list "postpaid" of adaptive cards of type "data_usage" ... skipped in 0.000s
    And Message number "3" contains an actions card with suggestions of type: "check_data_usage" for: "postpaid" contract ... skipped in 0.000s
@scenario.end
-----------------------------------------------------------------------------

Example of SKIP test

</system-out></testcase><testcase classname="1_es-co_data_usage.Data Usage - Check data usage" name="Get the data usage in different situations of a postpaid user -- @2.4 postpaid data with 2.00 GB" status="skipped" time="0.0"><skipped /><system-out>
<![CDATA[
@scenario.begin
@ @TL.AUR-6082 @bug_br @ap @ap_nov @ar @ar_nov @br @br_nov @gb @gb_nov
  Scenario Outline: Get the data usage in different situations of a postpaid user -- @2.4 postpaid data with 2.00 GB
    Given I have a users.data_usage.data_round_2GB msisdn ... skipped in 0.000s
    And I have a valid AURA ID ... skipped in 0.000s
    And I have started a conversation ... skipped in 0.000s
    When I am prepared to ask a question ... skipped in 0.000s
    And The following question is asked: "[LANG:data_usage.question]" ... skipped in 0.000s
    Then The bot response is completed, that is, contains "3" messages ... skipped in 0.000s
    And The response complies with the activities schema ... skipped in 0.000s
    And Message number "1" contains a text matching one of "services:services.usage.summary" ... skipped in 0.000s
    And Message number "2" contains a list "postpaid.data.data_round_2GB" of adaptive cards of type "data_usage" ... skipped in 0.000s
    And Message number "3" contains an actions card with suggestions of type: "check_data_usage" for: "postpaid" contract ... skipped in 0.000s
@scenario.end
------------------------------------------------------------------------------

Example of PASS test

--------------------------
------------------------------------------------------------------------------
]]>
</system-out></testcase><testcase classname="1_es-co_data_usage.Data Usage - Check data usage" name="Try to get the data usage with a multimsisdn user with username -- @1.1 multimsisdn user - [LANG:data_usage.question]" status="passed" time="19.751802"><system-out>
<![CDATA[
@scenario.begin
  @smoke @ap @ap_nov @ar @ar_nov @gb @gb_nov @co @co_nov
  Scenario Outline: Try to get the data usage with a multimsisdn user with username -- @1.1 multimsisdn user - [LANG:data_usage.question]
    Given I have a users.multimsisdn.postpaid msisdn logged with username ... passed in 15.484s
    And I have a valid AURA ID ... passed in 1.237s
    And I have started a conversation ... passed in 0.992s
    When I am prepared to ask a question ... passed in 0.009s
    And The following question is asked: "[LANG:data_usage.question]" ... passed in 0.703s
    Then The bot response is completed, that is, contains "1" messages ... passed in 1.309s
    And The response complies with the activities schema ... passed in 0.004s
    And A single message contains a text matching one of "context-filter:user-type-not-allowed.text" ... passed in 0.013s
@scenario.end
--------------------------------------------------------------------------------
]]>
</system-out></testcase></testsuite>

Allure Report

To generate the Allure report, run the following command:
$ allure serve ./_output/allure

The execution of this command generates a report in a temporary folder with data found in the provided path and then creates a local server instance, serves the generated report and opens it in the default browser.

Each Allure report contains a tree-like data structure that represents the test execution process. Different tabs allow to switch between the views of the original data structure, thus giving a different perspective: overview tab, navigation bar, several tabs for different types of data representation and test case pages for each individual test.

If you do not have Allure installed, access this link and follow the instructions: https://docs.qameta.io/allure/#_installing_a_commandline

⚠️ Allure is a third party tool and no support is provided by the Aura Global Team.

An example of the content of an Allure report is included below:

Overview page

The entry point for every report would be the overview page, that includes relevant dashboards and widgets:

The overview page hosts several default widgets representing basic characteristics of the project and test environment. Navigation bar is collapsible and enables to switch into several basic results overview modes.

Detail

Tests are shown grouped by features, through clicking “show all” or “Behaviors” from the overview page:

Test case page

For some of the results in the overview page described above, it is possible to access to the test case page after clicking on the individual tests. This page will typically contains relevant individual data related to the test case: steps executed during the test, timings, attachments, test categorization labels, descriptions and links.

Users’ files

📁 ~/[project_folder]/aura-tests/acceptance/_output/users/[country]/[userid].json Users’ data are contained in the Telefónica Kernel APIs. When the QA tests are executed, the system recovers the data and stores it in these JSON files.

Example of Telefonica Kernel data user JSON file

{
    "bundle_list": [
        {
            "date": "regex:[0-9]{1,2} de [a-zA-Zç]+ de [0-9]{4}", 
           "name": "Plan Prepago *", 
           "desc": ": InternetXdiaPlus$14 x50MB, HABLÁ: Si elegiste HABLÁ tenés un 50% de descuento en llamadas a Movistar por 7 días con tus recargas desde $6"
        }
    ], 
   "bills": [], 
   "roles": [
        "owner", 
       "admin"
    ], 
   "subscription_type": "prepaid", 
   "msisdn": "+541136742577", 
   "userid": "126529396", 
   "user_type": "monomsisdn", 
   "setup_4g_ready": [
        {
            "suggestion_des": "Tu telefono es 4G, por favor revisa tu configuracion aca", 
           "result_tm": "2029-01-24", 
           "description1_des": "http://ayuda.movistar.com.ar/pregunta/como-configurar-mi-equipo-en-la-red-4g.html", 
           "result_dt": ""
        }
    ], 
   "data_usage": [
        {
            "suggestion_des": "De acuerdo a tu patron de consumo, te recomiendo el plan Plan Comunidad 1 GB", 
           "result_tm": "2029-01-20 00:00:00.0", 
           "end_data_day_dt": null, 
           "additional_info_des": null, 
           "consumed_qt": "44.923", 
           "contracted_qt": "524288000", 
           "anomaly_ind": false
        }
    ], 
   "services": [
        "mobile_prepaid"
    ], 
   "device_recommender": [], 
   "balance": {
        "date": "[0-9]{1,2} de [a-zA-Zç]+ de [0-9]{4}", 
       "currency": "ARS", 
       "amount": "\\$ [0-9]+,[0-9]+"
    }, 
   "data": [], 
   "email": "MEDINA.M1990@GMAIL.COM"
}

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Upgrade Aura bot to node 18 and its dependencies

Guidelines for the upgrade of aura-bot to node 18 and the update of its major dependencies, in order to avoid end-of-life of current versions

Introduction

Current version of node being used is 14 LTS, that finished active support in October 2021 and security support in April 2023. In order to avoid the inconveniences of working with an old version, without security updates, we will update to current latest LTS version 18, with active support until October 2023 and security support until April 2025.

Moreover, some major dependencies are also upgraded in order to keep the latest available versions, with new features and security updates.

:warning:

The upgrade of node and dependencies in aura-bot comes together with the migration to Bot Framework 4.19..

The latter implies that local use cases must be migrated to this new version to be operative. For this purpose, OBs must follow the guidelines Migrate use cases to Bot Framework 4.19.

Guidelines for upgrade

In this section, a list of mandatory and recommended changes will be explained, but consider applying them both, as it will prevent future incompatibilities.

Mandatory changes

Docker base

Docker base image was changed from node:14.17.1-alpine3.13 to node:18.16.0-alpine3.17, in bot Dockerfile and mini-bot Dockerfile. If using a different container on deploys, it must be upgraded to node 18.

Internally, the jenkins slave was set to aura-node18-ubuntu22 on Jenkinsfile (only affects to the global team).

Node types update

Package with node types must be upgraded to version 18 in the package.json file:

{
    "@types/node": "^18.16.0"
}

Upgrade Typescript

Typescript was upgraded in aura-bot to version 5, so it must be also upgraded in all packages and libraries. For this purpose, modify the typescript dependency in the required package.json files:

{
    "typescript": "~5.0.0"
}

Update package-lock.json

After upgrading node version to 18, npm is also upgraded to version 9.5.1, and the package-lock.json is obsolete. Running a one-time npm install will upgrade lockfileVersion to 3, and the required content, such as sha512 integrity hashes instead of sha1.

It is also recommended to delete the whole file package-lock.json before npm install, to upgrade also dependencies to newer versions.

Recommended changes

In this section, other optional upgrades are shown, highly recommended in order to avoid future compatibility problems. We encourage applying them, in addition to the mandatory changes.

mongodb-memory-server

It is recommended to upgrade mongodb-memory-server to the latest version 8.12.2, due to deprecation of current version and, moreover, in order to prepare the code to near future upgrade of MongoDB (from version 4 to version 6). The upgrade requires a minimal code update.

npm-check-updates

It is also recommended to upgrade npm-check-updates to latest version 16.10.9, as current version has a transitive dependency with an obsolete node-gyp that causes incompatibility when using Python >= 3.11, that is the default version in Ubuntu 22.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Use cases flowcharts

Key operational flowcharts for different types of use cases such as TV, generic questions, etc.

Message generic questions use case

Generic questions use cases are based on frequently asked questions (FAQs).

These experiences are valid for anonymous users, so the example is provided with an anonymous user, but are also valid for authenticated users, in this case, when entering aura-bot the authentication steps should be executed.

Please, refer to Direct Line basic flows for authenticated users to check the differences. The example is provided using Direct Line, but it is also available for the rest of types of channels: WhatsApp or Auraline.

@startuml
title: User message that is recognized as a FAQ
    actor User
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 

    Channel -> DirectLineWebsocket: Open WebSocket
    User -> Channel: Send [Phrase that starts FAQ dialog]
    Channel -> DirectLine: Send {activity[Phrase that starts FAQ dialog]}
    DirectLine -> AuraGroot: Send {activity[Phrase that starts FAQ dialog]}
    AuraGroot -> DirectLine: 200 OK
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {activity[Phrase that starts FAQ dialog]}
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuthenticationApi: GET AuraId
    AuthenticationApi -> AuraBot: 404 Not found (Anonymous)
    AuraBot -> AuraBot: Middlewares
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute FAQ dialog
    AuraBot -> AuraBot: filterFaqWithContext(faq, user, channelData.contextFilters)
    AuraBot -> AuraGroot: Send {faqResponse}
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> DirectLine: Send {faqResponse}
    DirectLine -> AuraGroot: 200 OK
    Channel -> DirectLineWebsocket: Read {faqResponse}
    Channel -> User: Show {faqResponse}
@enduml

User message that leads to a dialog that needs an asynchronous API request to be resolved

This experience is defined in the guidelines for building a dialog that uses async APIs.

The example is provided using WhatsApp, but is also available for the rest of types of channels: DirectLine or Auraline.

@startuml
title: Use case handling asynchronous requests
    actor User
    participant WhatsApp #f6b5ff
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant AuraBridge #1add4d
    participant AuraBridgeOutbound #1add4d
    participant KernelWhatsAppApi #99FFFF
    participant AsyncApi #fc989b

    User -> WhatsApp: Request [message]
    WhatsApp -> KernelWhatsAppApi: Request [message]
    KernelWhatsAppApi -> AuraBridge: Request [message]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuthenticationApi: GET AuraId
    AuthenticationApi -> AuraGroot: 200 OK {UserData}
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: See Basic WhatsApp flow for authenticated users
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute dialog that calls to an asynchronous API
    AuraBot -> AuraBot: The dialog inits bypass
    AuraBot -> AsyncApi: POST request
    AsyncApi -> AuraBot: 200 OK
    AsyncApi -> AuraBridge: POST async-callback/notifications with response data
    AuraBridge -> AsyncApi: 200 OK
    AuraBridge -> AuraGroot: Send [payload with response data]
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraBot: Send [payload with response data]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Back to the dialog that opened the bypass
    AuraBot -> AuraBot: Process [payload with response data]
    AuraBot -> AuraGroot: Send [async request response]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Response to [message]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Response to [message]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Response to [message]
    WhatsApp -> User: Show response to [message]
@enduml

Message use case that receives files from the user

This experience is defined in the guidelines for using files in WhatsApp use cases.

The example is provided using WhatsApp, which is currently the only channel able to handle incoming files.

@startuml
title: Use case expecting files from the user
    actor User
    participant WhatsApp #f6b5ff
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant AuraBridge #1add4d
    participant AuraBridgeOutbound #1add4d
    participant KernelWhatsAppApi #99FFFF
    participant FileManager #fae193
    participant AzureStorage #dedddb

    User -> WhatsApp: Request [message]
    WhatsApp -> KernelWhatsAppApi: Request [message]
    KernelWhatsAppApi -> AuraBridge: Request [message]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuthenticationApi: GET AuraId
    AuthenticationApi -> AuraGroot: 200 OK {UserData}
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: See Basic WhatsApp flow for authenticated users
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute dialog that requests a file from the user
    AuraBot -> AuraBot: The dialog inits bypass
    AuraBot -> AuraGroot: Send [Provide a file]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Response to [Provide a file]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Response to [Provide a file]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Response to [Provide a file]
    WhatsApp -> User: Show [Provide a file]
    User -> WhatsApp: Send [requested file]
    WhatsApp -> KernelWhatsAppApi: Request [requested file]
    KernelWhatsAppApi -> AuraBridge: Request [requested file]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [requested file]
    Note over AuraBridge,AuraGroot: file is sent as an Attachment to the bot
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [activity[attachment[file]]]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: See Basic WhatsApp flow for authenticated users
    AuraBot -> AuraBot: Middleware that handles file attachments
    AuraBot -> AuraBot: check that a dialog was waiting for a file
    AuraBot -> FileManager: POST manage(file)
    FileManager -> AuraBot: 200 OK
    FileManager -> KernelWhatsAppApi: GET /media/file
    Note right of FileManager: In fact, file is passed by streaming from WhatsApp media API to Azure Storage
    KernelWhatsAppApi -> FileManager: 200 OK {fileStream}
    FileManager -> FileManager: validate(file)
    FileManager -> AzureStorage: POST upload(file)
    AzureStorage -> FileManager: 201 Created
    FileManager -> AuraBridge: POST async-callback/notifications with file validation data
    Note over FileManager,AuraBridge: FileManager response contains the file validation\nand the local Azure Storage URL where the file can be obtained.
    AuraBridge -> FileManager: 200 OK
    AuraBridge -> AuraGroot: Send [payload with file validation data]
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraBot: Send [payload with file validation data]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Back to the dialog that waits for a file
    AuraBot -> AuraBot: Process [payload with file validation data]
    AuraBot -> AuraGroot: Send [file response]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Response to [file response]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Response to [file response]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Response to [file response]
    WhatsApp -> User: Show response to [file response]
@enduml

TV use cases

Currently, TV use cases are only available for authenticated users.

TV use case for channels with integration with channelData v3

Operational flow for TV use cases in channels integrated with channelData v3.

@startuml
title: TV use case for channelData V3
    actor User
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant ComplexLogicApi #CCCCFF
    participant KernelVideoContentsApi #99FFFF

    Channel -> DirectLineWebsocket: Open WebSocket
    User -> Channel: Send [I want to see an action movie]
    Channel -> DirectLine: Send {activity[I want to see an action movie]}
    DirectLine -> AuraGroot: Send {activity[I want to see an action movie]}
    AuraGroot -> DirectLine: 200 OK
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {activity[I want to see an action movie]}
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Basic DirectLine flow for authenticated users
    AuraBot -> AuraBot: Middlewares
    AuraBot -> AuraBot: Recognizers intent.tv.search
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute intent.tv.search Dialog
    AuraBot -> ComplexLogicApi: POST tv/query {intent: intent.tv.search, entities: movie, action}
    ComplexLogicApi -> KernelVideoContentsApi: GET /videocontents filter by user context and entities
    KernelVideoContentsApi -> ComplexLogicApi: 200 OK [{videoContent}]
    ComplexLogicApi -> AuraBot: 200 OK [{videoContent}]
    AuraBot -> AuraGroot: Send [{videoContent}]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> DirectLine: Send [{videoContent}]
    DirectLine -> AuraGroot: 200 OK
    Channel -> DirectLineWebsocket: Read [{videoContent}]
    Channel -> User: Show [{videoContent}]
@enduml

TV use case for channels with integration with channelData v1

Operational flow for TV use cases in channels integrated with channelData v1.

This scenario is only available in Spain.

@startuml
title: TV use case for channelData V1
    actor User
    participant Channel #bdf492
    participant DirectLine #FFCC99
    participant DirectLineWebsocket #FFCC99
    participant AuthenticationApi #FFFF99
    participant AuraGroot #76bbe7
    participant AuraBot #41a0f9 
    participant MovistarResolutionApi #CCCCFF
    participant KernelLegacyVideoApi #99FFFF

    Channel -> DirectLineWebsocket: Open WebSocket
    User -> Channel: Send [I want to see an action movie]
    Channel -> DirectLine: Send {activity[I want to see an action movie]}
    DirectLine -> AuraGroot: Send >{activity[I want to see an action movie]}
    AuraGroot -> DirectLine: 200 OK
    AuraGroot -> AuraGroot: Middlewares
    AuraGroot -> AuraGroot: Recognizers (GetSkillByChannel)
    AuraGroot -> AuraBot: Send {activity[I want to see an action movie]}
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Basic DirectLine flow for authenticated users
    AuraBot -> AuraBot: Middlewares
    AuraBot -> AuraBot: Recognizers intent.tv.search
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute intent.tv.search Dialog
    AuraBot -> MovistarResolutionApi: POST tv/query {intent: intent.tv.search, entities: movie, action}
    MovistarResolutionApi -> KernelLegacyVideoApi: GET /video filter by user context and entities
    KernelLegacyVideoApi -> MovistarResolutionApi: 200 OK [{videoContent}]
    MovistarResolutionApi -> AuraBot: 200 OK {[{videoContent}], [{suggestion}]}
    AuraBot -> AuraGroot: Send {[{videoContent}], [{suggestion}]}
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> DirectLine: Send {[{videoContent}], [{suggestion}]}
    DirectLine -> AuraGroot: 200 OK
    Channel -> DirectLineWebsocket: Read {[{videoContent}], [{suggestion}]}
    Channel -> User: Show {[{videoContent}], [{suggestion}]}
@enduml

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Databricks Jobs user guide

Guidelines including the orderly steps to use Aura Databricks Jobs

Prerequisites

Python version 3.9 or higher.

# determine python version
python --version

Installed aura-pytraces: Aura repository for Python traces functionalities.
Prerequisites in Aura installer:
- Databricks must be enabled in Aura installer
- Databricks cluster node type must be configured
- Databricks job execution must be configured
Configure Kernel datasets. See more details in Kernel datasets configuration.

Flow

The flow that aura-databricks-jobs follows to validate if it is going to be executed is as follows:

Generate Reports

By default, aura-databricks-jobs generates a report in the import process. This report is available in the Azure Storage defined in AURA_MICROSOFT_AZURE_STORAGE_COMMON_ACCOUNT, and path AURA_KPI_AVRO_REPORTS_DESTINATION_PATH with the file name: aura-avro-kpis-report-{iso-date}.json.

If you want to change the behavior and generate reports of all uploaded files or disable their generation, you can do it by changing the environment variable AURA_KPIS_REPORTS_MODE. If the value is set to all, it will generate a report for each of the processed files, if it is set to none, it will not generate any report and if it set to error, the report will be generated only when there are errors in the process. The default value is all.

3.1 Report Model

A report will contain the following template in JSON format.

{
    "num_files_kernel_uploaded": 30,
    "num_files_moved_to_processed": 30,
    "num_files_deleted": 30,
    "num_files_skipped": 0,
    "num_errors": 0,
    "summary": {
        "D_Aura_Channel": {
            "dataset_id": "D_Aura_Channel",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Channel",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "8fb3e408-2ce0-42f4-8bbf-5b0974b44108",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 116,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 14640,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 116,
                    "local_spark_records_written_total": 116,
                    "total_not_informed_records_written": 0,
                    "records_written": 116,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 4796
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_Channel/6.0.0/CR_DIM_CHANNEL_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_Channel/6.0.0/CR_DIM_CHANNEL_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_Channel/6.0.0/CR_DIM_CHANNEL_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_Channel/6.0.0/CR_DIM_CHANNEL_20241017T100000Z.avro"
            ],
            "duration_seconds": 141.32
        },
        "D_Aura_Recognizer": {
            "dataset_id": "D_Aura_Recognizer",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Recognizer",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "415fb219-6ef4-4b21-9e14-c10347f1d2fa",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 376,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 49744,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 376,
                    "local_spark_records_written_total": 376,
                    "total_not_informed_records_written": 0,
                    "records_written": 376,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 9055
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_Recognizer/6.0.0/CR_DIM_RECOGNIZER_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_Recognizer/6.0.0/CR_DIM_RECOGNIZER_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_Recognizer/6.0.0/CR_DIM_RECOGNIZER_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_Recognizer/6.0.0/CR_DIM_RECOGNIZER_20241017T100000Z.avro"
            ],
            "duration_seconds": 94.75
        },
        "D_Aura_Component": {
            "dataset_id": "D_Aura_Recognizer",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Component",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "340c90a8-00d5-4868-a746-5ec0f8342a90",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 28,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 2108,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 28,
                    "local_spark_records_written_total": 28,
                    "total_not_informed_records_written": 0,
                    "records_written": 28,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 1255
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_Component/6.0.0/CR_DIM_COMPONENT_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_Component/6.0.0/CR_DIM_COMPONENT_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_Component/6.0.0/CR_DIM_COMPONENT_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_Component/6.0.0/CR_DIM_COMPONENT_20241017T100000Z.avro"
            ],
            "duration_seconds": 105.14
        },
        "D_Aura_Skill": {
            "dataset_id": "D_Aura_Skill",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Skill",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "60da9e25-0767-4097-ab9a-2bf388d8daa7",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 16,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 1280,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 16,
                    "local_spark_records_written_total": 16,
                    "total_not_informed_records_written": 0,
                    "records_written": 16,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 1246
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_Skill/6.0.0/CR_DIM_SKILL_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_Skill/6.0.0/CR_DIM_SKILL_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_Skill/6.0.0/CR_DIM_SKILL_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_Skill/6.0.0/CR_DIM_SKILL_20241017T100000Z.avro"
            ],
            "duration_seconds": 95.97
        },
        "D_Aura_Preset": {
            "dataset_id": "D_Aura_Preset",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Preset",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "8b143625-9bf7-484a-8a05-671a6cff72fe",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 64,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 5020,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 64,
                    "local_spark_records_written_total": 64,
                    "total_not_informed_records_written": 0,
                    "records_written": 64,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 2001
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_Preset/6.0.0/CR_DIM_PRESETS_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_Preset/6.0.0/CR_DIM_PRESETS_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_Preset/6.0.0/CR_DIM_PRESETS_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_Preset/6.0.0/CR_DIM_PRESETS_20241017T100000Z.avro"
            ],
            "duration_seconds": 72.97
        },
        "D_Aura_App": {
            "dataset_id": "D_Aura_App",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 4,
            "num_files_moved_to_processed": 4,
            "num_files_deleted": 4,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_App",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "f99b5dac-47ce-4525-aa86-6d3bbb3b67f5",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 28,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 5192,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 28,
                    "local_spark_records_written_total": 28,
                    "total_not_informed_records_written": 0,
                    "records_written": 28,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 2742
                }
            },
            "files_uploaded": [
                "avro_test/dimensional/D_Aura_App/6.0.0/CR_DIM_APP_20241017T070000Z.avro",
                "avro_test/dimensional/D_Aura_App/6.0.0/CR_DIM_APP_20241017T080000Z.avro",
                "avro_test/dimensional/D_Aura_App/6.0.0/CR_DIM_APP_20241017T090000Z.avro",
                "avro_test/dimensional/D_Aura_App/6.0.0/CR_DIM_APP_20241017T100000Z.avro"
            ],
            "duration_seconds": 93.86
        },
        "Aura_Audit": {
            "dataset_id": "Aura_Audit",
            "schema": "entity",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 2,
            "num_files_moved_to_processed": 2,
            "num_files_deleted": 2,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "Aura_Audit",
                "version": 6,
                "correlator": "55fc318d-b9cd-4070-ae6e-0407ef4b871e",
                "resource_id": "3013424c-4ef1-4bdb-b4fc-a02540f9b1f8",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 63,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 12452,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [
                        [
                            [
                                "DAY_DT",
                                "2024-10-04"
                            ]
                        ],
                        [
                            [
                                "DAY_DT",
                                "2024-10-07"
                            ]
                        ]
                    ],
                    "total_malformed_records_written": 0,
                    "total_malformed_records_by_column_written": [],
                    "total_records_by_partition_written": [
                        [
                            "DAY_DT=2024-10-04",
                            53
                        ],
                        [
                            "DAY_DT=2024-10-07",
                            10
                        ]
                    ],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 63,
                    "local_spark_records_written_total": 63,
                    "total_not_informed_records_written": 0,
                    "records_written": 63,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 6854
                }
            },
            "files_uploaded": [
                "avro_test/entity/Aura_Audit/6.0.0/AURA_062a0ab0-d0bd-5347-98bf-d88977af622f_CR_AUDIT_20241007T090000Z.avro",
                "avro_test/entity/Aura_Audit/6.0.0/AURA_1d43887a-f368-51ce-abee-60f5b25387ad_CR_AUDIT_20241004T110000Z.avro"
            ],
            "duration_seconds": 100.70
        },
        "Aura_Gateway_Message": {
            "dataset_id": "Aura_Gateway_Message",
            "schema": "entity",
            "version": "6.0.0",
            "step": "NOT_PROCESSED",
            "num_files_kernel_uploaded": 0,
            "num_files_moved_to_processed": 0,
            "num_files_deleted": 0,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {},
            "files_uploaded": [],
            "duration_seconds": 0.07
        }
    },
    "start_time": "2024-10-23T15:18:30.098166Z",
    "end_time": "2024-10-23T15:36:57.161532Z",
    "duration_seconds": 1107.06,
    "step": "FINISH",
    "status": "successfully"
}

The parameters are defined as follows:

dataset_id: Kernel dataset id to load.
schema: Type of schema to load.
version: Dataset version to load.
step: Stage of loading process. It could be:
- INIT: In this stage, the necessary Azure and Spark connections are created and a report is created.
- CHECK_PREVIOUS_ERRORS: In this stage, it is checked if there were errors in the last execution; the errors of the datasets that cannot be recovered are marked and those that can be recovered will be executed again.
- WRITING_KERNEL_STAGE: Stage for reading files and writing data to the Kernel datasets.
- MOVING_PROCESSED_BLOBS_STAGE: Stage for moving files to the processed folder.
- FINISH: This stage indicates that the process has been completed.
num_files_kernel_uploaded: Number of files that have been verified as successfully uploaded in Kernel Datalake.
num_files_moved_to_processed: Number of files that have been moved to the processed folder.
num_files_deleted : Number of files that have been deleted from the main folder.
num_files_skipped: Number of files that have been skipped. This is because they have not yet been processed due to match with pattern defined in job’s variable: AURA_KPI_AVRO_SCHEMAS_NOT_TO_UPLOAD
num_errors: Total of errors reported. It may indicate an error when loading the source files contained in one of the Avro-formatted folders. So it does not correspond to the number of erroneous files.
start_time: Date in ISO format with start time
end_time: Date in ISO format with end time
duration_seconds: duration in seconds of the import process.
status: It contains the status of process. The value will be failed or successfully.

summary: It contains the information of each coroutine processed that is responsible for loading a folder with files that have the same Avro schema and the same version. If there is a general error prior to the coroutines, it will also appear in the summary in the process_error field. It contains for each dataset id:

num_files_kernel_uploaded: Number of files that have been verified as successfully uploaded in Kernel Datalake for this dataset id.
num_files_moved_to_processed: Number of files that have been moved to the processed folder for this dataset id.
num_files_deleted: Number of files that have been deleted from the main folder for this dataset id.
num_errors: Number of errors reported for this dataset id.
errors: Produced errors for this dataset id. With elements: error, corr, step.
- error: Description or exception of error obtained.
- corr: Correlator used in process.
- step: It indicates the phase of the process for each Kernel dataset.
  - MOVING_BLOBS_TO_PROCESSED_WITH_PREVIOUS_ERRORS: In this stage, the processed files that were pending to move due to an error are now moved.
  - REMOVING_BLOBS_WITH_PREVIOUS_ERRORS: In this stage, the processed files that were pending to be deleted due to an error are now deleted.
  - NOT_PROCESSED_PREVIOUS_ERRORS: Errors that occurred in a previous process that are not recoverable. For example, if the writing has malformed or discarded records, they must be reviewed manually and should not be written to the dataset. Or if after trying to move the files to be processed again they fail again, it would be necessary to specifically check what happens with those files.
  - READING_BLOBS: In this stage, the files are read to create data to be written to the dataset.
  - WRITING_DATASET: This stage proceeds to write data to the dataset.
  - WRITING_DATASET_OK: At this stage, the data has already been correctly written to the dataset.
  - WRITING_DATASET_ERROR_NOT_RECOVERABLE: In the writing process, malformed or discarded records have been detected that must be checked manually.
  - MOVING_BLOBS_TO_PROCESSED: At this stage, the files are moved to the processed folder.
  - REMOVING_BLOBS: At this stage, the files are deleted from the processed folder.
  - NOT_PROCESSED: The dataset has no data and will not be processed.
  - FINISH: The dataset uploading has been completed correctly.
spark_executions: Spark report for that dataset id. Included info such as records read, written, discarded, etc.
files_uploaded: List of files that have been uploaded in Kernel for this dataset id.

Example of one coroutine executed for ´D_Aura_Channel´ dataset:

{
  "D_Aura_Channel": {
            "dataset_id": "D_Aura_Channel",
            "schema": "dimensional",
            "version": "6.0.0",
            "step": "FINISH",
            "num_files_kernel_uploaded": 156,
            "num_files_moved_to_processed": 156,
            "num_files_deleted": 156,
            "num_files_skipped": 0,
            "num_errors": 0,
            "errors": [],
            "spark_executions": {
                "dataset_id": "D_Aura_Channel",
                "version": 6,
                "correlator": "d558b080-f261-4e6b-9adc-a7503f3e51a9",
                "resource_id": "36417c66-a276-4107-bcb8-3792bccb076c",
                "request_type": "writes",
                "status": "finished",
                "metrics": {
                    "total_records_written": 4967,
                    "local_spark_write_discards": 0,
                    "local_spark_write_discards_total": 0,
                    "malformed_records_written": 0,
                    "total_records_filtered_by_gdpr": 0,
                    "local_spark_bytes_written_total": 4049495,
                    "total_malformed_records_by_partition_written": [],
                    "partitions_written": [],
                    "total_malformed_records_written": 0,
                    "total_records_by_partition_written": [],
                    "total_not_informed_records_by_partition_written": [],
                    "records_read": 4967,
                    "local_spark_records_written_total": 4967,
                    "total_not_informed_records_written": 0,
                    "records_written": 4967,
                    "total_malformed_records_discarded": 0,
                    "records_discarded": 0,
                    "data_access_audit": {
                        "partitions_num": 1,
                        "wasb_type": "avro_fp"
                    },
                    "total_executor_cpu_millis": 1,
                    "total_executor_memory": 593913446,
                    "total_bytes_written": 394038
                }
            },
            "duration_seconds": 112.05
        }
}

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Aura Clients

Description of aura-clients

Introduction

aura-clients is a package belonging to aura-common-utilities that includes tools that make easier to call APIs.

Find more information in the Github repository: https://github.com/Telefonica/aura-common-utilities/tree/master/packages/aura-clients/

How to install aura-clients package

$ git clone https://github.com/Telefonica/aura-clients.git

$ cd aura-common-utilities/packages/aura-clients

How to import an utility from this package

To import an utility from the aura-clients package, execute the following command:

import { ... } from '@telefonica/aura-clients/lib/[*client-name*]';

For example:

import { ChannelConfiguration } from '@telefonica/aura-clients/lib/aura-configuration-api-client';

Available aura-clients

Find the current aura-clients, both internal or external ones in Aura API clients.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA General RAG operational workflow

ATRIA technical operational flow corresponding to the operation of the RAG capability, specifically to the so-named General RAG predefined chain.

Flow diagram

Calls to the atria-rag-server component (AtriaRAG in the sequence diagram) executes the predefined RAG chain General RAG.


@startuml
title RAG API diagram
participant Application
participant Kernel #1add4d
participant AuraGatewayApi #76bbe7
participant AtriaModelGateway #f58e11
participant AtriaRAG #f5de11
participant AzureOpenAI #9476e7

Application -> Kernel: Create two-legged token with scope aura-aiservices:messaging:write
Note right of Kernel: this token needs refreshing
Kernel -> Application: Response two-legged token
Application -> Kernel: Request to aura-aiservices/generative/prompts with token and correlatorId (x-correlator)
Kernel -> AuraGatewayApi: Request to aiservices/generative/prompts with token-info header and correlatorId
AuraGatewayApi -> AuraGatewayApi: Validate request
AuraGatewayApi -> AuraGatewayApi: Generate prompt
AuraGatewayApi -> AtriaModelGateway: Send prompt to atria-model-gateway
activate AtriaModelGateway
AtriaModelGateway -> AtriaRAG: 1.0: Enrich request 
activate AtriaRAG
AtriaRAG -> AtriaRAG: securityStg

opt translateStg.enabled == true
    AtriaRAG -> AtriaRAG: 1.1: Translate user query 
    AtriaRAG -> AtriaModelGateway: Send request to LLM 
    AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
    AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
    AtriaModelGateway --> AtriaRAG: LLM response with translated query
end
opt cleanStg.enabled == true
    AtriaRAG -> AtriaRAG: 1.2: Clean the user query 
    AtriaRAG -> AtriaModelGateway: Send request to LLM 
    AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
    AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
    AtriaModelGateway --> AtriaRAG: LLM response with new cleaned query

end
opt contextStg.enable == true
    alt Ask LLM
        AtriaRAG -> AtriaModelGateway: 1.3: Request LLM to validate the conversational context
        AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
        AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
        AtriaModelGateway --> AtriaRAG: LLM response [SAME CONTEXT] or [DIFFERENT CONTEXT]
        AtriaRAG -> AtriaRAG: Recreate Query
    end
    alt Recreate Query 
        AtriaRAG -> AtriaModelGateway: 1.4: Call LLM to generate new question 
        AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
        AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
        AtriaModelGateway --> AtriaRAG: Response with new question
    end
end

AtriaRAG -> AtriaRAG: retrievalStg

opt postFilteringStg.enable == true
    AtriaRAG -> AtriaRAG: Post Filtering 
    note right: Batch request
    AtriaRAG -> AtriaModelGateway: 1.5: Request LLM for each chunk 
    AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
    AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
    AtriaModelGateway --> AtriaRAG: LLM response [RELEVANT] or [IGNORABLE]
end

AtriaRAG -> AtriaModelGateway: 1.6: Request LLM generativeStg 
AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI 
AtriaModelGateway --> AtriaRAG: LLM response
AtriaRAG --> AtriaModelGateway: 2: Final response 
deactivate AtriaRAG
deactivate AtriaModelGateway

AtriaModelGateway -> AuraGatewayApi: Response Model Gateway
AuraGatewayApi -> AuraGatewayApi: process atria-model-gateway response
AuraGatewayApi -> AuraGatewayApi: generate response
AuraGatewayApi -> Kernel: response 200 and message with session_id
Kernel -> Application: response 200 and message with session_id

@enduml

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Guidelines for OBs

Guidelines for OBs to allow the generation of datasets from their Aura users logs in local environment

Introduction

As seen in the Aura Analytics 2.0.0 architecture flowchart, Aura Analytics 2.0.0 contains two different environments: the OB local environment, managed by the OB and the Global one, managed by Aura Global Team.

Within this framework, the current guidelines are tailored towards OBs, indicating how to install and execute the PPD-Creator, for the creation and processing of PPD RAW datasets.

Once it is carried out, the subsequent processes of Aura Analytics 2.0.0 are executed in global environment by Aura Global Team.

Installation of PPD-Creator

The OB must install and store the PPD-Creator in a specific destination blob PPD-RAW and is responsible for its execution.

Guidelines are included in installer Aurak8s documentation: Active listening deployment.

Execution of PPD-Creator

The execution of the PPD-Creator must be done by the OBs, previous to its installation.

Parameters to launch the PPD-Creator

These are the parameters that the PPD-Creator takes from Kernel:

Mandatory parameters:

Parameter	Description	Example
`--src-type`	Source type	‘aws’, ’local’, ‘azure’
`--src-name`	Source folder name (raw files)	`/directory/data/`
`--dst-type`	Destination type	‘aws’, ’local’, ‘azure’
`--dst-name`	Destination folder name (raw files processed)	`/directory/data/output`
`--country`	Customize for a lang_country pair	es
`--table`	Table to process {message, grootmessage, recognizer, api}	MESSAGE
`--environment`	Environment to process (ap-one, ap-two, prod)	ap-one
OPERATIONS
`--transfer`	File processing: transfer, anonymize and group files
`--copy`	Raw file copy – no processing
`--copy-fix`	File copy + apply small fixes
`--show`	Show available files; no action performed

Optional parameters:

Parameter	Description
`--src-user`	Access key for the source folder
`--src-pass`	Source access secret
`--src-encryption`	Encryption key for data in source
`--dst-user`	Access key for the destination folder
`--dst-pass`	Destination access secret
`--dst-encryption`	Encryption key for data in destination
`--cloud-type`	Cloud type (‘aws’,’azure’)
`--dry-run`	Process dry-run: no action performed
`--reraise`	Re-raise exceptions on errors
`--options-file`	Read additional options from a file in dest repo
`--verbose`	Verbose level
`--console`	Act as a console app (format logs as console messages, raise on errors)
`--dest-log-skip`	Do not write the logfile at the destination folder
`--dest-log-dir`	Logging subdirectory at destination
`--show-input`	Print out input arguments
`--anon-key/ encryption-key`	Encryption key for anonymization of sensitive columns
`--max-files`	Maximum number of files to process
`--folders/month`	Restrict transfer to certain folders (i.e. months)
`--tables`	Restrict transfer to certain tables
`--reset`	Reset the index and re-process
`--encrypt-index`	Save the index files encrypted or unencrypted (default depends on cloud type)
`--raw`	Copy as raw data instead of text file
`--fix-header`	Fix file header
`--fix-anon`	Fix anonymized fields in API columns

Launching PPD-Creator

Execute the following command:

docker run aura/ppd-creator --country <country-code> --anon-key <KEY> <source-params> <dest-params>

Example:

docker run aura/ppd-creator \
   --country ar \
   --anon-key as34-dre23-4127 \
   --src-name 4P-bucket-name-for-uk \
   --src-user EF45IHWD34DE4FGA \
   --src-pass k/Erf/6DSWWPjhdde1/abc123def-2331ldf \
   --dst-name aura-ppd-ar \
   --dst-user EF4341sdf3EFGUA1 \
   --dst-pass J/DQW/Sdde5k12ldsf/1abcde12dd1d-123c11 \
   --dst-encryption 1234ab56-12a3-45eb-8e06-8c522cdbb668-75f1b00f-6ca6-4a13-a741-64514cce728b \
   --table message \
   --environment prod \
   --transfer

Output from PPD-Creator

The output includes the following items:

BOT_XXXXXX.txt.bz2: raw files (processed).
log folder: if the logging options have been configured.

aura-sync-cache-dst.json: table/month: processed files (automatically generated in destination). For example:

{
  "AURA_DATA/ES/API/202212/": [
    "BOT_04095750-724e-11ed-9565-53054255c842_ES_API_20221202T150000Z.txt.bz2",
    "BOT_d2e93fc0-7656-11ed-a8eb-49a811568ab3_ES_API_20221207T170000Z.txt.bz2",
    "BOT_987780e0-7660-11ed-ba4a-2dac114c5321_ES_API_20221207T180000Z.txt.bz2"
  ],
  ...
}

aura-sync-cache-src.json: table/month: raw files_to_process (source). For example:

{
"AURA_DATA/ES/API/202212/": [
  "BOT_04095750-724e-11ed-9565-53054255c842_ES_API_20221202T150000Z.txt",
  "BOT_05a5b860-7663-11ed-bbf7-cb8fd9eb3c25_ES_API_20221207T190000Z.txt",
  "BOT_05ae43e0-7663-11ed-a0aa-8b7e0e134809_ES_API_20221207T190000Z.txt",
  "BOT_0d69fb10-7492-11ed-a1fc-95dce7e56901_ES_API_20221205T110000Z.txt"
],
  ... 
}

aura-sync-key-dst.json: key used to encrypt sensitive fields. For example:
```
{
  "sample": "abcd1234-ab12-12ab-ab12-1abc234e56fg"
}
```

Local data visualization (optional)

As explained before, Aura Global Team will be in charge of the analysis of the generated data through the global tool Aura Analytics Dashboard.

Nevertheless, just in case the OB wants to visualize certain data locally:

This will be done following a prior agreement with the OB on privacy-related matters.
Aura Global Team will provide access to the clean data stored in the corresponding PPD-clean blob container.
The OB can install locally the ELK stack or other alternative tool for data visualization.
No support will be offered by Aura Global team for this task.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Manage locales in Aura

The aim of this document is both general and specific processes to describe how locales are handled by Aura Bot services

Introduction

Locales in Aura refer to specific content for an OB and a language, in which any special variant preference that an OB wants to see in its user interface is included.

Localization is an important aspect of internationalization and localization (i18n) for the adaptation of internationalized software for a specific region or language by translating text and adding locale-specific components.

The current section includes key documents to manage locales in Aura:

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Message exchange between channels and skills

Guidelines for the exchange of messages that allows the communication between a channel and a skill

Introduction

Once a skill is connected to Aura Root, now it is required to establish a communication between a channel and this skill in order to exchange messages between them.

For this purpose, the communication protocol Aura request-response semantic model v3 must be used both by channels and skills to enable them to speak a language Aura can understand using the Direct Line API in order to make a request from a user through the designated channel and receive back the most suitable response from Aura.

Request model v3

Use the root channelData properties of the Aura request semantic model v3 for message exchange from the channel to the skill through aura-groot.

JSON schema for the Aura request semantic model v3
payload property: In the framework of Aura distributed architecture, the payload property includes a specific field (AuraGrooPayload) that allows sending enriched information from aura-groot to the skill.

Response model v3

Use the root channelData properties of the Aura response semantic model v3 for message exchange from the skill to the channel through aura-groot.

JSON schema for the Aura response semantic model v3
Root attachment properties
skillPayload property: In the framework of Aura distributed architecture, this specific property allows sending enriched information from the skill to aura-groot.

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Migrate Aura Bot and Aura Groot context to Linkin Park

Guidelines for the migration of aura-bot and aura-groot database context schemas from releases previous to Linkin Park to Linkin Park onwards. Additionally, the rollback procedure is included.

Prerequisites

Mandatory requisite: A valid kubeconfig for the environment must be available.
Recommendation: Create a snapshot/backup of the current DB data.

Process for context DB migration

Access MongoDB console

To access and open MongoDB console we can use the kubectl command below to export the intended environment, with MongoDB adminuser password. Use the right environment and database name in the commands.

$ export ATLAS_DEPLOYMENT_NAME=aura-br-pro-70 # Get from kubectl get -n aura-system atlasdeployments.atlas.mongodb.com
$ export ATLAS_DATABASE_NAME=aura-groot-br-pro # Set with the correct DB of your deployment
$ export MONGODB_USER=$(kubectl get -n aura-system atlasdatabaseusers.atlas.mongodb.com mongodb-adminuser-password -o jsonpath='{.spec.username}')
$ export MONGODB_PASSWORD=$(kubectl get -n aura-system secret mongodb-adminuser-password -o go-template='{{ .data.password | base64decode }}')
$ export MONGODB_URI="$(kubectl get -n aura-system atlasdeployments.atlas.mongodb.com $ATLAS_DEPLOYMENT_NAME -o jsonpath='{.status.connectionStrings.standardSrv}'|sed "s|srv://|srv://$MONGODB_USER:$MONGODB_PASSWORD@|g")/${ATLAS_DATABASE_NAME}"
$ kubectl -n aura-system run fix-script -i -q --rm --restart=Never --image=mongo:latest --command mongosh ${MONGODB_URI}

Migrate aura-bot context collection to new schema

Update documents to the new format:

> db["aura-context"].updateMany(
      {
        document: {
          $exists: true
        }
      },
      [
        {
          $set: {
            eTag: "$document.eTag",
            conversationData: { $mergeObjects: ["$conversationData", "$document.conversationData"] },
            dialogState: { $mergeObjects: ["$dialogState", "$document.dialogState"] },
            userData: { $mergeObjects: ["$userData", "$document.userData"] },
            userAuthData: { $mergeObjects: ["$userAuthData", "$document.userAuthData"] }
          }
        },
        { $unset: "document" }
      ]
    );

Migrate aura-groot context collection to new schema

Update documents to the new format:

> db["aura-context"].updateMany(
      {
        document: {
          $exists: true
        }
      },
      [
        {
          $set: {
            eTag: "$document.eTag",
            activeSkill: { $mergeObjects: ["$activeSkill", "$document.activeSkill"] },
            conversationHistory: { $concatArrays: [{ $ifNull: ["$conversationHistory", []] }, { $ifNull: ["$document.conversationHistory", []] }] },
            conversationDataProperty: { $mergeObjects: ["$conversationDataProperty", "$document.conversationDataProperty"] },
            dialogContext: { $concatArrays: [{ $ifNull: ["$dialogContext", []] }, { $ifNull: ["$document.dialogContext", []] }] },
            skillConversationReference: { $mergeObjects: ["$skillConversationReference", "$document.skillConversationReference"] }
          }
        },
        { $unset: "document" }
      ]
    );

Rollback aura-bot to the previous schema

If a rollback is needed, documents should be modified to have the previous schema and maintain the users’ context data:

> db["aura-context"].updateMany(
      {},
      [
        {
          $set: {
            document: {
              eTag: "$eTag",
              conversationData: { $mergeObjects: ["$document.conversationData", "$conversationData"] },
              dialogState: { $mergeObjects: ["$document.dialogState", "$dialogState"] },
              userData: { $mergeObjects: ["$document.userData", "$userData"] },
              userAuthData: { $mergeObjects: ["$document.userAuthData", "$userAuthData"] }
            }
          }
        },
        {
          $unset: [ "eTag", "conversationData", "dialogState", "userData", "userAuthData"]
        }
      ]
    );

Rollback aura-groot to the previous schema

If a rollback is needed, documents should be modified to have the previous schema and maintain the users’ context data:

> db["aura-context"].updateMany(
      {},
      [
        {
          $set: {
            document: {
              eTag: "$eTag",
              activeSkill: { $mergeObjects: ["$document.activeSkill", "$activeSkill"] },
              conversationHistory: { $concatArrays: [{ $ifNull: ["$document.conversationHistory", []] }, { $ifNull: ["$conversationHistory", []] }] },
              conversationDataProperty: { $mergeObjects: ["$document.conversationDataProperty", "$conversationDataProperty"] },
              dialogContext: { $concatArrays: [{ $ifNull: ["$document.dialogContext", []] }, { $ifNull: ["$dialogContext", []] }] },
              skillConversationReference: { $mergeObjects: ["$document.skillConversationReference", "$skillConversationReference"] }
            }
          }
        },
        {
          $unset: [ "eTag", "activeSkill", "conversationHistory", "conversationDataProperty", "dialogContext", "skillConversationReference"]
        }
      ]
    );

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

ATRIA operational workflows

These documents include various ATRIA technical operational flows, designed as sequence diagrams to provide a clear, step-by-step representation of ATRIA capabilities and processes, interactions between components or systems, and the overall ATRIA workflow

Index of technical operational workflows

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Germany ATRIA General RAG operational workflow

ATRIA technical operational flow corresponding to the operation of the RAG capability, specifically to the so-named General RAG predefined chain, for one OB: Germany.

Flow diagram

Calls to the atria-rag-server component (AtriaRAG in the sequence diagram) executes the predefined RAG chain General RAG.

@startuml
title Germany RAG API diagram
participant Application
participant Kernel #1add4d
participant AuraGatewayApi #76bbe7
participant AtriaModelGateway #f58e11
participant AtriaRAG #f5de11
participant AzureOpenAI #9476e7

Application -> Kernel: Create two-legged token with scope aura-aiservices:messaging:write
Note right of Kernel: this token needs refreshing
Kernel -> Application: Response two-legged token
Application -> Kernel: Request to aura-aiservices/generative/prompts with token and correlatorId (x-correlator)
Kernel -> AuraGatewayApi: Request to aiservices/generative/prompts with token-info header and correlatorId
AuraGatewayApi -> AuraGatewayApi: Validate request
AuraGatewayApi -> AuraGatewayApi: Generate prompt
AuraGatewayApi -> AtriaModelGateway: Send prompt to atria-model-gateway
activate AtriaModelGateway
AtriaModelGateway -> AtriaRAG: 1.0: Enrich request 
activate AtriaRAG
AtriaRAG -> AtriaRAG: securityStg


    alt Ask LLM
        AtriaRAG -> AtriaModelGateway: 1.3: Request LLM to validate the conversational context
        AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
        AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
        AtriaModelGateway --> AtriaRAG: LLM response [SAME CONTEXT] or [DIFFERENT CONTEXT]
        AtriaRAG -> AtriaRAG: Recreate Query
        AtriaRAG -> AtriaModelGateway: 1.4: Call LLM to generate new question 
        AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
        AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
        AtriaModelGateway --> AtriaRAG: Response with new question
    end


AtriaRAG -> AtriaRAG: retrievalStg

AtriaRAG -> AtriaRAG: Post Filtering 
note right: Batch request
AtriaRAG -> AtriaModelGateway: 1.5: Request LLM for each chunk 
AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI
AtriaModelGateway --> AtriaRAG: LLM response [RELEVANT] or [IGNORABLE]


AtriaRAG -> AtriaModelGateway: 1.6: Request LLM generativeStg 
AtriaModelGateway -> AzureOpenAI: Send Request to ChatCompletation endpoint
AzureOpenAI --> AtriaModelGateway: Response from AzureOpenAI 
AtriaModelGateway --> AtriaRAG: LLM response
AtriaRAG --> AtriaModelGateway: 2: Final response 
deactivate AtriaRAG
deactivate AtriaModelGateway

AtriaModelGateway -> AuraGatewayApi: Response Model Gateway
AuraGatewayApi -> AuraGatewayApi: process atria-model-gateway response
AuraGatewayApi -> AuraGatewayApi: generate response
AuraGatewayApi -> Kernel: response 200 and message with session_id
Kernel -> Application: response 200 and message with session_id

@enduml

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Make-up index manager

Make-up Index Manager allows managing the indexes of a MongoDB database

Introduction

The Make-up Index Manager is an utility for the management of indexes of a MongoDB database. This configuration can be loaded remotely.

Find more information in the Github repository: https://github.com/Telefonica/aura-common-utilities/tree/master/packages/aura-utilities/src/aura-makeup-index-manager/

Configuration

This module uses a MakeupMongoIndexManagerOptions model to manage the process.

MakeupMongoIndexManagerOptions

Property	Type	Description
storageCredentials	StorageCredentials	Credentials of Azure Storage.
fileConfiguration	FileConfiguration	The configuration file structure to manage the files.
mongodbConfiguration	any	MongoDB config (*)
replaceLocalWithRemote	boolean	If `true` and if a remote file exist, this replaces the local one.
uploadFromLocalToRemote	boolean	If `true` and if a remote file does not exist, it uploads the local one.
ignoreDownloadErrors	boolean	If `true`, if any file cannot be downloaded, it stops the process and returns an error.
ignoreUploadErrors	boolean	If `true`, if any file cannot be uploaded, it stops the process and returns an error.
auraVersion	string	Aura version, used to store the remote file in a folder with this value. Optional.
dataBaseSuffix	string	Used to rename the MongoDB with a suffix of Aura Environment. Example: for the value “ap-current”, the aura-bot database will be “aura-bot-ap-current”. There is an environment variable `AURA_ENVIRONMENT_NAME` in aura-bot to get this value. Optional.

(*) The MongoDB configuration has not got a model defined yet. This is the used by MongoDB Index Manager:

  AURA_MONGODB_URI
  AURA_MONGODB_DB_NAME
  AURA_MONGODB_USERNAME
  AURA_MONGODB_PASSWORD
  AURA_MONGODB_POOL_SIZE
  AURA_MONGODB_SSL

An example is shown below:

   const options: MakeupMongoIndexManagerOptions = {
        mongodbConfiguration: {
            AURA_MONGODB_URI: configuration.AURA_MONGODB_URI,
            AURA_MONGODB_DB_NAME: configuration.AURA_MONGODB_BOT_DATABASE,
            AURA_MONGODB_USERNAME: configuration.AURA_MONGODB_USERNAME,
            AURA_MONGODB_PASSWORD: configuration.AURA_MONGODB_PASSWORD,
            AURA_MONGODB_POOL_SIZE: configuration.AURA_MONGODB_POOL_SIZE,
            AURA_MONGODB_SSL: configuration.AURA_MONGODB_SSL
        },
        fileConfiguration: {
            containerName: 'aura-configuration',
            localPath: 'settings/makeup',
            remotePath: '',
            files: [{ name: 'aura-bot-mongodb-indexes.json', mimeType: 'application/json' }]
        },
        replaceLocalWithRemote: true,
        storageCredentials: {
            storageKey: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCESS_KEY,
            storageName: configuration.AURA_MICROSOFT_AZURE_STORAGE_ACCOUNT
        },
        uploadFromLocalToRemote: true,
        auraVersion: configuration.AURA_VERSION,
        ignoreDownloadErrors: true,
        ignoreUploadErrors: true,
        dataBaseSuffix: configuration.AURA_ENVIRONMENT_NAME
    };

    const makeupIndexManager = new MakeupIndexManager(options);
    await makeupIndexManager.process();

This utility uses downloadFiles to download index files.

MongoDB Index Manager

This module allows managing the indexes of a MongoDB database manager through a configuration file.

Configuration

IndexManagerModel

Property	Type	Description
version	number	Index manager’s version.
databases	object	Object with databases names as properties.
forceToVersion	number	Force to use a base version to update indexes and collections. Optional.
rollback	boolean	Flag to initialize rollback procedure. Optional.

VersionControlModel

Property	Type	Description
version	number	Index manager’s version.
name	string	Internal name module for supporting version control in other modules.
timestamp	Date	Date of version applied.

IndexManagerCollectionModel

Property	Type	Description
version	number	Version of changes.
indexes	IndexModel[]	Array of indexes to generate or update.
isPrefix	boolean	Check if prefix if present or not. Optional.
removeIndex	string[]	Array of indexes names. For deleting all indexes in a collection, use ["*"]. Optional.
removeAllData	string	Parameter to remove all collection data. Use the collection name in upper case for validation. Optional.

IndexModel

Property	Type	Description
version	number	Version of changes.
name	string	Name of the index.
keys	IndexKeyModel	Document fields to generate the indexes.
unique	boolean	It indicates if the key is unique for a document or not. Optional.
partialFilterExpression	boolean	If the index is partial, expression which filters specific documents to apply the index. Optional.
expireAfterSeconds	number	Number of seconds when the index expires. For this, `keys` must contain a field `datetime`. Optional.
collation	boolean	It indicates if language-specific rules for string comparison to index apply or not. Optional.

An example is shown below:

{
  "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
}

Manage index with specific version

When an index configuration file is applied, the affected database generates or updates a collection called aura-control-version. In this collection, the history of index application and the last version applied are stored. This is to avoid generating indexes that have already been created.

If we want to force the generation of an index for a specific version, we can indicate it in the forceToVersion field of the configuration file. For example, if we are in version 1 and we want to generate a new index to the collection without modifying this version, we must force to the version previous to the one that currently has the database.

Example:

The database has the version 1 and we need apply a index with this version: we need to force it.

{
  "databases": {
    "forceToVersion": 0,
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
}

Rollbacks

Rollbacks are possible with the MongoDB Index Manager. A rollback forces MongoDB to generate the indexes on one or more other databases exactly as they are described in the configuration file, regardless of the version number.

In order to perform a rollback, it is necessary to have a configuration file. This configuration file can be generated manually or via the Mongo Index Manager Client.

Example of file configuration to make a rollback:

{
  "rollback": true,
  "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
}

First of all, the indexes will be removed and then will be regenerated as described in the configuration file.

Mongo Index Manager Cli

This utility allows us to perform index management operations of a MongoDB database. You can also generate the index configuration file of one or several MongoDB databases.

Command Line

node .\lib\mongo-index-manager-cli.js <options>

Options

-f, –fileIndex: Input or output file with the Index Configuration File path.
-a, –appName: Suffix for the databases. Example: “ap-current”. Optional.
-r, –rollback: Generates an exact index structure to the configuration file regardless of versions. Optional.
-d, –deleteOnly: Only delete all indexes. Optional
-c, –connection: MongoDB Uri: mongodb://[username:password@]host1[:port1][,…hostN[:portN]][/[defaultauthdb][?options]].
-u, –mongoUser: MongoDB Username. Optional but mandatory if the user does not exist in connection parameter.
-p, –mongoPassword: MongoDB Password. Optional but mandatory if the password does not exist in connection parameter.

Examples

Generate an Index Configuration File from MongoDB

node ./lib/mongo-index-manager-cli.js  -g -c mongodb://localhost:27017 -u username -p password -f index-configuration-file.json

Remove Indexes: Remove all indexes of collections that exist in the Configuration File.

Configuration File (file.json)

  {
      "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
  }

      node ./lib/mongo-index-manager-cli.js  -d -c mongodb://localhost:27017 -u username -p password -f file.json

Rollback Indexes: Generate the indexes in all collections defined in the Configuration File

Configuration File (file.json)

  {
  "rollback": true,
  "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 1,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
}

    node ./lib/mongo-index-manager-cli.js  -d -c mongodb://localhost:27017 -u username -p password -f file.json

Update or generate indexes in MongoDB by Configuration File

Configuration File (file.json)

  {
  "databases": {
    "aura-bot": {
      "aura-version-control": {
        "version": 1,
        "removeIndex": [],
        "removeAllData": "",
        "indexes": [
          {
            "version": 2,
            "name": "idx_name",
            "keys": {
              "name": 1
            },
            "unique": true
          }
        ]
      }
    }
  }
}

  node ./lib/mongo-index-manager-cli.js  -c mongodb://localhost:27017 -u username -p password -f file.json

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Migrate Aura Groot context (Dire Straits)

Guidelines for the migration of aura-groot database context schema from releases previous to Dire Straits to Dorian release onwards. Additionally, the rollback procedure is included.

Prerequisites

Mandatory requisite: A valid kubeconfig for the environment must be available.
Recommendation: Create a snapshot/backup of the current DB data.

Process for context DB migration

Access MongoDB console

$ export ATLAS_DEPLOYMENT_NAME=aura-br-pro-70 # Get from kubectl get -n aura-system atlasdeployments.atlas.mongodb.com
$ export ATLAS_DATABASE_NAME=aura-groot-br-pro # Set with the correct DB of your deployment
$ export MONGODB_USER=$(kubectl get -n aura-system atlasdatabaseusers.atlas.mongodb.com mongodb-adminuser-password -o jsonpath='{.spec.username}')
$ export MONGODB_PASSWORD=$(kubectl get -n aura-system secret mongodb-adminuser-password -o go-template='{{ .data.password | base64decode }}')
$ export MONGODB_URI="$(kubectl get -n aura-system atlasdeployments.atlas.mongodb.com $ATLAS_DEPLOYMENT_NAME -o jsonpath='{.status.connectionStrings.standardSrv}'|sed "s|srv://|srv://$MONGODB_USER:$MONGODB_PASSWORD@|g")/${ATLAS_DATABASE_NAME}"
$ kubectl -n aura-system run fix-script -i -q --rm --restart=Never --image=mongo:latest --command mongosh ${MONGODB_URI}

Migrate context collection to new schema

Update documents to the new format:

> db["aura-context"].aggregate([
      {
        $match: {
          _id: {
            $regex: "/conversations/",
          },
          "document.activeSkill.conversationId": {
            $exists: true,
          },
        },
      },
      {
        $lookup:
          {
            from: "aura-context",
            localField:
              "document.activeSkill.conversationId",
            foreignField: "_id",
            as: "document.skillConversationReference",
          },
      },
      {
        $set: {
          "document.skillConversationReference": {
            $arrayElemAt: [
              "$document.skillConversationReference",
              0,
            ],
          },
        },
      },
      {
        $set: {
          "document.skillConversationReference":
            "$document.skillConversationReference.document",
        },
      },
      {
        $merge: "aura-context",
      },
    ])

Check if changes have been applied. The following query should return n documents:

  > db["aura-context"].find({"document.skillConversationReference": { $exists: true }})

Rollback to the previous schema

If a rollback is needed, documents should be modified to have the previous schema and maintain the users’ context data:

> db["aura-context"].aggregate([
    {
      $match:
        {
          "document.activeSkill.conversationId": {
            $exists: true,
          },
          "document.skillConversationReference": {
            $exists: true,
          },
        },
    },
    {
      $project:
        {
          _id: "$document.activeSkill.conversationId",
          document:
            "$document.skillConversationReference",
          expiresAt: "$expiresAt",
        },
    },
    {
      $merge: "aura-context",
    },
  ])

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Migrate Aura Groot context (Dire Straits)

Guidelines for the migration of aura-groot database context schema from releases previous to Dire Straits to Dorian release onwards. Additionally, the rollback procedure is included.

Prerequisites

Mandatory requisite: A valid kubeconfig for the environment must be available.
Recommendation: Create a snapshot/backup of the current DB data.

Process for context DB migration

Access MongoDB console

$ export ATLAS_DEPLOYMENT_NAME=aura-br-pro-70 # Get from kubectl get -n aura-system atlasdeployments.atlas.mongodb.com
$ export ATLAS_DATABASE_NAME=aura-groot-br-pro # Set with the correct DB of your deployment
$ export MONGODB_USER=$(kubectl get -n aura-system atlasdatabaseusers.atlas.mongodb.com mongodb-adminuser-password -o jsonpath='{.spec.username}')
$ export MONGODB_PASSWORD=$(kubectl get -n aura-system secret mongodb-adminuser-password -o go-template='{{ .data.password | base64decode }}')
$ export MONGODB_URI="$(kubectl get -n aura-system atlasdeployments.atlas.mongodb.com $ATLAS_DEPLOYMENT_NAME -o jsonpath='{.status.connectionStrings.standardSrv}'|sed "s|srv://|srv://$MONGODB_USER:$MONGODB_PASSWORD@|g")/${ATLAS_DATABASE_NAME}"
$ kubectl -n aura-system run fix-script -i -q --rm --restart=Never --image=mongo:latest --command mongosh ${MONGODB_URI}

Migrate context collection to new schema

Update documents to the new format:

> db["aura-context"].aggregate([
      {
        $match: {
          _id: {
            $regex: "/conversations/",
          },
          "document.activeSkill.conversationId": {
            $exists: true,
          },
        },
      },
      {
        $lookup:
          {
            from: "aura-context",
            localField:
              "document.activeSkill.conversationId",
            foreignField: "_id",
            as: "document.skillConversationReference",
          },
      },
      {
        $set: {
          "document.skillConversationReference": {
            $arrayElemAt: [
              "$document.skillConversationReference",
              0,
            ],
          },
        },
      },
      {
        $set: {
          "document.skillConversationReference":
            "$document.skillConversationReference.document",
        },
      },
      {
        $merge: "aura-context",
      },
    ])

Check if changes have been applied. The following query should return n documents:

  > db["aura-context"].find({"document.skillConversationReference": { $exists: true }})

Rollback to the previous schema

If a rollback is needed, documents should be modified to have the previous schema and maintain the users’ context data:

> db["aura-context"].aggregate([
    {
      $match:
        {
          "document.activeSkill.conversationId": {
            $exists: true,
          },
          "document.skillConversationReference": {
            $exists: true,
          },
        },
    },
    {
      $project:
        {
          _id: "$document.activeSkill.conversationId",
          document:
            "$document.skillConversationReference",
          expiresAt: "$expiresAt",
        },
    },
    {
      $merge: "aura-context",
    },
  ])

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Purge expired Aura users

Guidelines for the elimination of expired Aura users, in order to minimize the number of documents in aura-users database. This will make data migration lighter.

Prerequirements

This step must be executed if the number of documents in the aura-users database is too large and there are a lot of expired users, i.e., users that accessed more than 6 months ago and did not come back to Aura for a time.
It must be executed on a weekly or monthly basis to avoid long executions. The frequency will depend on the amount of data in your database and how long it takes to remove the expired data.
A valid kubeconfig for the environment must be available
A valid token to be able to pull images from aura docker registry: auraregistry.azurecr.io must be available

Get the variables to access the database:

# substitute {{aura-environment with the environment you're configuring }}
export AURA_ENVIRONMENT={{aura-environment}}

$ kubectl -n $AURA_ENVIRONMENT get cm authentication-api -o json | jq -r ".data.AURA_MONGODB_URI"

{{mongo_uri}}

$ kubectl -n $AURA_ENVIRONMENT get cm authentication-api -o json | jq -r ".data.AURA_MONGODB_USERNAME"

{{mongo_user}}

$ kubectl -n $AURA_ENVIRONMENT get secret authentication-api -o json | jq -r ".data.AURA_MONGODB_PASSWORD|@base64d"

{{mongo_pass}}

$ kubectl -n $AURA_ENVIRONMENT get cm authentication-api -o json | jq -r ".data.AURA_MONGODB_USER_DB"

{{mongo_users_db}}

Process for expired users elimination

Access MongoDB console

This access depends on the deployment configuration:

If the environment database runs in an on-premise MongoDB server, set up the corresponding port-forward to the primary node of the replicaset:

# Review carefully the mongodb pod you're connecting to, it MUST be the primary of the replica set
# Review your local port carefully, to set a free one

$ kubeclt -n aura-system port-forward mongodb-0 27017:27017

# Set the proper mongo_uri to access via the port-forwarded connection
$ mongo_uri=mongodb://localhost:27017

If the environment database runs in Atlas, just connect to the {{mongo_uri}}, read from the environment configuration.

In the end, just open the MongoDB console:

$ mongo -u {{mongo_user}} -p {{mongo_pass}} {{mongo_uri}}

> use {{mongo_users_db}}

Check the number of expired users

Check how many users are expired in the database (Older than 180 days or without lastAccess field)

> db.users.find({ "$or": [ { "lastAccess": { "$exists": false }},{ "lastAccess": { "$lt": new Date(ISODate().getTime() - 1000 * 86400 * 180)} } ]}).count()

⚠️ If Movistar Plus is a valid channel in your deployment, then its users must not be considered in the query, because they are created from a backend and are assumed to be created beforehand.

> db.users.find({ "$and": [ { "$or": [ { "lastAccess": { "$exists": false }},{ "lastAccess": { "$lt": new Date(ISODate().getTime() - 1000 * 86400 * 180)} } ]}, { "channelId": { "$ne": "60f0ffda-e58a-4a96-aad9-d42be70b7b42" }} ]}).count()

Execute database-cleaner tool

The script iterates over all the users in the database, deleting those whose lastAccess is older than 180 days or without lastAccess field (meaning that they come from an old version of Aura where this field does not exist).

It will create some output files with the deleted users that can be used with mongoimport command to restore the deleted users, if needed. The output files with the deleted users will be split in files of 500Mb size each.

If the environment uses MongoDB on premise: Use with port-forwarding to the primary node of the cluster in the same host where the command is running:

# complete the {{mongodb_uri}} with the user and password of the database. You should obtain something like:
# mongodb_full_uri = mongodb://{{mongo_user}}:{{mongo_pass}}@{{mongodb_hosts_path}}

$ docker run -it --net=host -e MONGODB_USERS_DATABASE={{mongo_users_db}} -e MONGODB_URI={{mongodb_full_uri}} -v $(pwd)/output:/opt/cleaner/output auraregistry.azurecr.io/aura-tools/database-cleaner

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

WhatsApp flowchart

Key flowcharts for WhatsApp channel: basic, login and logout flows

WhatsApp basic flowchart

Flows for new messages from anonymous and authenticated users in the WhatsApp channel.

New WhatsApp message from anonymous user

@startuml
title: Basic flow for WhatsApp anonymous users
    actor User
    participant WhatsApp #f6b5ff
    participant KernelWhatsAppApi #99FFFF
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant AuthenticationApi #FFFF99
    participant AuraBot #41a0f9 
    participant TACApi #66B2FF
    participant AuraBridgeOutbound #1add4d

    User -> WhatsApp: Request [message]
    WhatsApp -> KernelWhatsAppApi: Request [message]
    KernelWhatsAppApi -> AuraBridge: Request [message]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    Note over AuraBridge,AuraGroot: WhatsApp channels use channelData V2 between AuraBridge and AuraGroot
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuthenticationApi: GET auraId
    AuthenticationApi -> AuraBot: 404 Not Found (Anonymous user)
    Note left of TACApi: See Terms and Conditions flow
    AuraBot -> TACApi: Check terms and conditions
    TACApi -> AuraBot: 200 OK
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute Specific functional Dialog
    AuraBot -> AuraGroot: Response to [message]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Response to [message]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Response to [message]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Response to [message]
    WhatsApp -> User: Show response to [message]
@enduml

New WhatsApp message from authenticated user

@startuml
title: Basic flow for WhatsApp authenticated users
    actor User
    participant WhatsApp #f6b5ff
    participant KernelWhatsAppApi #99FFFF
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant AuthenticationApi #FFFF99
    participant AuraBot #41a0f9 
    participant TACApi #66B2FF
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF
    participant AuraBridgeOutbound #1add4d

    User -> WhatsApp: Request [message]
    WhatsApp -> KernelWhatsAppApi: Request [message]
    KernelWhatsAppApi -> AuraBridge: Request [message]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    Note over AuraBridge,AuraGroot: WhatsApp channels use channelData V2 between AuraBridge and AuraGroot
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: GET userCache(auraId)
    opt User is not in cache
        AuraBot -> AuthenticationApi: GET AuraId
        AuthenticationApi -> AuraBot: 200 OK {userData}
        AuraBot -> KernelAuthServer: POST /token
        Note over AuraBot,KernelAuthServer: Here, a 3legged accessToken is requested
        KernelAuthServer -> AuraBot: {token}
        AuraBot -> KernelAuthServer: getIntrospect(token)
        opt channel allows UserProfile
            AuraBot -> KernelUserProfileApi: getUserProfile(userId)
            KernelUserProfileApi -> AuraBot: UserProfile
        end
        AuraBot -> AuraBot: store user in cache: userData, userProfile, valid scopes and purposes
    end
    Note left of TACApi: See Terms and Conditions flow
    AuraBot -> TACApi: Check terms and conditions
    TACApi -> AuraBot: 200 OK
    AuraBot -> AuraBot: Recognizers
    AuraBot -> AuraBot: Main Dialog
    AuraBot -> AuraBot: Execute Specific functional Dialog
    AuraBot -> AuraGroot: Response to [message]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Response to [message]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Response to [message]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Response to [message]
    WhatsApp -> User: Show response to [message]
@enduml

Terms & Conditions flowchart

@startuml

title: Acceptance of terms and conditions flow
    actor User
    participant WhatsApp #f6b5ff
    participant KernelWhatsAppApi #99FFFF
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant AuthenticationApi #FFFF99
    participant AuraBot #41a0f9 
    participant TACApi #66B2FF
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF
    participant AuraBridgeOutbound #1add4d

    User -> WhatsApp: Request [message]
    WhatsApp -> KernelWhatsAppApi: Request [message]
    KernelWhatsAppApi -> AuraBridge: Request [message]
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: GET userCache(auraId)
    alt User already accepted authenticated T&C or Channel doesn't have terms and conditions config
        AuraBot -> TACApi: GET termsAndConDitions(auraId)
        TACApi -> AuraBot: 200 OK
        Note left of AuraBot: See WhatSApp basic flow
        AuraBot -> AuraBot: Recognizers
        AuraBot -> AuraBot: Main Dialog
        AuraBot -> AuraBot: Execute Specific functional Dialog
        AuraBot -> AuraGroot: Response to [message]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Response to [message]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Response to [message]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp: Response to [message]
        WhatsApp -> User: Show response to [message]
    else User needs to accept authenticated T&C
        AuraBot -> TACApi: GET termsAndConditions(auraId)
        TACApi -> AuraBot: 404 Not found
        AuraBot -> AuraBot: executes terms and conditions dialog
        AuraBot -> AuraGroot: Send [onboarding messages]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Send [onboarding messages]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Send [onboarding messages]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp: Send [onboarding messages]
        WhatsApp -> User: Show [onboarding messages]
    end
@enduml

WhatsApp phone OTP (LoA2) authentication

Operational flow based on the whatsapp-otp-login global dialog.

The flow will be similar for email OTP method.

@startuml
title: WhatsApp authentication flow via phone OTP (LoA2)
    actor User
    participant WhatsApp #f6b5ff
    participant KernelWhatsAppApi #99FFFF
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant AuthenticationApi #FFFF99
    participant AuraBot #41a0f9 
    participant TACApi #66B2FF
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF
    participant AuraBridgeOutbound #1add4d

    User -> WhatsApp: I want to log in
    WhatsApp -> KernelWhatsAppApi: I want to log in
    KernelWhatsAppApi -> AuraBridge: I want to log in
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: I want to log in
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> AuraBot: Request [message]
    AuraBot -> AuraGroot: 200 OK
    note left of AuraGroot: See basic WhatsApp flow for anonymous users
    AuraBot -> AuraBot: basic whatsapp flow for anonymous user
    AuraBot -> AuraBot: Dialog needs auth and user is anonymous. Redirect to WhatsApp login dialog, step 1
    AuraBot -> AuraGroot: Send [Please, enter your phone number]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Send [Please, enter your phone number]
    AuraBridgeOutbound -> KernelWhatsAppApi: Send [Please, enter your phone number]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Send [Please, enter your phone number]
    WhatsApp -> User: Send [Please, enter your phone number]
    User -> WhatsApp: phoneNumber
    WhatsApp -> KernelWhatsAppApi: phoneNumber
    KernelWhatsAppApi -> AuraBridge: phoneNumber
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: phoneNumber
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraBot: phoneNumber
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Execute step 2 of WhatsApp login dialog
    AuraBot -> KernelWhatsAppApi: POST sendSMSOTPCode(phoneNumber)
    KernelWhatsAppApi -> AuraBot: 200 OK
    KernelWhatsAppApi -> User: [SMS] Your verification code is XXXX
    AuraBot -> AuraGroot: Send [Please, enter your phone number]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Send [Please, enter your phone number]
    AuraBridgeOutbound -> KernelWhatsAppApi: Send [Please, enter your phone number]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Send [Please, enter your phone number]
    WhatsApp -> User: Send [Please, enter the verification code]
    User -> WhatsApp: XXXX
    WhatsApp -> KernelWhatsAppApi: XXXX
    KernelWhatsAppApi -> AuraBridge: XXXX
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: XXXX
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraBot: XXXX
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Execute step 3 of WhatsApp login dialog
    AuraBot -> KernelWhatsAppApi: POST validateCode(phoneNumber, code)
    KernelWhatsAppApi -> AuraBot: 200 OK {authenticationContext}
    AuraBot -> AuthenticationApi: POST /users/auraId {authenticationContext}
    AuthenticationApi -> AuraBot: 201 Created
    alt  User has already accepted authenticated Terms and Conditions
        AuraBot -> TACApi: GET termsAndConditions(auraId)
        TACApi -> AuraBot: 200 OK
        AuraBot -> AuraGroot: Send [Great! you are now signed in]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Send [Great! you are now signed in]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Send [Great! you are now signed in]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp: Send [Great! you are now signed in]
        WhatsApp -> User: Show [Great! you are now signed in]
    else User needs to accept authenticated T&C
        AuraBot -> TACApi: GET termsAndConditions(auraId)
        TACApi -> AuraBot: 404 Not found
        AuraBot -> AuraGroot: Send [Great! you are now signed in]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Send [Great! you are now signed in]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Send [Great! you are now signed in]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp: Send [Great! you are now signed in]
        WhatsApp -> User: Show [Great! you are now signed in]
        AuraBridgeOutbound -> AuraGroot: intent.onboarding.terms-and-conditions from redirect intent configured for the channel
        AuraGroot -> AuraBridgeOutbound: 200 OK
        AuraGroot -> AuraBot: intent.onboarding.terms-and-conditions from redirect intent configured for the channel
        AuraBot -> AuraGroot: 200 OK
        AuraBot -> AuraBot: GET userCache(auraId)
        opt User is not in cache
            AuraBot -> AuthenticationApi: GET AuraId
            AuthenticationApi -> AuraBot: 200 OK {userData}
            AuraBot -> KernelAuthServer: POST /token
            Note over AuraBot,KernelAuthServer: Here, a 3legged accessToken is requested
            KernelAuthServer -> AuraBot: {token}
            AuraBot -> KernelAuthServer: getIntrospect(token)
            opt channel allows UserProfile
                AuraBot -> KernelUserProfileApi: getUserProfile(userId)
                KernelUserProfileApi -> AuraBot: UserProfile
            end
            AuraBot -> AuraBot: store user in cache: userData, userProfile, valid scopes and purposes
        end
        AuraBot -> AuraBot: executes Terms and Conditions dialog
        AuraBot -> AuraGroot: Send [onboarding messages]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Send [onboarding messages]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Send [onboarding messages]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp:  Send [onboarding messages]
        WhatsApp -> User: Show [onboarding messages]
    else Channel doesn't have terms and conditions config
        AuraBot -> AuraGroot: Send [Great! you are now signed in]
        AuraGroot -> AuraBot: 200 OK
        AuraGroot -> AuraBridgeOutbound: Send [Great! you are now signed in]
        AuraBridgeOutbound -> AuraGroot: 200 OK
        AuraBridgeOutbound -> KernelWhatsAppApi: Send [Great! you are now signed in]
        KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
        KernelWhatsAppApi -> WhatsApp: Send [Great! you are now signed in]
        WhatsApp -> User: Show [Great! you are now signed in]
    end
@enduml

WhatsApp logout

Operational flow based on the whatsapp-logout global dialog.

@startuml
title: WhatsApp logout flow
    actor User
    participant WhatsApp #f6b5ff
    participant KernelWhatsAppApi #99FFFF
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant AuthenticationApi #FFFF99
    participant AuraBot #41a0f9 
    participant KernelAuthServer #99FFFF
    participant KernelUserProfileApi #99FFFF
    participant AuraBridgeOutbound #1add4d

    User -> WhatsApp: I want to logout
    WhatsApp -> KernelWhatsAppApi: I want to logout
    KernelWhatsAppApi -> AuraBridge: I want to logout
    AuraBridge -> KernelWhatsAppApi: 200 OK
    AuraBridge -> AuraGroot: I want to logout
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraBot: I want to logout
    AuraBot -> AuraGroot: 200 OK
    AuraBot -> AuraBot: Basic whatsapp flow for authenticated users
    AuraBot -> AuthenticationApi: DELETE /users/auraId
    AuthenticationApi -> AuraBot: 204 NO_CONTENT
    AuraBot -> KernelWhatsAppApi: DELETE /sessions/authorizationId
    KernelWhatsAppApi -> AuraBot: 204 NO_CONTENT
    AuraBot -> AuraGroot: Send [You're successfully logged out, discover what can be done with Aura]
    AuraGroot -> AuraBot: 200 OK
    AuraGroot -> AuraBridgeOutbound: Send [You're successfully logged out, discover what can be done with Aura]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> KernelWhatsAppApi: Send [You're successfully logged out, discover what can be done with Aura]
    KernelWhatsAppApi -> AuraBridgeOutbound: 200 OK
    KernelWhatsAppApi -> WhatsApp: Send [You're successfully logged out, discover what can be done with Aura]
    WhatsApp -> User: Show [You're successfully logged out, discover what can be done with Aura]
@enduml

Docs:

Mon, 01 Jan 0001 00:00:00 +0000

Auraline flowcharts

Basic flowcharts for Auraline channels message flow.

Auraline basic flowcharts

Auraline channel handled by an external skill

This flowchart shows the interaction of anonymous users requesting a use case handled by an external skill.

@startuml
title: Auraline anonymous user using external skill
    actor User
    participant Channel #bdf492
    participant AuraBridge #1add4d
    participant AuraGroot #76bbe7
    participant ExternalSkill #B266FF
    participant AuraBridgeOutbound #1add4d

    User -> Channel: Request [message]
    Channel -> AuraBridge: Request [message]
    AuraBridge -> Channel: 200 OK
    AuraBridge -> AuraGroot: Request [message]
    Note over AuraBridge,AuraGroot: Auraline  channels use channelData V3 between AuraBridge and AuraGroot
    AuraGroot -> AuraBridge: 200 OK
    AuraGroot -> AuraGroot: GetSkillByChannel
    AuraGroot -> ExternalSkill: Request [message]
    ExternalSkill -> AuraGroot: 200 OK
    ExternalSkill -> ExternalSkill: Process [message]
    ExternalSkill -> AuraGroot: Send [response]
    AuraGroot -> ExternalSkill: 200 OK
    AuraGroot -> AuraBridgeOutbound: Send [response]
    AuraBridgeOutbound -> AuraGroot: 200 OK
    AuraBridgeOutbound -> Channel: Send [response]
    Channel -> User: Show [response]
    alt Channel should use status endpoint to inform Aura whether or not the sent activities are shown to the user
        Channel -> AuraBridge: Send [status]
        AuraBridge -> Channel: 200 OK
        AuraBridge -> AuraBridge: log status
    end
@enduml

Aura – operation

Docs:

Aura Bot utilities

Introduction

How to install aura-bot-utilities package

How to import an utility from this package

Available utilities

Docs:

Aura common utilities

Introduction

Docs:

Core technologies in Aura

Aura deployment

Security and privacy

Operational foundations

Data management

Languages

Monitoring tools

Testing tools

AI-driven technologies

Releases management

Docs:

Direct Line flowcharts

Request a new accessToken from Direct Line to access Aura

New Direct Line message from anonymous users

New Direct Line message from authenticated users

Docs:

General guidelines for locales management

Introduction

Previous steps

Generation of POEditor token

Importing locale files with aura-locale-importer tool

Locale files uploading

Make modifications available

Check LocaleManager configuration

Restart the corresponding pod/pods

Docs:

Get started with Aura Bot

Introduction

Create a bot service

Install Aura Bot

Configure Aura Bot

How to start a basic Aura Bot configuration

Access with kubeconfig

Example of environment configuration

Docs:

Handling user messages in RCS channel

Handling user button responses

Handling suggestion responses

Handling actions responses

Ignoring responses

Docs:

Aura operational flowcharts

Introduction

Docs:

Start a conversation in RCS channel

Introduction

Sending text messages to the user

Sending complex messages to the user

Sending messages through aura-bot

Checking the contact availability

Aura line api

Docs:

Aura KPIs uploader user guide

1. Prepare your CONFIG_FILE

2. Launch Aura KPIs uploader

2.1. Launch the tool directly with the source code

2.2. Launch the tool as a docker container

2.2.1. Pull image from repository

2.2.2. Run Docker container

3. Execution Dependencies

3.1 Evaluation of conditions for execution

4 Generate Reports

4.1 Report upload Files

4.1.1 Report Model

4.2 Report Generating Avro KPIs

4.2.1 Report Model

Docs:

Aura Context architecture and operation

Functional architecture

1. Prepare your `CONFIG_FILE`