1083 lines
38 KiB
TypeScript
1083 lines
38 KiB
TypeScript
/*****************************************************************************\
|
|
| ( )_ _ |
|
|
| _ _ _ __ _ _ __ ___ ___ _ _ | ,_)(_) ___ ___ _ |
|
|
| ( '_`\ ( '__)/'_` ) /'_ `\/' _ ` _ `\ /'_` )| | | |/',__)/' v `\ /'_`\ |
|
|
| | (_) )| | ( (_| |( (_) || ( ) ( ) |( (_| || |_ | |\__, \| (˅) |( (_) ) |
|
|
| | ,__/'(_) `\__,_)`\__ |(_) (_) (_)`\__,_)`\__)(_)(____/(_) (_)`\___/' |
|
|
| | | ( )_) | |
|
|
| (_) \___/' |
|
|
| |
|
|
| General Bots Copyright (c) Pragmatismo.io. All rights reserved. |
|
|
| Licensed under the AGPL-3.0. |
|
|
| |
|
|
| According to our dual licensing model, this program can be used either |
|
|
| under the terms of the GNU Affero General Public License, version 3, |
|
|
| or under a proprietary license. |
|
|
| |
|
|
| The texts of the GNU Affero General Public License with an additional |
|
|
| permission and of our proprietary license can be found at and |
|
|
| in the LICENSE file you have received along with this program. |
|
|
| |
|
|
| This program is distributed in the hope that it will be useful, |
|
|
| but WITHOUT ANY WARRANTY, without even the implied warranty of |
|
|
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
| GNU Affero General Public License for more details. |
|
|
| |
|
|
| "General Bots" is a registered trademark of Pragmatismo.io. |
|
|
| The licensing of the program under the AGPLv3 does not imply a |
|
|
| trademark license. Therefore any rights, title and interest in |
|
|
| our trademarks remain entirely with us. |
|
|
| |
|
|
\*****************************************************************************/
|
|
|
|
/**
|
|
* @fileoverview General Bots server core.
|
|
*/
|
|
|
|
'use strict';
|
|
|
|
import urlJoin = require('url-join');
|
|
const { DialogSet, TextPrompt } = require('botbuilder-dialogs');
|
|
const express = require('express');
|
|
const request = require('request-promise-native');
|
|
const removeRoute = require('express-remove-route');
|
|
const AuthenticationContext = require('adal-node').AuthenticationContext;
|
|
const wash = require('washyourmouthoutwithsoap');
|
|
import {
|
|
AutoSaveStateMiddleware,
|
|
BotFrameworkAdapter,
|
|
ConversationState,
|
|
MemoryStorage,
|
|
TurnContext,
|
|
UserState
|
|
} from 'botbuilder';
|
|
import { ConfirmPrompt, OAuthPrompt, WaterfallDialog } from 'botbuilder-dialogs';
|
|
import {
|
|
GBDialogStep,
|
|
GBLog,
|
|
GBMinInstance,
|
|
IGBAdminService,
|
|
IGBConversationalService,
|
|
IGBCoreService,
|
|
IGBInstance,
|
|
IGBPackage
|
|
} from 'botlib';
|
|
import { AzureText, CollectionUtil } from 'pragmatismo-io-framework';
|
|
|
|
import { MicrosoftAppCredentials } from 'botframework-connector';
|
|
import fs = require('fs');
|
|
import { GBServer } from '../../../src/app';
|
|
import { GBAdminService } from '../../admin.gbapp/services/GBAdminService';
|
|
import { GuaribasConversationMessage } from '../../analytics.gblib/models';
|
|
import { AnalyticsService } from '../../analytics.gblib/services/AnalyticsService';
|
|
import { GBVMService } from '../../basic.gblib/services/GBVMService';
|
|
import { AskDialogArgs } from '../../kb.gbapp/dialogs/AskDialog';
|
|
import { KBService } from '../../kb.gbapp/services/KBService';
|
|
import { SecService } from '../../security.gbapp/services/SecService';
|
|
import { WhatsappDirectLine } from '../../whatsapp.gblib/services/WhatsappDirectLine';
|
|
import { Messages } from '../strings';
|
|
import { GBConfigService } from './GBConfigService';
|
|
import { GBConversationalService } from './GBConversationalService';
|
|
import { GBDeployer } from './GBDeployer';
|
|
|
|
/**
|
|
* Minimal service layer for a bot and encapsulation of BOT Framework calls.
|
|
*/
|
|
export class GBMinService {
|
|
|
|
/**
|
|
* Default General Bots User Interface package.
|
|
*/
|
|
private static uiPackage = 'default.gbui';
|
|
|
|
/**
|
|
* Main core service attached to this bot service.
|
|
*/
|
|
public core: IGBCoreService;
|
|
|
|
/**
|
|
* Reference to conversation services like receive and prompt text.
|
|
*/
|
|
public conversationalService: IGBConversationalService;
|
|
|
|
/**
|
|
* Conversational administration services like publishing packages.
|
|
*/
|
|
public adminService: IGBAdminService;
|
|
|
|
/**
|
|
* Deployent of packages and publishing related services.
|
|
*/
|
|
public deployer: GBDeployer;
|
|
|
|
/**
|
|
* Static initialization of minimal instance.
|
|
*
|
|
* @param core Basic database services to identify instance, for example.
|
|
*/
|
|
constructor(
|
|
core: IGBCoreService,
|
|
conversationalService: IGBConversationalService,
|
|
adminService: IGBAdminService,
|
|
deployer: GBDeployer
|
|
) {
|
|
this.core = core;
|
|
this.conversationalService = conversationalService;
|
|
this.adminService = adminService;
|
|
this.deployer = deployer;
|
|
}
|
|
|
|
/**
|
|
* Constructs a new minimal instance for each bot.
|
|
*/
|
|
public async buildMin(instances: IGBInstance[]) {
|
|
|
|
// Servers default UI on root address '/' if web enabled.
|
|
if (process.env.DISABLE_WEB !== 'true') {
|
|
const url = GBServer.globals.wwwroot
|
|
? GBServer.globals.wwwroot
|
|
: urlJoin(GBDeployer.deployFolder, GBMinService.uiPackage, 'build');
|
|
|
|
GBServer.globals.server.use('/', express.static(url));
|
|
}
|
|
|
|
// Servers the bot information object via HTTP so clients can get
|
|
// instance information stored on server.
|
|
|
|
if (process.env.DISABLE_WEB !== 'true') {
|
|
GBServer.globals.server.get('/instances/:botId', this.handleGetInstanceForClient.bind(this));
|
|
}
|
|
|
|
// Servers the WhatsApp callback.
|
|
|
|
GBServer.globals.server.post('/webhooks/whatsapp', this.WhatsAppCallback.bind(this));
|
|
|
|
// Call mountBot event to all bots.
|
|
|
|
await CollectionUtil.asyncForEach(instances, async instance => {
|
|
try {
|
|
await this.mountBot(instance);
|
|
} catch (error) {
|
|
GBLog.error(`Error mounting bot ${instance.botId}: ${error.message}`);
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Removes bot endpoint from web listeners and remove bot instance
|
|
* from list of global server bot instances.
|
|
*/
|
|
public async unmountBot(botId: string) {
|
|
const url = `/api/messages/${botId}`;
|
|
removeRoute(GBServer.globals.server, url);
|
|
|
|
const uiUrl = `/${botId}`;
|
|
removeRoute(GBServer.globals.server, uiUrl);
|
|
|
|
GBServer.globals.minInstances = GBServer.globals.minInstances.filter(p => p.instance.botId !== botId);
|
|
}
|
|
|
|
/**
|
|
* Mount the instance by creating an BOT Framework bot object,
|
|
* serving bot endpoint in several URL like WhatsApp endpoint, .gbkb assets,
|
|
* installing all BASIC artifacts from .gbdialog and OAuth2.
|
|
*/
|
|
public async mountBot(instance: IGBInstance) {
|
|
|
|
// Build bot adapter.
|
|
|
|
const { min, adapter, conversationState } = await this.buildBotAdapter(
|
|
instance,
|
|
GBServer.globals.sysPackages,
|
|
GBServer.globals.appPackages
|
|
);
|
|
GBServer.globals.minInstances.push(min);
|
|
|
|
await this.deployer.deployPackage(min, 'packages/default.gbtheme');
|
|
|
|
// Install per bot deployed packages.
|
|
|
|
let packagePath = `work/${min.botId}.gbai/${min.botId}.gbdialog`;
|
|
if (fs.existsSync(packagePath)) {
|
|
await this.deployer.deployPackage(min, packagePath);
|
|
}
|
|
packagePath = `work/${min.botId}.gbai/${min.botId}.gbapp`;
|
|
if (fs.existsSync(packagePath)) {
|
|
await this.deployer.deployPackage(min, packagePath);
|
|
}
|
|
packagePath = `work/${min.botId}.gbai/${min.botId}.gbtheme`;
|
|
if (fs.existsSync(packagePath)) {
|
|
await this.deployer.deployPackage(min, packagePath);
|
|
}
|
|
packagePath = `work/${min.botId}.gbai/${min.botId}.gblib`;
|
|
if (fs.existsSync(packagePath)) {
|
|
await this.deployer.deployPackage(min, packagePath);
|
|
}
|
|
|
|
// Calls the loadBot context.activity for all packages.
|
|
|
|
await this.invokeLoadBot(GBServer.globals.appPackages, GBServer.globals.sysPackages, min);
|
|
|
|
// Serves individual URL for each bot conversational interface...
|
|
|
|
const url = `/api/messages/${instance.botId}`;
|
|
GBServer.globals.server.post(url, async (req, res) => {
|
|
await this.receiver(adapter, req, res, conversationState, min, instance, GBServer.globals.appPackages);
|
|
});
|
|
GBLog.info(`GeneralBots(${instance.engineName}) listening on: ${url}.`);
|
|
|
|
// Serves individual URL for each bot user interface.
|
|
|
|
if (process.env.DISABLE_WEB !== 'true') {
|
|
const uiUrl = `/${instance.botId}`;
|
|
const uiUrlAlt = `/${instance.activationCode}`;
|
|
GBServer.globals.server.use(
|
|
uiUrl,
|
|
express.static(urlJoin(GBDeployer.deployFolder, GBMinService.uiPackage, 'build'))
|
|
);
|
|
GBServer.globals.server.use(
|
|
uiUrlAlt,
|
|
express.static(urlJoin(GBDeployer.deployFolder, GBMinService.uiPackage, 'build'))
|
|
);
|
|
|
|
GBLog.info(`Bot UI ${GBMinService.uiPackage} accessible at: ${uiUrl} and ${uiUrlAlt}.`);
|
|
}
|
|
|
|
// Clients get redirected here in order to create an OAuth authorize url and redirect them to AAD.
|
|
// There they will authenticate and give their consent to allow this app access to
|
|
// some resource they own.
|
|
|
|
this.handleOAuthRequests(GBServer.globals.server, min);
|
|
|
|
// After consent is granted AAD redirects here. The ADAL library
|
|
// is invoked via the AuthenticationContext and retrieves an
|
|
// access token that can be used to access the user owned resource.
|
|
|
|
this.handleOAuthTokenRequests(GBServer.globals.server, min, instance);
|
|
|
|
// Provides checking of instance health.
|
|
|
|
this.createCheckHealthAddress(GBServer.globals.server, min, min.instance);
|
|
}
|
|
|
|
private async WhatsAppCallback(req, res) {
|
|
try {
|
|
|
|
// Detects if the message is echo fro itself.
|
|
|
|
const id = req.body.messages[0].chatId.split('@')[0];
|
|
const senderName = req.body.messages[0].senderName;
|
|
const text = req.body.messages[0].body;
|
|
if (req.body.messages[0].fromMe) {
|
|
res.end();
|
|
|
|
return; // Exit here.
|
|
}
|
|
|
|
// Detects if the welcome message is enabled.
|
|
|
|
let activeMin;
|
|
if (process.env.WHATSAPP_WELCOME_DISABLED !== 'true') {
|
|
|
|
// Tries to find if user wants to switch bots.
|
|
|
|
let toSwitchMin = GBServer.globals.minInstances.filter(
|
|
p => p.instance.botId.toLowerCase() === text.toLowerCase()
|
|
)[0];
|
|
if (!toSwitchMin) {
|
|
toSwitchMin = GBServer.globals.minInstances.filter(p =>
|
|
p.instance.activationCode ? p.instance.activationCode.toLowerCase() === text.toLowerCase() : false
|
|
)[0];
|
|
}
|
|
|
|
// Find active bot instance.
|
|
|
|
activeMin = toSwitchMin ? toSwitchMin : GBServer.globals.minBoot;
|
|
|
|
// If it is the first time for the user, tries to auto-execute
|
|
// start dialog if any is specified in Config.xlsx.
|
|
|
|
const sec = new SecService();
|
|
let user = await sec.getUserFromSystemId(id);
|
|
if (user === null || user.hearOnDialog) {
|
|
user = await sec.ensureUser(activeMin.instance.instanceId, id, senderName, '', 'whatsapp', senderName);
|
|
|
|
const startDialog = user.hearOnDialog ?
|
|
user.hearOnDialog :
|
|
activeMin.core.getParam(activeMin.instance, 'Start Dialog', null);
|
|
|
|
GBLog.info(`Auto start dialog is now being called: ${startDialog}...`);
|
|
if (startDialog) {
|
|
req.body.messages[0].body = `${startDialog}`;
|
|
|
|
// Resets HEAR ON DIALOG value to none and passes
|
|
// current dialog to the direct line.
|
|
|
|
await sec.updateUserHearOnDialog(user.userId, null);
|
|
await (activeMin as any).whatsAppDirectLine.received(req, res);
|
|
} else {
|
|
await (activeMin as any).whatsAppDirectLine.sendToDevice(
|
|
id,
|
|
`Olá! Seja bem-vinda(o)!\nMe chamo ${activeMin.instance.title}. Como posso ajudar? Pode me falar que eu te ouço, me manda um aúdio.`
|
|
);
|
|
res.end();
|
|
}
|
|
} else {
|
|
|
|
// User wants to switch bots.
|
|
|
|
if (toSwitchMin !== undefined) {
|
|
|
|
// So gets the new bot instance information and prepares to
|
|
// auto start dialog if any is specified.
|
|
|
|
const instance = await this.core.loadInstanceByBotId(activeMin.botId);
|
|
await sec.updateUserInstance(id, instance.instanceId);
|
|
await (activeMin as any).whatsAppDirectLine.resetConversationId(id);
|
|
const startDialog = activeMin.core.getParam(activeMin.instance, 'Start Dialog', null);
|
|
GBLog.info(`Auto start dialog is now being called: ${startDialog}...`);
|
|
|
|
if (startDialog) {
|
|
req.body.messages[0].body = `${startDialog}`;
|
|
await (activeMin as any).whatsAppDirectLine.received(req, res);
|
|
} else {
|
|
await (activeMin as any).whatsAppDirectLine.sendToDevice(
|
|
id,
|
|
`Agora falando com ${activeMin.instance.title}...`
|
|
);
|
|
res.end();
|
|
}
|
|
} else {
|
|
activeMin = GBServer.globals.minInstances.filter(p => p.instance.instanceId === user.instanceId)[0];
|
|
if (activeMin === undefined) {
|
|
activeMin = GBServer.globals.minBoot;
|
|
await (activeMin as any).whatsAppDirectLine.sendToDevice(
|
|
id,
|
|
`O outro Bot que você estava falando(${user.instanceId}), não está mais disponível. Agora você está falando comigo, ${activeMin.instance.title}...`
|
|
);
|
|
}
|
|
await (activeMin as any).whatsAppDirectLine.received(req, res);
|
|
}
|
|
}
|
|
} else {
|
|
|
|
// Just pass the message to the receiver.
|
|
|
|
await (GBServer.globals.minBoot as any).whatsAppDirectLine.received(req, res);
|
|
}
|
|
} catch (error) {
|
|
GBLog.error(`Error on Whatsapp callback: ${error.data ? error.data : error}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Creates a listener that can be used by external monitors to check
|
|
* bot instance health.
|
|
*/
|
|
private createCheckHealthAddress(server: any, min: GBMinInstance, instance: IGBInstance) {
|
|
server.get(`/${min.instance.botId}/check`, async (req, res) => {
|
|
try {
|
|
|
|
// Performs the checking of WhatsApp API if enabled for this instance.
|
|
|
|
if (min.whatsAppDirectLine != undefined && instance.whatsappServiceKey !== null) {
|
|
if (!(await min.whatsAppDirectLine.check(min))) {
|
|
const error = `WhatsApp API lost connection.`;
|
|
GBLog.error(error);
|
|
res.status(500).send(error);
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// GB is OK, so 200.
|
|
|
|
res.status(200).send(`General Bot ${min.botId} is healthly.`);
|
|
|
|
} catch (error) {
|
|
|
|
// GB is not OK, 500 and detail the information on response content.
|
|
|
|
GBLog.error(error);
|
|
res.status(500).send(error.toString());
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Handle OAuth2 web service calls for token requests
|
|
* on https://<gbhost>/<BotId>/token URL.
|
|
*/
|
|
private handleOAuthTokenRequests(server: any, min: GBMinInstance, instance: IGBInstance) {
|
|
|
|
server.get(`/${min.instance.botId}/token`, async (req, res) => {
|
|
|
|
// Checks request state by reading AntiCSRFAttackState from GB Admin infrastructure.
|
|
|
|
const state = await min.adminService.getValue(instance.instanceId, 'AntiCSRFAttackState');
|
|
if (req.query.state !== state) {
|
|
const msg = 'WARNING: state field was not provided as anti-CSRF token';
|
|
GBLog.error(msg);
|
|
throw new Error(msg);
|
|
}
|
|
const authenticationContext = new AuthenticationContext(
|
|
urlJoin(min.instance.authenticatorAuthorityHostUrl, min.instance.authenticatorTenant)
|
|
);
|
|
const resource = 'https://graph.microsoft.com';
|
|
|
|
// Calls MSFT to get token.
|
|
|
|
authenticationContext.acquireTokenWithAuthorizationCode(
|
|
req.query.code,
|
|
urlJoin(instance.botEndpoint, min.instance.botId, '/token'),
|
|
resource,
|
|
instance.marketplaceId,
|
|
instance.marketplacePassword,
|
|
async (err, token) => {
|
|
if (err) {
|
|
const msg = `Error acquiring token: ${err}`;
|
|
GBLog.error(msg);
|
|
res.send(msg);
|
|
} else {
|
|
|
|
// Saves token to the database.
|
|
|
|
await this.adminService.setValue(instance.instanceId, 'accessToken', token.accessToken);
|
|
await this.adminService.setValue(instance.instanceId, 'refreshToken', token.refreshToken);
|
|
await this.adminService.setValue(instance.instanceId, 'expiresOn', token.expiresOn.toString());
|
|
await this.adminService.setValue(instance.instanceId, 'AntiCSRFAttackState', undefined);
|
|
|
|
// Inform the home for default .gbui after finishing token retrival.
|
|
|
|
res.redirect(min.instance.botEndpoint);
|
|
}
|
|
}
|
|
);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Handle OAuth2 web service calls for authorization requests
|
|
* on https://<gbhost>/<BotId>/auth URL.
|
|
*/
|
|
private handleOAuthRequests(server: any, min: GBMinInstance) {
|
|
server.get(`/${min.instance.botId}/auth`, (req, res) => {
|
|
let authorizationUrl = urlJoin(
|
|
min.instance.authenticatorAuthorityHostUrl,
|
|
min.instance.authenticatorTenant,
|
|
'/oauth2/authorize'
|
|
);
|
|
authorizationUrl = `${authorizationUrl}?response_type=code&client_id=${min.instance.marketplaceId
|
|
}&redirect_uri=${urlJoin(min.instance.botEndpoint, min.instance.botId, 'token')}`;
|
|
res.redirect(authorizationUrl);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Returns the instance object to clients requesting bot info.
|
|
*/
|
|
private async handleGetInstanceForClient(req: any, res: any) {
|
|
|
|
// Translates the requested botId.
|
|
|
|
let id = req.params.botId;
|
|
if (id === '[default]' || id === undefined) {
|
|
id = GBConfigService.get('BOT_ID');
|
|
}
|
|
|
|
// Loads by the botId itself or by the activationCode field.
|
|
|
|
let instance = await this.core.loadInstanceByBotId(id);
|
|
if (instance === null) {
|
|
instance = await this.core.loadInstanceByActivationCode(id);
|
|
}
|
|
|
|
if (instance !== null) {
|
|
|
|
// Gets the webchat token, speech token and theme.
|
|
|
|
const webchatTokenContainer = await this.getWebchatToken(instance);
|
|
const speechToken = instance.speechKey != undefined ? await this.getSTSToken(instance) : null;
|
|
let theme = instance.theme;
|
|
|
|
// Sends all information to the .gbui web client.
|
|
|
|
if (theme === undefined) {
|
|
theme = 'default.gbtheme';
|
|
}
|
|
res.send(
|
|
JSON.stringify({
|
|
instanceId: instance.instanceId,
|
|
botId: id,
|
|
theme: theme,
|
|
webchatToken: webchatTokenContainer.token,
|
|
speechToken: speechToken,
|
|
conversationId: webchatTokenContainer.conversationId,
|
|
authenticatorTenant: instance.authenticatorTenant,
|
|
authenticatorClientId: instance.marketplaceId
|
|
})
|
|
);
|
|
} else {
|
|
const error = `Instance not found while retrieving from .gbui web client: ${id}.`;
|
|
res.sendStatus(error);
|
|
GBLog.error(error);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets Webchat token from Bot Service.
|
|
*/
|
|
private async getWebchatToken(instance: any) {
|
|
const options = {
|
|
url: 'https://directline.botframework.com/v3/directline/tokens/generate',
|
|
method: 'POST',
|
|
headers: {
|
|
Authorization: `Bearer ${instance.webchatKey}`
|
|
}
|
|
};
|
|
|
|
try {
|
|
const json = await request(options);
|
|
|
|
return JSON.parse(json);
|
|
} catch (error) {
|
|
const msg = `[botId:${instance.botId}] Error calling Direct Line to generate a token for Web control: ${error}.`;
|
|
|
|
return Promise.reject(new Error(msg));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Gets a Speech to Text / Text to Speech token from the provider.
|
|
*/
|
|
private async getSTSToken(instance: any) {
|
|
const options = {
|
|
url: instance.speechEndpoint,
|
|
method: 'POST',
|
|
headers: {
|
|
'Ocp-Apim-Subscription-Key': instance.speechKey
|
|
}
|
|
};
|
|
|
|
try {
|
|
return await request(options);
|
|
} catch (error) {
|
|
const msg = `Error calling Speech to Text client. Error is: ${error}.`;
|
|
|
|
return Promise.reject(new Error(msg));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Builds the BOT Framework & GB infrastructures.
|
|
*/
|
|
private async buildBotAdapter(instance: any, sysPackages: IGBPackage[], appPackages: IGBPackage[]) {
|
|
|
|
// MSFT stuff.
|
|
|
|
const adapter = new BotFrameworkAdapter(
|
|
{ appId: instance.marketplaceId, appPassword: instance.marketplacePassword });
|
|
const storage = new MemoryStorage();
|
|
const conversationState = new ConversationState(storage);
|
|
const userState = new UserState(storage);
|
|
adapter.use(new AutoSaveStateMiddleware(conversationState, userState));
|
|
MicrosoftAppCredentials.trustServiceUrl('https://directline.botframework.com',
|
|
new Date(new Date().setFullYear(new Date().getFullYear() + 10))
|
|
);
|
|
|
|
// The minimal bot is built here.
|
|
|
|
const min = new GBMinInstance();
|
|
min.botId = instance.botId;
|
|
min.bot = adapter;
|
|
min.userState = userState;
|
|
min.core = this.core;
|
|
min.conversationalService = this.conversationalService;
|
|
min.adminService = this.adminService;
|
|
min.deployService = this.deployer;
|
|
min.kbService = new KBService(this.core.sequelize);
|
|
min.instance = instance;
|
|
min.cbMap = {};
|
|
min.scriptMap = {};
|
|
min.sandBoxMap = {};
|
|
min.packages = sysPackages;
|
|
min.appPackages = appPackages;
|
|
if (GBServer.globals.minBoot === undefined) {
|
|
GBServer.globals.minBoot = min;
|
|
}
|
|
// TODO: min.appPackages = core.getPackagesByInstanceId(min.instance.instanceId);
|
|
|
|
// Creates a hub of services available in .gbapps.
|
|
|
|
await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => {
|
|
let services: ConcatArray<never>;
|
|
if ((services = await e.onExchangeData(min, 'getServices', null))) {
|
|
min.gbappServices = {...min.gbappServices, ...services};
|
|
}
|
|
});
|
|
|
|
// If there is WhatsApp configuration specified, initialize
|
|
// infrastructure objects.
|
|
|
|
if (min.instance.whatsappServiceKey !== null) {
|
|
min.whatsAppDirectLine = new WhatsappDirectLine(
|
|
min,
|
|
min.botId,
|
|
min.instance.whatsappBotKey,
|
|
min.instance.whatsappServiceKey,
|
|
min.instance.whatsappServiceNumber,
|
|
min.instance.whatsappServiceUrl
|
|
);
|
|
await min.whatsAppDirectLine.setup(true);
|
|
} else {
|
|
const minBoot = GBServer.globals.minBoot as any;
|
|
if (minBoot.instance.whatsappServiceKey) {
|
|
min.whatsAppDirectLine = new WhatsappDirectLine(
|
|
min,
|
|
min.botId,
|
|
min.instance.whatsappBotKey,
|
|
minBoot.instance.whatsappServiceKey,
|
|
minBoot.instance.whatsappServiceNumber,
|
|
minBoot.instance.whatsappServiceUrl
|
|
);
|
|
await min.whatsAppDirectLine.setup(false);
|
|
}
|
|
}
|
|
|
|
// Setups default BOT Framework dialogs.
|
|
|
|
min.userProfile = conversationState.createProperty('userProfile');
|
|
const dialogState = conversationState.createProperty('dialogState');
|
|
|
|
min.dialogs = new DialogSet(dialogState);
|
|
min.dialogs.add(new TextPrompt('textPrompt'));
|
|
min.dialogs.add(new ConfirmPrompt('confirmPrompt'));
|
|
min.dialogs.add(
|
|
new OAuthPrompt('oAuthPrompt', {
|
|
connectionName: 'OAuth2',
|
|
text: 'Please sign in.',
|
|
title: 'Sign in',
|
|
timeout: 300000
|
|
})
|
|
);
|
|
|
|
return { min, adapter, conversationState };
|
|
}
|
|
|
|
/**
|
|
* Performs calling of loadBot event in all .gbapps.
|
|
*/
|
|
private async invokeLoadBot(appPackages: IGBPackage[], sysPackages: IGBPackage[], min: GBMinInstance) {
|
|
|
|
// Calls loadBot event in all .gbapp packages.
|
|
|
|
await CollectionUtil.asyncForEach(sysPackages, async p => {
|
|
p.sysPackages = sysPackages;
|
|
if (p.getDialogs !== undefined) {
|
|
const dialogs = await p.getDialogs(min);
|
|
if (dialogs !== undefined) {
|
|
dialogs.forEach(dialog => {
|
|
min.dialogs.add(new WaterfallDialog(dialog.id, dialog.waterfall));
|
|
});
|
|
}
|
|
}
|
|
|
|
await p.loadBot(min);
|
|
});
|
|
|
|
// Adds all dialogs from .gbapps into global dialo list for this minimal instance.
|
|
|
|
await CollectionUtil.asyncForEach(appPackages, async p => {
|
|
p.sysPackages = sysPackages;
|
|
await p.loadBot(min);
|
|
if (p.getDialogs !== undefined) {
|
|
const dialogs = await p.getDialogs(min);
|
|
if (dialogs !== undefined) {
|
|
dialogs.forEach(dialog => {
|
|
min.dialogs.add(new WaterfallDialog(dialog.id, dialog.waterfall));
|
|
});
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* BOT Framework web service hook method.
|
|
*/
|
|
private async receiver(
|
|
adapter: BotFrameworkAdapter,
|
|
req: any,
|
|
res: any,
|
|
conversationState: ConversationState,
|
|
min: GBMinInstance,
|
|
instance: any,
|
|
appPackages: any[]
|
|
) {
|
|
|
|
// Default activity processing and handler.
|
|
|
|
await adapter.processActivity(req, res, async context => {
|
|
|
|
// Get loaded user state
|
|
|
|
const step = await min.dialogs.createContext(context);
|
|
step.context.activity.locale = 'pt-BR';
|
|
let firstTime = false;
|
|
|
|
try {
|
|
const user = await min.userProfile.get(context, {});
|
|
|
|
// First time processing.
|
|
|
|
const sec = new SecService();
|
|
if (!user.loaded) {
|
|
user.loaded = true;
|
|
user.subjects = [];
|
|
user.cb = undefined;
|
|
user.welcomed = false;
|
|
firstTime = true;
|
|
|
|
// Sends loadInstance event to .gbui clients.
|
|
|
|
await min.conversationalService.sendEvent(min, step, 'loadInstance', {
|
|
instanceId: instance.instanceId,
|
|
botId: instance.botId,
|
|
theme: instance.theme ? instance.theme : 'default.gbtheme',
|
|
secret: instance.webchatKey
|
|
});
|
|
|
|
// This same event is dispatched either to all participants
|
|
// including the bot, that is filtered bellow.
|
|
|
|
if (context.activity.from.id !== min.botId) {
|
|
|
|
// Creates a new row in user table if it does not exists.
|
|
|
|
const member = context.activity.from;
|
|
const persistedUser = await sec.ensureUser(
|
|
instance.instanceId,
|
|
member.id,
|
|
member.name,
|
|
'',
|
|
'web',
|
|
member.name
|
|
);
|
|
|
|
// Required for MSTEAMS handling of persisted conversations.
|
|
|
|
if (step.context.activity.channelId === 'msteams') {
|
|
persistedUser.conversationReference = JSON.stringify(
|
|
TurnContext.getConversationReference(context.activity)
|
|
);
|
|
await persistedUser.save();
|
|
}
|
|
|
|
// Stores conversation associated to the user to group each message.
|
|
|
|
const analytics = new AnalyticsService();
|
|
user.systemUser = persistedUser;
|
|
user.conversation = await analytics.createConversation(persistedUser);
|
|
|
|
}
|
|
|
|
// Saves session user (persisted GuaribasUser is inside).
|
|
|
|
await min.userProfile.set(step.context, user);
|
|
}
|
|
|
|
GBLog.info(`User>: text:${context.activity.text} (type: ${context.activity.type}, name: ${context.activity.name}, channelId: ${context.activity.channelId}, value: ${context.activity.value})`);
|
|
|
|
// Answer to specific BOT Framework event conversationUpdate to auto start dialogs.
|
|
|
|
if (context.activity.type === 'conversationUpdate' && context.activity.membersAdded.length > 0) {
|
|
|
|
// Check if a bot or a human participant is being added to the conversation.
|
|
|
|
const member = context.activity.membersAdded[0];
|
|
if (context.activity.membersAdded[0].id === context.activity.recipient.id) {
|
|
GBLog.info(`Bot added to conversation, starting chat...`);
|
|
|
|
// Calls onNewSession event on each .gbapp package.
|
|
|
|
await CollectionUtil.asyncForEach(appPackages, async e => {
|
|
await e.onNewSession(min, step);
|
|
});
|
|
|
|
// Auto starts dialogs if any is specified.
|
|
|
|
const startDialog = min.core.getParam(min.instance, 'Start Dialog', null);
|
|
if (startDialog && !user.welcomed) {
|
|
user.welcomed = true;
|
|
GBLog.info(`Auto start dialog is now being called: ${startDialog}...`);
|
|
await GBVMService.callVM(startDialog.toLowerCase(), min, step, this.deployer);
|
|
} else {
|
|
|
|
// Otherwise, calls / (root) to default welcome users.
|
|
|
|
await step.beginDialog('/');
|
|
}
|
|
|
|
} else {
|
|
|
|
GBLog.info(`Member added to conversation: ${member.name}`);
|
|
}
|
|
|
|
} else if (context.activity.type === 'message') {
|
|
|
|
// Process messages activities.
|
|
|
|
await this.processMessageActivity(context, min, step);
|
|
|
|
} else if (context.activity.type === 'event') {
|
|
|
|
// Processes events activies.
|
|
|
|
await this.processEventActivity(context, step);
|
|
}
|
|
|
|
// Saves conversation state for later use.
|
|
|
|
await conversationState.saveChanges(context, true);
|
|
|
|
} catch (error) {
|
|
|
|
const msg = `ERROR: ${error.message} ${error.stack ? error.stack : ''}`;
|
|
GBLog.error(msg);
|
|
|
|
await min.conversationalService.sendText(
|
|
min,
|
|
step,
|
|
Messages[step.context.activity.locale].very_sorry_about_error
|
|
);
|
|
|
|
await step.beginDialog('/ask', { isReturning: true });
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Called to handle all event sent by .gbui clients.
|
|
*/
|
|
private async processEventActivity(context, step: GBDialogStep) {
|
|
|
|
if (context.activity.name === 'whoAmI') {
|
|
await step.beginDialog('/whoAmI');
|
|
} else if (context.activity.name === 'showSubjects') {
|
|
await step.beginDialog('/menu', undefined);
|
|
} else if (context.activity.name === 'giveFeedback') {
|
|
await step.beginDialog('/feedback', {
|
|
fromMenu: true
|
|
});
|
|
} else if (context.activity.name === 'showFAQ') {
|
|
await step.beginDialog('/faq');
|
|
} else if (context.activity.name === 'answerEvent') {
|
|
await step.beginDialog('/answerEvent', <AskDialogArgs>{
|
|
questionId: context.activity.data,
|
|
fromFaq: true
|
|
});
|
|
} else if (context.activity.name === 'quality') {
|
|
await step.beginDialog('/quality', {
|
|
score: context.activity.data
|
|
});
|
|
} else if (context.activity.name === 'updateToken') {
|
|
const token = context.activity.data;
|
|
await step.beginDialog('/adminUpdateToken', { token: token });
|
|
} else {
|
|
await step.continueDialog();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called to handle all text messages sent and received by the bot.
|
|
*/
|
|
private async processMessageActivity(context, min: GBMinInstance, step: GBDialogStep) {
|
|
|
|
// Removes <at>Bot Id</at> from MS Teams.
|
|
|
|
context.activity.text = context.activity.text.trim();
|
|
context.activity.text = context.activity.text.replace(/\<at\>.*\<\/at\>\s/gi, '');
|
|
|
|
const user = await min.userProfile.get(context, {});
|
|
let message: GuaribasConversationMessage;
|
|
if (process.env.PRIVACY_STORE_MESSAGES === 'true') {
|
|
|
|
// Adds message to the analytics layer.
|
|
|
|
const analytics = new AnalyticsService();
|
|
if (user) {
|
|
|
|
if (!user.conversation) {
|
|
user.conversation = await analytics.createConversation(user.systemUser);
|
|
}
|
|
|
|
message = await analytics.createMessage(
|
|
min.instance.instanceId,
|
|
user.conversation,
|
|
user.systemUser.userId,
|
|
context.activity.text
|
|
);
|
|
}
|
|
}
|
|
|
|
// Checks for global exit kewywords cancelling any active dialogs.
|
|
|
|
const globalQuit = (locale, utterance) => {
|
|
return utterance.match(Messages.global_quit);
|
|
};
|
|
|
|
// Files in .gbdialog can be called directly by typing its name normalized into JS .
|
|
|
|
const isVMCall = Object.keys(min.scriptMap).find(key => min.scriptMap[key] === context.activity.text) !== undefined;
|
|
if (isVMCall) {
|
|
await GBVMService.callVM(context.activity.text, min, step, this.deployer);
|
|
} else if (context.activity.text.charAt(0) === '/') {
|
|
|
|
const text = context.activity.text;
|
|
const parts = text.split(' ');
|
|
const cmdOrDialogName = parts[0];
|
|
parts.splice(0, 1);
|
|
const args = parts.join(' ');
|
|
|
|
if (cmdOrDialogName === '/call') {
|
|
await GBVMService.callVM(args, min, step, this.deployer);
|
|
} else {
|
|
await step.beginDialog(cmdOrDialogName, { args: args });
|
|
}
|
|
} else if (globalQuit(step.context.activity.locale, context.activity.text)) {
|
|
await step.cancelAllDialogs();
|
|
await min.conversationalService.sendText(min, step, Messages[step.context.activity.locale].canceled);
|
|
|
|
} else if (context.activity.text === 'admin') {
|
|
await step.beginDialog('/admin');
|
|
|
|
} else if (context.activity.text.startsWith('{"title"')) {
|
|
await step.beginDialog('/menu', JSON.parse(context.activity.text));
|
|
|
|
} else if (
|
|
!(await this.deployer.getStoragePackageByName(min.instance.instanceId, `${min.instance.botId}.gbkb`)) &&
|
|
process.env.GBKB_ENABLE_AUTO_PUBLISH === 'true'
|
|
) {
|
|
await min.conversationalService.sendText(min, step,
|
|
`Oi, ainda não possuo pacotes de conhecimento publicados. Por favor, aguarde alguns segundos enquanto eu auto-publico alguns pacotes.`
|
|
);
|
|
await step.beginDialog('/publish', { confirm: true, firstTime: true });
|
|
} else {
|
|
|
|
// Removes unwanted chars in input text.
|
|
|
|
let text = context.activity.text;
|
|
const originalText = text;
|
|
text = text.replace(/<([^>]+?)([^>]*?)>(.*?)<\/\1>/gi, '');
|
|
|
|
// Saves special words (keep text) in tokens to prevent it from
|
|
// spell checking and translation.
|
|
|
|
const keepText: string = min.core.getParam(min.instance, 'Keep Text', '');
|
|
let keepTextList = [];
|
|
if (keepTextList) {
|
|
keepTextList = keepTextList.concat(keepText.split(';'));
|
|
}
|
|
const replacements = [];
|
|
await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => {
|
|
const result = await e.onExchangeData(min, 'getKeepText', {});
|
|
if (result) {
|
|
keepTextList = keepTextList.concat(result);
|
|
}
|
|
});
|
|
let textProcessed = GBConversationalService.removeDiacritics(text);
|
|
if (keepTextList) {
|
|
keepTextList = keepTextList.filter(p => p.trim() !== '');
|
|
let i = 0;
|
|
await CollectionUtil.asyncForEach(keepTextList, item => {
|
|
const it = GBConversationalService.removeDiacritics(item);
|
|
|
|
if (textProcessed.toLowerCase().indexOf(it.toLowerCase()) != -1) {
|
|
const replacementToken = 'X' + GBAdminService.getNumberIdentifier().substr(0, 4);
|
|
replacements[i] = { text: item, replacementToken: replacementToken };
|
|
i++;
|
|
textProcessed = textProcessed.replace(new RegExp(`\\b${it.trim()}\\b`, 'gi'), `${replacementToken}`);
|
|
}
|
|
});
|
|
}
|
|
|
|
// Spells check the input text before translating,
|
|
// keeping fixed tokens as specified in Config.
|
|
|
|
text = await min.conversationalService.spellCheck(min, textProcessed);
|
|
|
|
// Detects user typed language and updates their locale profile if applies.
|
|
|
|
let locale = min.core.getParam<string>(min.instance, 'Default User Language',
|
|
GBConfigService.get('DEFAULT_USER_LANGUAGE')
|
|
);
|
|
const detectLanguage = min.core.getParam<boolean>(min.instance, 'Language Detector',
|
|
GBConfigService.getBoolean('LANGUAGE_DETECTOR')
|
|
) === 'true';
|
|
const systemUser = user.systemUser;
|
|
locale = systemUser.locale;
|
|
if (detectLanguage || !locale) {
|
|
locale = await min.conversationalService.getLanguage(min, text);
|
|
if (systemUser.locale != locale) {
|
|
const sec = new SecService();
|
|
user.systemUser = await sec.updateUserLocale(systemUser.userId, locale);
|
|
await min.userProfile.set(step.context, user);
|
|
}
|
|
}
|
|
|
|
// Checks for bad words on input text.
|
|
|
|
const hasBadWord = wash.check(locale, context.activity.text);
|
|
if (hasBadWord) {
|
|
return await step.beginDialog('/pleaseNoBadWords');
|
|
}
|
|
|
|
// Translates text into content language, keeping
|
|
// reserved tokens specified in Config.
|
|
|
|
const contentLocale = min.core.getParam<string>(
|
|
min.instance,
|
|
'Default Content Language',
|
|
GBConfigService.get('DEFAULT_CONTENT_LANGUAGE')
|
|
);
|
|
text = await min.conversationalService.translate(min, text, contentLocale);
|
|
GBLog.info(`Translated text (processMessageActivity): ${text}.`);
|
|
|
|
// Restores all token text back after spell checking and translation.
|
|
|
|
if (keepTextList) {
|
|
let i = 0;
|
|
await CollectionUtil.asyncForEach(replacements, item => {
|
|
i++;
|
|
text = text.replace(new RegExp(`${item.replacementToken}`, 'gi'), item.text);
|
|
});
|
|
}
|
|
context.activity.text = text;
|
|
context.activity.originalText = originalText;
|
|
GBLog.info(`Final text ready for NLP/Search/.gbapp: ${text}.`);
|
|
|
|
// If there is a dialog in course, continue to the next step.
|
|
|
|
if (step.activeDialog !== undefined) {
|
|
await step.continueDialog();
|
|
|
|
} else {
|
|
|
|
let nextDialog = null;
|
|
await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => {
|
|
nextDialog = await e.onExchangeData(min, 'handleAnswer', {
|
|
query: text,
|
|
step: step,
|
|
notTranslatedQuery: originalText,
|
|
message: message ? message['dataValues'] : null,
|
|
user: user ? user.dataValues : null
|
|
});
|
|
});
|
|
await step.beginDialog(nextDialog ? nextDialog : '/answer', {
|
|
query: text,
|
|
user: user ? user.dataValues : null,
|
|
message: message
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|