Aura – installation

Docs:

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

Google RCS Business Messaging channel activation

Guidelines for the activation of Google RCS Business Messaging in Aura

Create an RBM account

First, fill the following form to create an RBM (RCS Business Messaging) account.
After that, wait until Google answers your request or contact them to speed up the process.
Once you receive the confirmation, you will be sent an email with another form to create your partner account.
Following the previous instructions, you will be able to create and configure new agents.

Configure a new agent

To create a new agent, go to the RBM console and configure your agent with the desired parameters.

After that, configure your channel to handle all the messages. First, create your channel with a configuration similar to this:

If your channel is already created in aura-config-provision, you should configure the missing values for your environment.
- agentId in the configuration of each environment
- Secrets in the environment configuration

There are some fields in the rcs configuration that must be obtained from the RBM console:

The agentId value can be found in the overview section in your agent configuration:
The clientToken can be a custom value or a generated one in the web. It will be used later when the webhook is configured.
The email and privateKey can be obtained in the RBM console, creating a new private key inside the partner account settings:

This action will return a json file with all the information, including email and privateKey

Important: the field privateKey must be stored in aura-configuration-api in a base64 format.
With the channel configured, add your endpoint to the webhook agent configuration:

To configure the webhook, set the public endpoint of your bridge:

https://svc-{{ENVIRONMENT}}.auracognitive.com/aura-services/v1/rcs/channels/{{CHANNELID}}/messages

And set the client token with the value configured in the field rcs.clientToken within the channel configuration.

If the values are properly configured, the web will return a success message. All these values stored in aura-configuration-api must be consolidated in the aura-config-provision repository.

Docs:

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

Install global use cases

Guidelines for the installation of Aura global use cases

Introduction

If you are interested in taking advantage of an Aura global use case, already developed by Aura Platform Team, follow these instructions for its installation.

Installation of global use cases

To install the global use cases, use the following command:

npm run local-dependencies:install

This command will add the dependencies of the global use case libraries in both the package.json and the plugin-config.json file and install them into the project.

In order to install the versions needed, please update the following file local-dependencies/libraries-list.json and set the corresponding versions of your libraries.

⚠️ Remember to add a new profile if checking a new version of the libraries. For instance:

To test aura-platform version killets:

[
     {
        "profile": "release/killers",
        "description": "Use cases delivered in The Killets",
        "disttags": [
            "devkillers"
        ],
        "libraries": [
            { "name": "@telefonica/aura-bot-alfred-library" },
            { "name": "@telefonica/aura-bot-bill-library" },
            { "name": "@telefonica/aura-bot-cognitive-library" },
            { "name": "@telefonica/aura-bot-common-library" },
            { "name": "@telefonica/aura-bot-disambiguation-library" },
            { "name": "@telefonica/aura-bot-generic-library" },
            { "name": "@telefonica/aura-bot-handover-library" },
            { "name": "@telefonica/aura-bot-issues-library" },
            { "name": "@telefonica/aura-bot-linking-library" },
            { "name": "@telefonica/aura-bot-miscellaneous-library" },
            { "name": "@telefonica/aura-bot-none-library" },
            { "name": "@telefonica/aura-bot-onboarding-library" },
            { "name": "@telefonica/aura-bot-recommender-library" },
            { "name": "@telefonica/aura-bot-services-library" },
            { "name": "@telefonica/aura-bot-tv-library" },
            { "name": "@telefonica/aura-bot-wakeup-library" },
            { "name": "@telefonica/aura-bot-wifi-library" }
        ]
    }
]

Uninstallation of global use cases

To uninstall the global use cases, use the following command:

npm run local-dependencies:uninstall

This command will uninstall all the dependencies of the global libraries you have previously installed, it will also clear the file package.json and plugin-config.json.

Installation of dialogs in Aura minibot

Yo can see how to install new dialogs here

Docs:

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

Aura Mocks server installation

Guidelines for the installation, testing and deployment of Aura Mocks Server

Introduction

These instructions will allow you to get a copy of the project running on your local machine for development and testing purposes.

The following pre-requirements are needed:

nodeJS installed version: 12 or higher

    $ node --version

Installation

Download from git:

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

Build project:
```
$ npm run build
```

Run tests

This project uses tslint to validate the coding style.

Code style tests

These tests perform the validation coding rules defined in aura using the tslint tool.

You can validate the code using:

   $ npm run lint

Deployment

This project uses Jenkins to generate the docker image in the azure registry.

You can download the image using pull:

docker pull auraregistry.azurecr.io/aura/aura-mocks-server:<VERSION>

Build local docker image

To build docker image execute:

$ docker build -f ./delivery/docker/Dockerfile -t auraregistry.azurecr.io/aura-mocks-server .

Run server

To start mock server:

    $ docker run -d -p 3000:3000 auraregistry.azurecr.io/aura-mocks-server

This starts a server listening on port 3000

Deploy

To deploy in performance environments, there is a convinient deployment yaml in aurak8s repository at tools/mocks/deployment.yml so you just need to run kubectl apply -f tools/mocks/deployment.yml.

Developer notes

The folder structure used for development is:

src
├── api             // Statics API code
├── modules         // Modules code (jsonserver)
├── scripts         // Scripts
└── shared          // Shared code between APIs and modules.
    ├── common
    └── services

Versioning

