asksuite-core/services/SophiaAccessor.js

const request = require('request');
const FallbackResolver = require('../util/FallbackResolver');
const RequestPreprocessor = require('../util/RequestPreprocessor');
const { ErrorHandlerService } = require('./ErrorHandlerService');
const StringUtils = require('../util/StringUtils');
const IntentResolver = require('../util/IntentResolver');

const URLRegex =
  /^[(http(s)?):\/\/(www\.)?a-zA-Z0-9@:%._\+~#=]{2,256}\.[a-z]{2,6}\b([-a-zA-Z0-9@:%_\+.~#?&//=]*)$/gi;

class SophiaAccessor {
  constructor(baseUrl, enabled, corePayload) {
    this.baseUrl = baseUrl;
    this.enabled = !!enabled;
    this.corePayload = corePayload;
  }

  resolveText(request) {
    console.log('[SophiaAccessor.resolveText started]');
    return new Promise((resolve) => {
      const defaultIntent = FallbackResolver.fallbackWithDefaultIntent(request.intents) || {};

      if (!this.enabled) {
        console.warn('[SophiaAccessor disabled]');
        resolve(defaultIntent);
        return;
      }

      const executor = async () => {
        const cleanText = RequestPreprocessor.removeUtilityTexts(
          RequestPreprocessor.removeEmoji(request.text),
        ).trim();
        console.log('[SophiaAccessor cleanText]', cleanText);
        const companyId = this.parseCompanyId(request.originalCompanyId);
        const companyName = request.companyName;
        if (this.isNotUnderstandable(cleanText)) {
          defaultIntent.processingStep = {
            fallbackReason: 'text_not_understandable',
            intentFound: 'naoentendi',
            text: cleanText || '',
          };
          resolve(defaultIntent);
          return;
        }

        try {
          const payload = {
            message: request.text,
            companyId,
            language: request.language,
            threadId: request.conversationId,
            companies: [
              {
                companyId,
                companyName,
              },
            ],
            leadData: {
              name: request?.leadData?.name,
              phone: request?.leadData?.phone,
            },
            metadata: {
              ip: request?.ip,
              mobile: request?.mobile,
              parentCompanyId: request?.parentCompanyId,
              platform: request?.platform,
              botName: request?.botName,
              timeConfiguration: request?.timeConfiguration,
              processMessageAfterRedirect: request?.processMessageAfterRedirect,
            },
          };

          console.log('[SophiaAccessor payload]', payload);

          const result = await this.requestData(this.baseUrl, payload);
          const data = result.body;
          const inputLanguage = result.body.inputLanguage;
          const genericBotResponse = result.body.genericBotResponse || {};
          const actions = genericBotResponse.actions || [];
          const tags = genericBotResponse.tags || [];

          let responseTexts = result.body.response || [];
          if (!Array.isArray(responseTexts)) {
            responseTexts = [responseTexts];
          }

          let intent = genericBotResponse.intent || 'sophia';
          if (intent === 'cant_understand') {
            intent = 'naoentendi';
          }

          const generateDialog = this.generateDialog(
            intent,
            companyId,
            responseTexts,
            inputLanguage,
            actions,
            tags,
          );

          resolve({
            ...generateDialog,
            processingStep: {
              fallbackReason: null,
              intentFound: generateDialog.intent,
              extraInfo: result.body.usage || null,
              text: cleanText || '',
              answer: responseTexts,
              data,
            },
          });
        } catch (e) {
          console.error('[SophiaAccessor error]', e);
          const errorData = ErrorHandlerService.accessorErrorHandler(e);

          const { intent, dialog } =
            request.intents.find(IntentResolver.isIntentForNotUnderstandable) || defaultIntent;

          const generateDialog = this.generateDialog(
            intent,
            companyId,
            [],
            request.language,
            [
              {
                action: 'dialog',
                body: {
                  dialog,
                },
                metadata: {},
              },
            ],
            [],
          );

          resolve({
            ...generateDialog,
            processingStep: {
              intentFound: intent,
              text: cleanText || '',
              fallbackReason: 'request_error',
              errorData,
            },
          });
        }
      };

      executor().then();
    });
  }

  requestData(url, json) {
    return new Promise((resolve, reject) => {
      request.post(url, { json, timeout: 160 * 1000 }, (err, res) => {
        if (err) {
          reject(err);
        }
        resolve(res);
      });
    });
  }

  parseCompanyId(name) {
    let companyId = name;
    if (companyId.indexOf('.') > -1) {
      const splited = companyId.split('.');
      companyId = splited[splited.length - 1];
    }
    return companyId;
  }

  generateDialog(intent, companyId, responseTexts, inputLanguage, actions, tags) {
    return {
      intent,
      dialog: `${companyId}.sophia`,
      responseTexts,
      inputLanguage,
      actions,
      tags,
    };
  }

  textToKeyword(text = '') {
    return text
      .toLowerCase()
      .normalize('NFD')
      .replace(/[^a-z]/g, '');
  }

  isNotUnderstandable(cleanText) {
    return (
      !cleanText || // empty string
      StringUtils.hasOnlySpecialChars(cleanText) ||
      URLRegex.test(cleanText) // Only link
    );
  }
}

module.exports = SophiaAccessor;