We use [SemVer] (http://semver.org/) for versioning.

For all available versions, look at the tags in this repository.

Docs:

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

QA Tool installation guide

Guidelines for the installation of Aura QA Tool

Download the QA test set from a Github repository

In order to download the QA tool from one specific branch in the GitHub repository, follow these instructions:

Open a terminal.
Change the current working directory to the location where the cloned directory will be placed.
Type the following command: git clone https://github.com/Telefonica/aura-tests.git

Press “Enter”. The local clone will be created.

$ git clone https://github.com/Telefonica/aura-tests.git
Cloning into 'aura-tests'...
remote: Enumerating objects: 1095, done.
remote: Counting objects: 100% (1095/1095), done.
remote: Compressing objects: 100% (235/235), done.
remote: Total 30040 (delta 962), reused 947 (delta 850), pack-reused 28945
Receiving objects: 100% (30040/30040), 55.39 MiB | 3.28 MiB/s, done.
Resolving deltas: 100% (23490/23490), done.

Check the specific branch for your release in Aura release vs QA Tool branches and switch to this branch using the following instructions:
```
git checkout <branch_name>
```

Create and activate the new virtual environment

Make available a new virtual environment through these steps:

Create a virtual environment for the project:

$ cd <project_folder>
$ virtualenv venv

Activate the virtual environment:
```
$ source venv/bin/activate
```
If it is required to deactivate the virtual environment:
```
$ deactivate
```

Install requirements

⚠️ Remember that it is highly recommended to reinstall the QA Tool requirements if you have installed a new Aura Platform release

Once the virtual environment is activated, install the packages required for the QA tests execution in the current environment. The installation must be done inside the activated virtual environment.

The requirements are included in the file requirements_ob.txt, within the folder: https://github.com/Telefonica/aura-tests/blob/master/acceptance

The steps to do that, are described below:

$ cd [project_folder]/aura-tests 
$ cd acceptance/ 
$ pip install -r requirements_ob.txt

ℹ️ Please, ignore no critical warning or errors messages that can be displayed, depending on the system versions.

Docs:

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

WhatsApp channel activation

Guidelines for the activation and deactivation of WhatsApp features in Aura

Prerequirements

This step must be only executed if the environment counts on a channel of whatsapp type.
It must be executed only once, when setting up each channel. Afterwards, the configuration just has to be reviewed.

Moreover, the following pre-requirements must be met:

WhatsApp channel is already configured in the aura-configuration-api and its uses cases are already configured and its configuration included:
Kernel client_id for aura-bot
Kernel client_secret for aura-bot
There is a valid and active MSISDN to be configured as WhatsApp contact for the company phone number.
There is an URL where the whatsapp callback of aura-bridge will be listening to once activated.
- Usually, something like:
  https://{{aura-services-domain}}.auracognitive.com/aura-services/v1/whatsapp/messages?apikey={{api_key}}
  Where:
  - {{aura-services-domain}} should be svc-[country]-[environment], for instance svc-es-pre
  - {{api_key}} is an specific APIKey created for Kernel to access this endpoint.
There is a Kernel environment to which Aura environment is connected. Recommended:
- kubectl installed in your local host.
- curl installed in your local host.
- jq installed in your local host.

Register WhatsApp in Kernel and FacebookManager

Before activating WhatsApp in Aura, WhatsApp API must be configured in the corresponding Kernel environment.

⚠️ If the APIs are already configured for your aura-bot application, please skip this section.

This whole procedure is fully dependant of the Kernel Operations Team and it is defined in the Kernel documentation: WhatsApp channel API.

As a summary, follow the steps below.

Add WhatsApp scopes in your application

First of all, we must get the Kernel app name or client_id in which WhatsApp APIs must be available.

To obtain it, just execute the following command:

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

$ kubectl -n $AURA_ENVIRONMENT get cm aura-bot -o json | jq -r ".data.AURA_FP_CLIENT_ID"

aura-bot

Now, request the change to the Kernel operators of your environment: add the scope whatsapp:app-admin in aura-bot.

Get a valid access_token to start the registering process

To use the Kernel WhatsApp API, you must first authenticate with client credentials specifying the required purpose (whatsapp:app-admin).

To obtain the real secret of your app, just run the following command, as an example of using app “aura-bot” in Kernel “global-int-current” with a fake password.
```
$ kubectl -n $AURA_ENVIRONMENT get secret aura-bot -o json | jq -r ".data.AURA_FP_CLIENT_SECRET|@base64d"
```

Now you are able to request the access_token:

# generate a valid UUID as correlator
# subsitute {{correlator}} with the generated UUID
export CORRELATOR={{correlator}}
# substitute aura-bot:secret with the specific information for your Kernel client.

$ curl -i -X POST -u aura-bot:secret -H 'Content-Type: application/x-www-form-urlencoded' -H 'Cache-Control: no-cache' -H 'x-correlator: $CORRELATOR' 'https://auth.global-int-current.baikalplatform.com/token' -d 'scope=whatsapp:app-admin&grant_type=client_credentials'

HTTP/2 200
{"access_token":"<token>","token_type":"Bearer","expires_in":3599,"scope":"whatsapp:app-admin","purpose":""}

export TOKEN=<token>

As can be seen, we get a token, that we will use as bearer authorization when registering the phone number.

Register the phone number in Facebook Manager

⚠️ This step must be done by Kernel Operations Team

Request Kernel Operations Team to register your phone number in Facebook in the following URL:

https://developers.facebook.com/docs/whatsapp/api/account#phone-and-certificate
The outcome of this operation might be a certificate that allows us to configure the app in Kernel.

Request a registration code

For this step, you need the previously generated access_token and the base64 encoded certificate associated to your phone number.

To execute the request, just launch the following command.

# substitute <phone-number> with your own one without the country code
# substitute <base64_cert> with the certificate that Kernel handed to you
# set sms or voice in the method field. SMS recommended.

$ curl -i -X POST -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' -H 'x-correlator: $CORRELATOR' 'https://api.global-int-current.baikalplatform.com/whatsapp/v1/account' -d '{"cc": "34", "phone_number": "<phone-number>", "method": "sms", "cert":"<base64_cert>"}'

HTTP/2 202
{"account":[{"vname":"Entorno Aura Movistar Espa\u00f1a"}],"meta":{"api_status":"stable","version":"2.29.3"}}

The outcome of this request is a registration code and can be received via SMS or voice call, so your SIM must be deployed in a device.

Find further information in Kernel documentation: Request code

Behind the scenes, it will call https://developers.facebook.com/docs/whatsapp/api/account#regcode

Verify registration

Once you have received the registration code via the method of your choice (i.e., SMS or voice), complete your account registration by sending an API call to the /v1/account/verify endpoint:

# substitute <code> with the registration code received from Facebook.

$ curl -i -X POST -H "Authorization: Bearer $TOKEN" -H 'Content-Type: application/json' -H 'x-correlator: $CORRELATOR' 'https://api.global-int-current.baikalplatform.com/whatsapp/v1/account/verify' -d '{"code": "<code>"}'

HTTP/2 201
{"account":[{"vname":"Entorno Aura Movistar Espa\u00f1a"}],"meta":{"api_status":"stable","version":"2.29.3"}}

Find further information in Kernel documentation: Register account

Behind the scenes, it will call https://developers.facebook.com/docs/whatsapp/api/account#verify

Set the webhook

Tell Kernel which is the callback of the service where Aura will process the WhatsApp requests.

So, in this case, we must set as webhook the WhatsApp messages endpoint of aura-bridge.

An example request is shown below:

# substitute <aura-services-domain> with the domain of your environment, usually something like svc-es-pro
# substitute <api-key> with an apikey generated
# substitute <channelId> with a whatsapp channel identifier

$ curl -i -X PATCH -H "Authorization: Bearer $TOKEN" -H 'content-type: application/json' -H 'x-correlator: $CORRELATOR' 'https://api.global-int-current.baikalplatform.com/whatsapp/v1/settings/webhook' -d '{"webhooks": {"url": "https://<aura-services-domain>.auracognitive.com/aura-services/v1/whatsapp/messages?apikey=<api_key>&channelId=<channelId>"}}'

HTTP/2 201
{"webhooks": {"url": "https://<aura-services-domain>.auracognitive.com/aura-services/v1/whatsapp/messages?apikey=<api_key>&channelId=<channelId>"}}

⚠️ It is not needed that the endpoint is up and running to set it as webhook.

Find further information in Kernel documentation: Update webhooks

Enabling WhatsApp controller in Aura Bridge

Get sure that all the necessary WhatsApp plugins are set in aura-bridge plugin configuration file:

[
    "./lib/plugins/directline-service",
    "./lib/plugins/directline-whatsapp-processor",
    "./lib/plugins/directline-whatsapp-service",
    "./lib/plugins/whatsapp-incoming-processor",
    "./lib/plugins/whatsapp-service"
]

Review the already configured values in these aura-bridge environment variables:

# `<4p-environment>` must contain the proper Kernel environment value.
aura_bridge:
  config:
    AURA_FP_WHATSAPP_ENDPOINT: https://api.<4p-environment>.baikalplatform.com/whatsapp
    AURA_FP_AUTHSERVER_ENDPOINT: https://auth.<4p-environment>.baikalplatform.com/whatsapp/v1
    AURA_FP_CLIENT_ID: <aura-bot-4p-client-id>
    AURA_FP_CLIENT_SECRET: <aura-bot-4p-client-secret>

To assure that everything is configured as expected:
- Kernel authserver endpoint must belong to the same Kernel environment than AURA_FP_WHATSAPP_ENDPOINT.
- The AURA_FP_CLIENT_ID must be the one that has been configured with the WhatsApp APIs settings.
Follow the instructions in the current document in order to apply the updated configuration.

Once the configuration is applied, validate that the WhatsApp controller is working properly:

# substitute <aura-services-domain> with the domain of your environment, usually something like svc-es-pro
# substitute <api-key> with an apikey generated
# substitute <channelId> with a whatsapp channel identifier

$ curl -i -X POST -H 'Content-Type: application/json' -H 'x-correlator: $CORRELATOR' 'https://<aura-services-domain>.auracognitive.com/aura-services/v1/whatsapp/messages?apikey=<api-key>&channelId=<channelId>'

It everything is working properly, it should return a response with a 400 statusCode.
If the endpoint was not configured, it should return 404.

The objective of this step is to enable the whatsapp-otp-login dialog and whatsapp-logout dialog dialogs.

Set the following environment variables in the aura-bot section of your Aura installer configuration, as explained in the document Aura installer aurak8s.

# substitute `<4p-environment>` with the proper Kernel environment value.
aura_bot:
  config:
    LINKING_FP_WHATSAPP_ENDPOINT: https://api.<4p-environment>.baikalplatform.com/whatsapp # must be the same as AURA_FP_WHATSAPP_ENDPOINT of ***aura-bridge***

Review the plugins-config.json file to set the proper libraries configuration. This file can be found in this path of Aura installer, where you have to choose the country for your installation: br, de, es, uk:
deploy/files/containers/bot/plugin-config-[country].json
At this point, two scenarios can arise:

Scenario 1. Linking library is already enabled for any channel

If the linking library is configured but the whatsapp dialogs are disabled, the file would contain the following lines:

{
  "packagePath": "@telefonica/aura-bot-linking-library",
  "exclude": [
    "./whatsapp/whatsapp-logout-dialog",
    "./whatsapp/whatsapp-otp-login-dialog",
    "./whatsapp/otp-phone-number-dialog",
    "./whatsapp/otp-sms-auth-code-dialog"
  ]
},

To enable all whatsapp dialogs, just remove all those lines and add the following one:

"@telefonica/aura-bot-linking-library",

Now, follow the instructions in the current document in order to apply the updated configuration.

Scenario 2. Linking library is not enabled for any channel

If the linking library is not enabled and you want to enable only whatsapp dialogs, just add the following lines:

{
  "packagePath": "@telefonica/aura-bot-linking-library",
  "exclude": [
    "./account-linking/account-get-oauth-url-dialog",
    "./account-linking/account-linking-dialog",
    "./account-linking/account-remove-dialog",
    "./seamless-account-remove/seamless-account-remove-dialog"
  ]
},

This enables all the dialogs within the handover library.

Now, follow the instructions in the current document in order to apply the updated configuration.

Apply the updated configuration

Once the configuration changes are applied:

If the environment has local use cases:
- First, run again the deploy_local command, once the configuration changes and plugins file modifications are done.
- Then, run deploy_core including -t aura-bridge parameter to deploy config changes to aura-bridge
If the environment is not using local use cases, just run deploy_core including -t aura-bridge aura-bot parameter to deploy config changes to aura-bridge and aura-bot components.

Docs:

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

Install full Aura Bot

Guidelines for the installation and configuration of full Aura Bot

Introduction to full Aura Bot

This document details the steps to locally deploy a fully functional working aura-bot instance. By fully functional working instance, we mean a bot interacting with the Aura Cognitive services as well as with the Kernel APIs deployed as part of the desired environment the local aura-bot instance should interact with. 

Install Aura Bot

ℹ️ This is a general process suitable for every developer and environment.

The general process for the installation of an aura-bot instance is explained below.

Access to the main aura-bot repository:
https://github.com/Telefonica/aura-bot-platform
Clone the repository for the intended release branch, i.e., for Killers release:
git clone https://github.com/Telefonica/aura-bot-platform.git --branch release/killers
Get into the local repository root directory:
$ cd aura-bot-platform
Log in NPM to be able to download the private NPM package dependencies (request the token from the Aura Platform Team (APE) to properly log in). You can login with user/password or using the token:

User/password -> npm login
Token -> Add the token to the environment variables on your machine. Follow the guidelines for mac/linux.

Now configure your bot as explained in the section configure Aura Bot.
If required, install the existing local use cases (packaged as .tgz files)
There are two options:

a. Add the library .tgz file to the file plugin-config.json (placed in the aura-bot-platform Github repository).
Note that manual addition of libraries to plugin-config.json file requires manual installation too:
npm install <library>
b. Use the automatic script:
npm run import-libraries
This process will install any .tgz in aura-bot-platform/local_modules folder.
The previous command will add the library in package.json and plugin-config.json files and will install them into the project.
If a further configuration of the library is required (for example, disabling some dialogs), this must be done manually by editing plugin-config.json available at the root of the aura-bot-platform folder.

Practical example for working with full Aura Bot

The current section includes a practical example of the process for a specific environment (for example, applied to MacOS, Visual Studio, access to the kubernetes cluster, etc.). Therefore, the steps explained below may slightly differ from the general guidelines, but provide a useful practical approach for developers.

Dependencies

The following tools and artifacts are needed:

NodeJS version 14 You can download it here and install it via package manager.
ngrok
The executable binary can be downloaded for several systems in ngrok. Alternatively, ngrok can be installed via the NPM package, once NodeJS is installed, with the following command:
```
    npm install -g ngrok
```
Personal Kubernetes configuration file
Your local DevOps or Development Team will provide you with it. In this case, this file looks like this (the certificate and key data have been modified for security reasons):

    apiVersion: v1

    clusters:

        cluster:

            certificate-authority-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUV5RENDQXJDZ0F3S

            server: https://aura-auradev-1-14-6.westeurope.cloudapp.azure.com

            name: aura-auradev-1-14-6

    contexts:

        context:

            cluster: aura-auradev-1-14-6

            user: german.torodelvalle-1573743046

            name: aura-auradev-1-14-6

        current-context: aura-auradev-1-14-6

            kind: Config

            preferences: {}

    users:

        name: user-1573743046

        user:

            client-certificate-data: LS0tLS1CRUdJTiBDRVJUSUZJQ0FURS0tLS0tCk1JSUVHRENDQWdDZ0F3SUJB

            client-key-data: LS0tLS1CRUdJTiBSU0EgUFJJVkFURSBLRVktLS0tLQpNSUlFb3dJQkFBS0NBUUVBdTR4

A bot service deployed in the Microsoft Azure portal (https://portal.azure.com) enabling the Direct Line channel to be able to interact with the bot from any client using Direct Line.
Visual Studio Code (https://code.visualstudio.com) to be able to debug the running instance of the Aura Bot locally.

Procedure for working with full Aura Bot

To install a working fully operational local instance of aura-bot, follow the steps below:

Local deployment of the aura-bot instance for your Aura Platform release. Check the example below for Jimi Hendrix release (each line corresponds to a command to be executed):
```
    git clone https://github.com/Telefonica/aura-bot-platform.git --branch release/jimihendrix

    cd aura-bot-platform

    npm install
```
Kubernetes configuration: Consider including the next environment variable export in your local terminal starting up configuration file to avoid running the following command each time. Obviously, a correct path to the personal Kubernetes configuration file mentioned as a dependency in the previous dependencies section should be used in the following command.
```
    export KUBECONFIG=~/kubernetes-config.yaml
```
Get the list of available Kubernetes namespaces:
```
    kubectl get ns
```
Get the configuration for the Kubernetes namespace of interest (contact your local DevOps team to figure it out). In our case, since we are deploying a local release of the aura-bot instance, the aura-ap-next should be used as the namespace (the configuration will be stored in a file named aura-bot.ap-next.env):
```
    (kubectl -n aura-ap-next get cm aura-bot -o json | jq -r ".data|to_entries|map(\"\(.key)=\(.value|tostring)\")|.[]" ; kubectl -n aura-ap-next get secret aura-bot -o json | jq -r ".data|to_entries|map(\"\(.key)=\(.value|tostring|@base64d)\")|.[]" ) > aura-bot.ap-next.env
```

Work with Visual Studio Code:

Open the previous aura-bot-platform directory (see step 1) in Visual Studio Code.
Open the internal Visual Studio Code terminal (CONTROL + ` in Windows).
Place the aura-bot.ap-next.env file (see step 4) in the .vscode/.env/ subfolder inside the aura-bot folder. Create the needed directories if not already created.

Include the following launch configuration in the .vscode/launch.json file inside the aura-bot-platform repository (create the needed directories if not already created) to be able to start the aura-bot instance from inside Visual Studio Code. Please, set the AURA_MICROSOFT_APP_ID as well as the AURA_MICROSOFT_APP_PASSWORD configuration variables to the appropriate values obtained when creating the bot service in the Microsoft Azure portal (see the dependency number 4 included in the previous dependencies section):

{

    // Use IntelliSense to learn about possible attributes.

    // Hover to view descriptions of existing attributes.

    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387

    "version": "0.2.0",

    "configurations": [

        {

            "type": "node",

            "request": "launch",

            "name": "aura-bot.ap-next.env",

            "program": "${workspaceFolder}/lib/index.js",

            "console": "integratedTerminal",

            "outFiles": [

                "${workspaceFolder}/lib/**/*.js"

            ],

            "env": {

                "CONFIG_FILE": ".vscode/.env/aura-bot.ap-next.env",

                "AURA_MICROSOFT_APP_ID": "8d72c407-XXXX-4b50-a076-76XXXX5437e4",

                "AURA_MICROSOFT_APP_PASSWORD": "password",

                "AURA_LOGGING_FORMAT": "dev",

                "AURA_LOGGING_LEVEL": "DEBUG"

            }

        }

    ]

}

In the aura-bot.ap-next.env file: Set the values of the configuration variables named AURA_DEFAULT_LOCALE and AURA_DEFAULT_TIME_ZONE to the desired values according to the appropriate language and time zone. For example, for Spain these values are:
```
AURA_DEFAULT_LOCALE=es-es

AURA_DEFAULT_TIME_ZONE=Europe/Madrid
```
Provide access to the Aura Mongo databases:
- Substitute the Mongo connection URI configuration variable (named AURA_MONGODB_URI) located in the .vscode/.env/aura-bot.ap-next.env configuration file to the next value:
```
    AURA_MONGODB_URI=mongodb://localhost:27017
```
- Port forwards the local URI to the real one running the following command in an internal Visual Studio Code terminal using the following command:
```
    kubectl port-forward mongodb-0 -n aura-system 27017:27017
```
This makes your bot use the Mongo database in your development environment, if you are not using Atlas.
Provide access to the Aura Cognitive Services:
- Substitute the Aura Cognitive URI configuration variable (named AURA_COGNITIVE_ENDPOINT) located in the .vscode/.env/aura-bot.ap-next.env configuration file to the next value:
```
    AURA_COGNITIVE_ENDPOINT=http://localhost:7000/auracognitive/v3
```
- Port forwards the local URI to the real one running the following command in an internal Visual Studio Code terminal using the following command:
```
    kubectl -n aura-ap-next port-forward deployment/api-gw 7000:80
```
Provide external access to the locally deployed release of the aura-bot instance:
- Start ngrok in an internal Visual Studio Code terminal using the following command:
```
    ngrok http 8080
```
- Set the new HTTPS URL provided by ngrok in the configuration of the bot service available in the Microsoft Azure portal (see the dependency number 4 included in the dependencies section). The messaging connection endpoint should have a value similar to: https://55a1d84f.ngrok.io/api/messages
The locally deployed release of the aura-bot instance is ready to be started. Click on the “Play” icon in Visual Studio Code to run the launch configuration named aura-bot.ap-next.env.

Interact with the locally deployed Aura release of the aura-bot instance:

11.1. Get a DirectLine token running the following command (instead of the included one, use the secret for the Direct Line channel of the bot service available in the Microsoft Azure portal (see the dependency number 4 included in the dependencies section):

curl --location --request POST 'https://directline.botframework.com/v3/directline/tokens/generate' \

--header 'Authorization: Bearer 55FhfjL8soI.bm-NhUy68mwCfPar4zIjTYHGd5cEGmKWt5zXqmA9rxI' \

-d ''

A response such as the following one is received:

    {

    "conversationId": "AUR2oOohW9Z64MtvuQyoFO-a",

    "token": "ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd01234ZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJuYmYiOiAxNTg4NzYyMjQwLA0KICAiZXhwIjogMTU4ODc2NTg0MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3XXXXLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.pps98q5aYO2T4S7XwdIBudCzZB1T31HlwJ51tbEMcGGJrcHRI-hXnZskjHlcXIzBJiABeYiZSncqyWsNRWSmoVQ3iIYTrBiJM6y1EYn2qDJO4JYjZI5IZeFnp3GieB3eMP-HsW1DixK2p_C2DwxZy5pDc3nveclejI7SeUpl6m4frzNDPfqv7UoEW6aMthnT64JWhzncfF3y3_X-6J5v5RhTPW0OJEXpEuZ94AkhwHLfjLKzyewMwk0NzyAwmnCSZ0p6XyJjx9lA1FByHMRP0OLwcrfE8l_N_eXwUZuSY10gqRl5Tmm-D9p869mooA_0DuJYZUhgH_0D_4yg8PFjtg",

    "expires_in": 3600

    }

11.2. Start the conversation using the token obtained in the previous step (11.1).

curl --location --request POST 'https://directline.botframework.com/v3/directline/conversations' \

--header 'Authorization: Bearer ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd01234ZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJuYmYiOiAxNTg4NzYyMjQwLA0KICAiZXhwIjogMTU4ODc2NTg0MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3XXXXLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.pps98q5aYO2T4S7XwdIBudCzZB1T31HlwJ51tbEMcGGJrcHRI-hXnZskjHlcXIzBJiABeYiZSncqyWsNRWSmoVQ3iIYTrBiJM6y1EYn2qDJO4JYjZI5IZeFnp3GieB3eMP-HsW1DixK2p_C2DwxZy5pDc3nveclejI7SeUpl6m4frzNDPfqv7UoEW6aMthnT64JWhzncfF3y3_X-6J5v5RhTPW0OJEXpEuZ94AkhwHLfjLKzyewMwk0NzyAwmnCSZ0p6XyJjx9lA1FByHMRP0OLwcrfE8l_N_eXwUZuSY10gqRl5Tmm-D9p869mooA_0DuJYZUhgH_0D_4yg8PFjtg' \

--data-raw ''

A response such as the following one is received:

{

  "conversationId": "AUR2oOohW9Z64MtvuQyoFO-a",

  "token": "ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd0b3JvZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJu1234OiAxNTg4NzYyMjY5LA0KICAiZXhwIjogMTU4ODc2NTg2OSwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3b3JrLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.Ft_r71JQ-Qq39nXqzO2u3SEHYMjGY8vMb4_OJL89Uw9NXXXXcvYmM62iu6YG8DcFCy2PFj2hmOev35f06zNXsgbHAthPxTPTIboPO8DyXYFQe8yYbhBKXBt2AIoI4SOO16e_OKaEETh-R2sXe6rfSp3PTgKddzFyLkXCl77e2Tz3TI7Zwe-NIyfmXKhJwd-XzTl7lxJAunSDSDS1i2rwzz8yAjBwJl5wFFhGXnOxPph1bHi_Ag-gU-XIMk_vhTTMLvkCORhBGWZJCNSGXxs5XBUYOZf2oZJA_UWtHqNolNO3K5mF6-cHg188YbAax78-gq0lB2XQCKCamZTmD9TRCg",

  "expires_in": 3600,

  "streamUrl": "wss://directline.botframework.com/v3/directline/conversations/AUR2oOohW9Z64MtvuQyoFO-a/stream?watermark=-&t=ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI61234T08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd0b3JvZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJuYmYiOiAxNTg4NzYyMjY5LA0KICAiZXhwIjogMTU4ODc2MjMyOSwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3b3JrLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.igWA6xJmWwYoTeOV_A5cY_1_spptYgG2xqhJFGBc6PR0l62W-XXXXohqwZqfs7-z-VfyRrWKmD6x2xCw17DRGua6P7qE5Sk9XeV5DcD4XE_f80jGsr86CxFxL_F23iAYWOnpRtYNXJ3yCn69GXHBHvp0sAefLno7JqaoeHZlstyEm72o1v_WqFVd1RHW9zzbbEzQrIhmixUoQbEacuIIMAc6Wtesi3bb8iPOVtFIN_nEovceIieeQggMn0YesYDjiQ600zUX6p4FnU8MPtWpwV6XCSspC3iTuuUSjnpMMbekXYqJHItdgPTE4dPFkqQI_mhPEU0Ravn4vWNQLMd0rg",

  "referenceGrammarId": "95090c7e-6475-5a58-ba7a-35e45f903d38"

}

11.3. Send a message to the bot using the conversation obtained in the previous step and any of the tokens obtained in step 11.1 or 11.2 (you should use a valid user Aura id set in the from.id property, request it from your local QA or DevOps team):

    curl --location --request POST 'https://directline.botframework.com/v3/directline/conversations/AUR2oOohW9Z64MtvuQyoFO-a/activities' \

    --header 'Content-Type: application/json' \--header 'Authorization: Bearer ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd01234ZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJuYmYiOiAxNTg4NzYyMjQwLA0KICAiZXhwIjogMTU4ODc2NTg0MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3XXXXLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.pps98q5aYO2T4S7XwdIBudCzZB1T31HlwJ51tbEMcGGJrcHRI-hXnZskjHlcXIzBJiABeYiZSncqyWsNRWSmoVQ3iIYTrBiJM6y1EYn2qDJO4JYjZI5IZeFnp3GieB3eMP-HsW1DixK2p_C2DwxZy5pDc3nveclejI7SeUpl6m4frzNDPfqv7UoEW6aMthnT64JWhzncfF3y3_X-6J5v5RhTPW0OJEXpEuZ94AkhwHLfjLKzyewMwk0NzyAwmnCSZ0p6XyJjx9lA1FByHMRP0OLwcrfE8l_N_eXwUZuSY10gqRl5Tmm-D9p869mooA_0DuJYZUhgH_0D_4yg8PFjtg
    ' \

    --data-raw ' {

        "type": "message",

        "from": {

            "id": "d1626d20-4e16-46ac-ba3c-c140fa3742a1"

        },

        "text": "Hola"

    }'

A response such as the following one is received:

        {
            "id": "AUR2oOohW9Z64MtvuQyoFO-a|0000001"
        }

To get the message sent by the aura-bot instance, run the following command to get the activities sent in the conversation (use the same conversation started in step 11.2 and any of the tokens obtained in step 11.1.

    curl --location --request GET 'https://directline.botframework.com/v3/directline/conversations/AUR2oOohW9Z64MtvuQyoFO-a/activities' \

    --header 'Authorization: Bearer ew0KICAiYWxnIjogIlJTMjU2IiwNCiAgImtpZCI6ICJBT08tZXhGd2puR3lDTEJhOTgwVkxOME1tUTgiLA0KICAieDV0IjogIkFPTy1leEZ3am5HeUNMQmE5ODBWTE4wTW1ROCIsDQogICJ0eXAiOiAiSldUIg0KfQ.ew0KICAiYm90IjogImF1cmEtYm90LWd01234ZGVsdmFsbGUiLA0KICAic2l0ZSI6ICI1NUZ1dmdMOHNvSSIsDQogICJjb252IjogIkFVUjJvT29oVzlaNjRNdHZ1UXlvRk8tYSIsDQogICJuYmYiOiAxNTg4NzYyMjQwLA0KICAiZXhwIjogMTU4ODc2NTg0MCwNCiAgImlzcyI6ICJodHRwczovL2RpcmVjdGxpbmUuYm90ZnJhbWV3XXXXLmNvbS8iLA0KICAiYXVkIjogImh0dHBzOi8vZGlyZWN0bGluZS5ib3RmcmFtZXdvcmsuY29tLyINCn0.pps98q5aYO2T4S7XwdIBudCzZB1T31HlwJ51tbEMcGGJrcHRI-hXnZskjHlcXIzBJiABeYiZSncqyWsNRWSmoVQ3iIYTrBiJM6y1EYn2qDJO4JYjZI5IZeFnp3GieB3eMP-HsW1DixK2p_C2DwxZy5pDc3nveclejI7SeUpl6m4frzNDPfqv7UoEW6aMthnT64JWhzncfF3y3_X-6J5v5RhTPW0OJEXpEuZ94AkhwHLfjLKzyewMwk0NzyAwmnCSZ0p6XyJjx9lA1FByHMRP0OLwcrfE8l_N_eXwUZuSY10gqRl5Tmm-D9p869mooA_0DuJYZUhgH_0D_4yg8PFjtg
    '

A response such as the following one is received:

{

  "activities": [

    {

      "type": "message",

      "id": "AUR2oOohW9Z64MtvuQyoFO-a|0000000",

      "timestamp": "2020-05-06T11:14:43.8618783Z",

      "serviceUrl": "https://directline.botframework.com/",

      "channelId": "directline",

      "from": {

        "id": "d1626d20-4e16-46ac-ba3c-c140fa3742a1"

      },

      "conversation": {

        "id": "DvpneVrCrDG9DVIL7pQr5N-a"

      },

      "text": "Hola"

    },

    {

      "type": "message",

      "id": "AUR2oOohW9Z64MtvuQyoFO-a|0000001",

      "timestamp": "2020-05-06T11:14:49.2303326Z",

      "localTimestamp": "2020-05-06T11:14:45.764+00:00",

      "channelId": "directline",

      "from": {

        "id": "aura-bot-gtorodelvalle",

        "name": "aura-bot-gtorodelvalle"

      },

      "conversation": {

        "id": "AUR2oOohW9Z64MtvuQyoFO-a"

      },

      "text": "Hola, buenas",

      "inputHint": "acceptingInput",

      "channelData": {

        "correlator": "6a3ccc2a-c80e-441f-83ff-945691fd3407"

      },

      "replyToId": "DvpneVrCrDG9DVIL7pQr5N-a|0000000"

    }

  ],

  "watermark": "1"

}

ℹ️ Instead of using HTTP requests, another possibility is to use the Web Sockets URL obtained in step 11.2 (see the streamUrl property obtained in the response) using a Web Sockets client such as the Smart Web Sockets extension for Google Chrome.

Notice the Aura Cognitive services recognized the “Hola” text message sent to the bot as a greeting and it responded with a greeting message (“Hola, buenas”).

You could set a breakpoint in any part of the code (for example, in the greetings dialog) to debug it.

Docs:

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

Work with Kernel

Guidelines that include different tasks required for working with Kernel

Index

Docs:

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

Channels registration template

Template for the registration of a channel in Aura

How to use the template

The main steps that OBs willing to register a channel in Aura must follow are summarized below:

Create a task for channel registration in JIRA
Copy the table below and paste it onto the JIRA task
Fill in all the fields in the table’s column “Value in channel” for the complete definition of the channel.
Do not modify the content of the remaining columns aside from “Value in channel”.

This will serve as the basis for the subsequent creation of the channel by Aura by Aura Global Team or GES.

Template

CHANNELS REGISTRATION TEMPLATE
a. Channel basic data
Property	Definition	Feasible Values	Value in channel
Channel name	Channel descriptive name Use lowercase hyphen-separated words	N/A	to be completed
Channel prefix	Minimal expression of the channel name Use lowercase hyphen-separated words	N/A	to be completed
Channel ID	UUID that identifies the channel univocally in Aura	N/A	to be completed
Channel type	Type of channel among the feasible values	*- directline* *- directline.tv* *- whatsapp* *- auraline*	to be completed
Formats	Specific formats used by the channel: language, date, currency, etc.	N/A	to be completed

b. Channel configuration
Property	Definition	Feasible Values	Value in channel
Configuration environments	Name of environment(s) where the channel is to be configured	N/A	to be completed
channelData version	Version of the channelData property that defines Aura request-response model	*- channelData v1* *- channelData v2* *- channelData v3*	to be completed
Response type	Type of response messages supported by the channel. Parameter defined in the outputMessageFormat channel model property. Recommended value in new channels: *custom*	*- custom: TV channels - enrich: Channels supporting Adaptive Cards (Novum) - simple*: Channels supporting Hero Cards (WhatsApp)	to be completed
Global suggestions	Indicate if the channel must include global suggestions	*- Yes* *- No*	to be completed
Disambiguation	*- Suggestions* *- Prompt* *- Disabled*	to be completed
Type of users	Type(s) of Aura users that can be supported by the channel	*- Anonymous users* *- Authenticated users*	to be completed
Type of anonymous users	Type of anonymous users, depending on the `userId`	*- Anonymous* *- Identifiable* *- N/A*	to be completed
Authentication type	Type of authentication supported by the channel	*- Integrated authentication* *- Non-integrated authentication* *- N/A*	to be completed
UserProfile allowed?	Indicate whether or not UserProfile Kernel API must be called when authenticating a user in the channel	*- Yes* *- No* *- N/A*	to be completed
Terms and Conditions required?	In case of integrated authentication, indicate whether or not T&C are required	*- Yes* *- No* *- N/A*	to be completed
POEditor resources	Are specific POEditor resources required for this channel? If yes, add the list of resources from other channels that should be duplicated here	*- Yes* *- No*	to be completed

c. Understanding issues
Property	Definition	Feasible Values	Value in channel
Aura NLP required?	Indicate whether or not the channel counts on any training handled by Aura NLP	*- Yes* *- No*	to be completed
*- Yes* *- No*	to be completed
Entities recognition stages	Indicate if NLP will contain entities recognition stages (therefore, dictionaries will be required)	*- Yes* *- No*	to be completed
Local grammars	Indicate if local grammars are required	*- Yes* *- No*	to be completed
NLP development	Indicate which team is in charge of NLP development	*- OB's Local Team* *- Aura Global Team*	to be completed

Docs:

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

Handover activation

Guidelines for the activation and deactivation of direct handover-genesys feature in Aura

Prerequirements

This step must be only executed if the environment counts on a channel which integration with the customer center system in done via an aura-bot dialog and only if the customer center system is Genesys.
It must be executed only once, when setting up the dialog. Afterwards, the configuration must just be reviewed.

Moreover, the following pre-requirements must be met:

A kubeconfig of the Aura environment to be configured is available.
Request to Genesys team the data to access the service:
- The URL of Genesys service endpoint. For instance, in PRE environment in Spain is: https://www.movistar.es/atcliente/Chat_PRE/ReActivo
- This endpoint must use basic HTTP authorization, so please, request also the credentials to access it.
There is an URL where the genesys callback of aura-bridge will be listening to once activated. Usually, something like: https://{{aura-services-domain}}.auracognitive.com/aura-services/v1/genesys/messages?apikey={{api_key}}
Where:
- {{aura-services-domain}} should svc-[country]-[environment], for instance svc-es-pre
- {{api_key}} is a specific APIKey created for genesys to access this endpoint.
Send the aura-bridge Genesys callback to Genesys team, so it can be configured as callback to send the push notifications. They have to update the callback related to GCTI_GMS_PushProvider: Aura to this URL.
There is a Kernel environment to which Aura environment is connected. Recommended:
- kubectl installed in your local host.
- curl installed in your local host.
- jq installed in your local host.

Enabling Genesys controller in Aura bridge

Ensure that all Genesys necessary plugins are set in aura-bridge plugin configuration file:

[
  "./lib/plugins/async-callback-directline-processor",
  "./lib/plugins/directline-service"
]

Once the configuration is applied, validate that the Genesys controller is working properly:

# substitute <aura-services-domain> with the domain of your environment, usually something like svc-es-pro
# substitute <api-key> with an apikey generated
# generate a valid UUID as correlator
# substitute {{correlator}} with the generated UUID
export CORRELATOR={{correlator}}

$ curl -i -X POST -H 'Content-Type: application/json' -H 'x-correlator: $CORRELATOR' 'https://<aura-services-domain>.auracognitive.com/aura-services/v1/whatsapp/messages?apikey=<api-key>'

It should return a response with a 401 statusCode.
If the endpoint is not configured, it should return a 404.

Enabling Genesys use case in Aura Bot

Set the following environment variables in the aura-bot section of your Aura installer configuration, as explained in the document Aura installer aurak8s.

aura_bot:
  config:
    HANDOVER_CLIENT_BASE_PATH_URL: '<genesys-api-endpoint>' # URL to access genesys system
    HANDOVER_CLIENT_BASIC_AUTH_NAME: '<aura-user-name>' # user for the basic authorization of genesys endpoint
    HANDOVER_CLIENT_BASIC_AUTH_PASSWORD: '<aura-user-secret>' # password for the basic authorization of genesys endpoint
    HANDOVER_CHAT_SERVICE_NAME: 'XXXX' # base chat name configured in genesys, by default, request-whatsapp-aura`
    HANDOVER_CHECK_STATUS_CHAT_SERVICE_NAME: 'XXX' #chat service to validate communication, by default request-whatsapp-testaura
    HANDOVER_USERDATA_GCTI_GMS_NODEGROUP: 'XXX' # in genesys PRE environments GMS_Cluster, in pro TELF_GMS_Cluster
    HANDOVER_ALWAYS_USE_REMOTE_CACHE: false # cache to get the bypass data. By default, false.

Review the plugins-config.json file to set the proper libraries configuration. This file can be found in this path of Aura installer, where you have to choose the country for your installation: br, de, es, uk:
deploy/files/containers/bot/plugin-config-[country].json

If the handover library is configured but the genesys use case is disabled, the file would contain the following lines:

{
    "packagePath": "@telefonica/aura-bot-handover-library",
    "exclude": [
        "./handover-genesys/handover-bypass-dialog",
        "./handover-genesys/handover-status-dialog"
    ]
},

To enable the use case, just remove all those lines and add the following one:
```
"@telefonica/aura-bot-handover-library",
```
If handover library was not previously configured in your environment, just add the last line. This enables all the dialogs within the handover library.
Now, follow the instructions in the current document in order to apply the updated configuration.

Apply the updated configuration

Once the configuration changes are applied:

If the environment has local use cases:
- First, run again the deploy_local command, once the configuration changes and plugins file modifications are done.
- Then, run deploy_core including -t aura-bridge parameter to deploy config changes to aura-bridge
If the environment is not using local use cases, just run deploy_core including -t aura-bridge aura-bot parameter to deploy config changes to aura-bridge and aura-bot components.

Docs:

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

Activate features in Aura

Guidelines for the activation / deactivation of different features in Aura

Introduction

In order to customize your Aura system and adapt it to your requirements, it is possible to activate or deactivate certain features listed below:

Docs:

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

Aura File Manager activation

Guidelines for the activation and deactivation of the Aura File Manager module

Related documents
📃Aura File Manager description

Prerequirements

This step must be only executed if the environment counts on a channel of whatsapp type (WhatsApp channel).
It must be executed once, when setting up each channel. Afterwards, the configuration must just be reviewed.

Steps for File Manager enabling

In order to enable Aura File Manager component to deploy it in environment, follow these steps:

Add to the environment config file the following command:
```
file_manager_enabled: true
```
Only for ES environments, it is also required to set the lines below, as the Whatsapp channel is already configured to accept this configuration in the environment config file:
```
clients:
  wa:
    file_attachments:
      enabled: true
```
If the clients structure already exists in the config file, merge this configuration with the current one:
- WhatsApp channels need to have enabled attachments:
```
{
    name: 'nameOfChannel',
    requestOptions: {
        fileAttachments: {
            enabled: true
        }
    }
}
```
  Find here detailed information regarding the requestOptions model within Aura channel model, that includes the configuration of the allowed files.
In order to process the files, aura-bot must set the Aura File Manager API URL in the environment variable AURA_FILE_ENDPOINT.
On the other hand, the variables of the File Manager must be configured.
It is also needed to configure a container in Azure Storage with Automatic removal files.

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

Install and configure in Aura Virtual Assistant

Install components in Aura Virtual Assistant, customize your system once deployed through the activation/deactivation of features and adapt the configuration to your requirements

Introduction

Once Aura Virtual Assistant is deployed, OBs can adapt their system to their specific requirements and users need in terms of components, types of clients, demanded experiences, etc. Tasks in this section can be organized in four groups:

Installation of components in Aura Virtual Assistant

Get started with Aura Bot: install and configure aura-bot
Install global use cases: guidelines for the installation of global use cases and global dialogs in charge of their logic.

Activation of features

After deployment, learn how to activate or deactivate features in Aura such as the aura-file-manager

Configure Aura

Use the Aura configuration updater to easily change channels configuration and POEditor resources.

Keda configuration

Guidelines for the configuration of Keda, used for the autoscaling of pods

Docs:

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

Connect a channel to Auraline

Guidelines for the connection of a channel to Auraline communication protocol

These guidelines are valid both for the scenario of an individual channel connecting to Auraline and for the connection of a channel aggregation platform to Auraline, although they are firstly conceived for the second scenario (Specific scenario for the use of Auraline communication protocol: CCaaS).

Introduction

Aura Platform Team has developed a new communication protocol: Auraline. It is based on Direct Line but with significant advantages as it is a proprietary one and, consequently, eliminates the dependency on Microsoft.

Channels can use this protocol through the Aura Request – Response Semantic Model, within the version v3 of the channelData property.

Find detailed information regarding Auraline communication protocol.

Prerequisites

For sending messages from a channel through Auraline, there are certain mandatory pre-requirements described below:

The channel must have a callback endpoint exposed to receive the responses.
- It must include an authorization type: Bearer, APIKey, etc. Only APIKey authentication will be supported for this initial phase, due to its simple approach.
- The value for this endpoint and header will be included in the configuration of each channel in Aura.
- This callback endpoint might be the same for all channels, but it also can be different, and so the required authorization.
Before sending messages, a new conversation must be generated.
- To generate a new conversation, an APIKey is required.
- This APIKey expires, so it is the channel’s responsibility to refresh it before the expiration date.
- The conversation provides back a conversationId and a token.
- This token also expires, so it is required to refresh it or to obtain a new one.
- Once the previous steps are completed, you can start sending messages through Auraline.

Data to be used

aura-root needs a different userId per user and channel (individual application):
- If it exists, we usually use the identifier of the channel (i.e., the whatsapp_id or the phone_number in a call)
- If it does not exist, as in a web chat for this first phase, we recommend generating an identifier per session opened by the user. We normally generate a UUIDv4, but aura-root allows any string in the from.id field.
aura-root will set up the selected channels. In the first phase, we will set up the selected Web Chat and provide the channel identifier to the channel, so it can be used in the requests.
- Certain information is required to set up the channel, such as the already mentioned callback URL and its authorization/credentials.

Integration scenario

The following figures show two different scenarios for the connection of a channel to Auraline:

Connection of an individual channel to Auraline
Connection of a channel aggregation platform to Auraline (for example, a call-center as a service (CCaaS) that aggregates several channels)

Communication protocol

The following sections describe Auraline communication protocol, that includes three main tasks: handling conversations, sending messages within a conversation and sending answers to the channel. Each of them is managed by an aura-bridge API:

Handling conversations

If the channel does not count on a valid conversationId/token for the user/channel pair, then a new conversation MUST be created.
An APIKey will be provided to the channel per environment that will allow access to this endpoint.

Create a conversation

The following snippets provide an example of the start conversation request and response.

It is recommended to count on a dedicated BE service that is in charge of creating conversations, so the semi-permanent APIKey is not included in the user’s apps. The app should only handle the temporary token created for each conversation.

Request

POST https://svc-[ENV].auracognitive.com/aura-services/v1/auraline/conversations
Authorization: APIKEY iaJrC8xpy8qbOF5xnR2vtCX7CZj0LdjAPGfiCpg4Fv0y8qbOF5xPGfiCpg4Fv0y8qqbOF5x8qbOF5xn

Response

HTTP/1.1 201 Created
[other headers]
{
  "conversationId": "X7CZj0LdjAPGfiCpg4Fv",
  "token": "RCurR_XV9ZA.cwA.BKA.iaJrC8xpy8qbOF5xnR2vtCX7CZj0LdjAPGfiCpg4Fv0y8qbOF5xPGfiCpg4Fv0y8qqbOF5x8qbOF5xn",
  "expires_in": 1800,
}

Example

A real example with development environment ap-one is shown below:

Parameters:

URL to get conversation Id: https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations
Method: Post
APIKey: 5498fc14aec4d4f0d1d2db588ce0ef1023630c9bbb299af2af88bc873002b60fdbe9ff9bdc7538dfd5bf5afd94795f7ce38b71793daa8f41447c15c638c1b81550c762ccc6e6c5ab4cabc8d26290943a7dd6a853d776ad8cc301b06ba8c3a62dc23a3e2a5a33ae2616c0bc5a969232e214c1235dd05ffe40c2df85859637faeeef2a71997380a68e61a5cef317dc97148137105214945fbd96b9e56f85a90797e659b35008ed3ed355c741af4c3f015b

curl --location --request POST 'https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations' \
--header 'Authorization: APIKEY 5498fc14aec4d4f0d1d2db588ce0ef1023630c9bbb299af2af88bc873002b60fdbe9ff9bdc7538dfd5bf5afd94795f7ce38b71793daa8f41447c15c638c1b81550c762ccc6e6c5ab4cabc8d26290943a7dd6a853d776ad8cc301b06ba8c3a62dc23a3e2a5a33ae2616c0bc5a969232e214c1235dd05ffe40c2df85859637faeeef2a71997380a68e61a5cef317dc97148137105214945fbd96b9e56f85a90797e659b35008ed3ed355c741af4c3f015b' \
--data ''

Refresh a conversation token

If the channel (CCaaS) counts on a previously requested conversationId/token, it must be refreshed before it expires.

Request

POST https://svc-[ENV].auracognitive.com/aura-services/v1/auraline/conversations/X7CZj0LdjAPGfiCpg4Fv0y8xpy8qbOF5xnR2vtCX7CZj0Ldj/refresh
Authorization: APIKEY RCurR_XV9ZA.cwA.BKA.iaJrC8xpy8qbOF5xnR2vtCX7CZj0LdjAPGfiCpg4Fv0y8qbOF5xPGfiCpg4Fv0y8qqbOF5x8qbOF5xn

Response

HTTP/1.1 200 OK
[other headers]
{
  "conversationId": "X7CZj0LdjAPGfiCpg4Fv",
  "token": "RCurR_XV9ZA.cwA.BKA.y8qbOF5xPGfiCpg4Fv0y8qqbOF5x8qbOF5xniaJrC8xpy8qbOF5xnR2vtCX7CZj0LdjAPGfiCpg4Fv0",
  "expires_in": 1800
}

Example

A real example with development environment ap-one is shown below:

ConversationId: ddlu65ft
URL to get conversation Id: https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations/ddlu65ft/refresh/
Method: Post
APIKey: 005c4dae31a660fb7435034ded7790b843e139afc8d7512b973d2073b9be16172b69fe8952e1590c282bb7cb6a7fce362db5218b84dc960dec9c2dee8654d45def1c184e7a73988c3db67f62eb656ac2e646cc266942c016e32e048a13ee52ea0980a65f21dc119aff57af07cf5d3cb1320e4c52c5d964cabf0e4fb06ba38667861b5943fd59f6f7525151014776181e04f47033e99e3cd38810fc0d0470881c4aacc7f5b60c3f46a8a65f2c37a4dc00

curl --location --request POST 'https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations/ddlu65ft/refresh' \
--header 'Authorization: APIKEY RCurR_XV9ZA.cwA.BKA.y8qbOF5xPGfiCpg4Fv0y8qqbOF5x8qbOF5xniaJrC8xpy8qbOF5xnR2vtCX7CZj0LdjAPGfiCpg4Fv0' \
--data ''

This example uses a temporary token. You must generate your own conversationId to test it.

Sending messages within a conversation

In order to send an activity to aura-bridge, the client must create an Activity object to define the activity and then issue a POST request to https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations/{conversationId}/activities, specifying the Activity object in the body of the request.

The following snippets provide an example of the Send Activity request and response. This is only an example without full integration with aura-bridge.

Request

POST https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations/X7CZj0LdjAPGfiCpg4Fv/activities
Authorization: APIKEY TOKEN-GENERATED-FOR-CONVERSATION
Content-Type: application/json
[other headers]
{
    "locale": "en-EN",
    "type": "message",
    "from": {
        "id": "user1"
    },
    "text": "hallo",
    "channelData": {
       "version": "3",
       "correlator": "a9db4c4f-3ad5-6331-b34a-8ffb0254aaea3",
       "appContext": {
          "channel": {
             "id": "f69f5766-9386-169d-c386-34463b99a956",
             "modality": "text"
          }
      }
    }
}

Response

When the activity is delivered, the service responds with an HTTP status code that reflects the status code.

If the POST is successful, the response contains a JSON payload that specifies the ID of the Activity that was sent to the bot.

HTTP/1.1 200 OK
[other headers]
{
    "id": "nR2vtCX7"
}

Sending answers to the channel

Activities are returned by Aura to the channel in the callback configured for each channel.

The activityId will be a composition of the incoming activityId and the order of the response, separated by |. This follows Direct Line identifiers approach.

In any case, the order can also be inferred from the array direct order. We just added the pipe and the number to mimic Direct Line ids.

Request

Send messages from Aura to a specific channel.

# https://ccaas-callback-url/auraline/v1/conversations/{conversationId}/activities/{messageId}
POST https://ccaas-callback-url/auraline/v1/conversations/j0LdjAPGfiCpg/activities/nR2vtCX7
Authorization: CALLBACK-TOKEN-PROVIDED-BY-SPRINKLER
  
{
    "activities": [
        {
            "type": "message",
            "channelId": "channelId",
            "conversation": {
                "id": "j0LdjAPGfiCpg"
            },
            "id": "nR2vtCX7|0001",
            "from": {
                "id": "bot1"
            },
            "text": "hello"
        },
        {
            "type": "message",
            "channelId": "channelId",
            "conversation": {
                "id": "j0LdjAPGfiCpg"
            },
            "id": "nR2vtCX7|0002",
            "from": {
                "id": "bot1"
            },
            "text": "How are you?"
        }
    ]
}

Response

When the activity is posted to the configured callback, the channel or CCaaS callback responds with an HTTP status code that reflects the status of the reception.

If the POST is successful, a 204 OK is expected. In this scenario Aura does not need anything, apart from the status code.

HTTP/1.1 204 OK
[other headers]

Answer status

aura-root needs that the channel or CCaaS informs about the status of the response delivered to the user.

Request

POST https://svc-de-dev.auracognitive.com/aura-services/v1/auraline/conversations/j0LdjAPGfiCpg/activities/nR2vtCX7/status
Authorization: APIKEY TOKEN-GENERATED-FOR-CONVERSATION
  
[{
    "id": "nR2vtCX7|0001",
    "status": "delivered"
},
{
    "id": "nR2vtCX7|0002",
    "status": "failed",
    "description": "Internal Error"
}]

Where:

status: Possible values delivered or failed.
description: Optional field intended for describing what happened with all the responses of each incoming message.

Response

HTTP/1.1 204 OK
[other headers]

Docs:

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

Enable corporate anonymous users check

Guidelines for the activation and deactivation of corporate anonymous users check, both general steps and specific ones for the use case under development

Prerequirements

Request to Kernel and OB Operations Teams to provide a purpose for aura-bot client in Kernel that provides access to UserProfile API via client credentials flow. It should be something like aura-bot-search-customer-purpose.
Request to Kernel to update the aura-bot client in Kernel to include the new purpose in client credentials flow. For instance:

        {
            "name": "client_credentials",
            "scopes": [
                "whatsapp:app-admin",
                "whatsapp:app-messaging",
                "whatsapp:manage-templates"
            ],
            "purposes": [
                "auraid-admin",
                "aura-bot-search-customer-purpose"
            ]
        }

Activation

Set the following environment variable in aura-bot configmap or in the configuration file of the environment.

AURA_FP_CLIENT_CRED_PURPOSES: aura-bot-search-customer-purpose

Activate the validation in the corresponding channels. These channels must support anonymous users and the identifier coming from the channel must be a phonenumber, WhatsApp based channels, for instance. Add the following settings to your channel configuration:

    "security": {
        "anonymous": "identifiable",
        "anonymousSettings": {
            "checkPromptedNumber": false,
            "enableUserProfile": true
        }
    }

Further information regarding these settings is found in anonymousSettings and aura-configuration-api component.

Docs:

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

Manage channels in Aura

Guidelines for the management of channels in Aura: how to activate of different channels; connect a channel to Auraline and more

Introduction

An Aura channel is any communication means a Telefónica client may use to interact with Aura, typically to gather information about, as well as to manage, the client’s Telefónica products and services.

Firstly, we recommend reading the descriptive documentation regarding channels in Aura:

Introduction to Aura channels
Aura communication protocols
Channels authentication
Aura channel model: updated model for the communication between Aura and a channel.
Descriptive information regarding key channels available in Aura: WhatsApp channel and Aura Webclient

The current section includes practical guidelines for the management of channels in Aura:

General guidelines

Guidelines for specific OBs/scenarios

Docs:

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

Manage skills

The following guidelines include the detailed processes required for working with skills in Aura new distributed architecture (Phase 1)

ℹ️ Before facing these documents, The Aura Platform Team highly recommends reading the basic information regarding Aura distributed architecture to have a clear overview of the functional architecture, its benefits and foundations

Introduction

Aura new architecture is conceived as a multi-bot system, based on Microsoft skills architecture, that works with an orchestrator at the top (Aura Root). Currently, skills are independent domain bots able to manage specific experiences (use cases) of the same type.

In this framework, constructors can develop and integrate into Aura different type of skills, as independent modules:

Skills developed over Aura cluster (Microsoft Bot Framework Direct Line protocol).
Skills developed outside Aura cluster with a technology compatible with Microsoft Bot Framework (Composer, etc.).
Third-party bots, developed with other technologies available on the market. These skills will require an adapter for its communication with Aura Root.

In the phase 1 of the architecture implementation, these are the main tasks that must be executed by constructors in order to make the most of Aura:

Develop a skill
Connect a skill to Aura Root
Connect a skill to Aura Minigroot for testing purposes
Message exchange between channels and skills
Hot swapping processes to add or delete a skill

Aura – installation

Docs:

Google RCS Business Messaging channel activation

Create an RBM account

Configure a new agent

Docs:

Install global use cases

Introduction

Installation of global use cases

Uninstallation of global use cases

Installation of dialogs in Aura minibot

Docs:

Aura Mocks server installation

Introduction

Installation

Run tests

Code style tests

Deployment

Build local docker image

Run server

Deploy

Developer notes

Versioning

Docs:

QA Tool installation guide

Download the QA test set from a Github repository

Create and activate the new virtual environment

Install requirements

Docs:

WhatsApp channel activation

Prerequirements

Register WhatsApp in Kernel and FacebookManager

Add WhatsApp scopes in your application

Get a valid access_token to start the registering process

Register the phone number in Facebook Manager

Request a registration code

Verify registration

Set the webhook

Enabling WhatsApp controller in Aura Bridge

Enabling WhatsApp login and logout dialogs

Scenario 1. Linking library is already enabled for any channel

Scenario 2. Linking library is not enabled for any channel

Apply the updated configuration

Docs:

Install full Aura Bot

Introduction to full Aura Bot

Install Aura Bot

Practical example for working with full Aura Bot

Dependencies

Procedure for working with full Aura Bot

Docs:

Work with Kernel

Index

Docs:

Channels registration template

How to use the template

Template

Docs:

Handover activation

Prerequirements

Enabling Genesys controller in Aura bridge

Enabling Genesys use case in Aura Bot

Apply the updated configuration

Docs:

Activate features in Aura

Introduction

Docs:

Aura File Manager activation

Prerequirements

Steps for File Manager enabling

Docs:

Guidelines for OBs

Introduction

Installation of PPD-Creator

Execution of PPD-Creator

Parameters to launch the PPD-Creator

Launching PPD-Creator

Output from PPD-Creator

Local data visualization (optional)

Docs: