asksuite-core/services/NLPClassifierAccessor.js

const request = require('request');
const AsksuiteProcessingNaturalUtils = require('../AsksuiteProcessingNaturalUtils');
const { ErrorHandlerService } = require('./ErrorHandlerService');
const Util = require('../util');
const QuoteDataAccessor = require('./QuoteDataAccessor');
const AWSLambdaCaller = require('./AWSLambdaCaller');
const RequestPreprocessor = require('../util/RequestPreprocessor');

const GROUP_QUOTATION = 'Cotacao_grupo';

class NLPClassifierAccessor {
  constructor(NLP_CLASSIFIER_LAYER_URL, nlpClassifierParameters) {
    this.NLP_CLASSIFIER_LAYER_URL = NLP_CLASSIFIER_LAYER_URL;
    this.supportedLanguages = ['pt', 'es', 'en'];
    this.utils = new AsksuiteProcessingNaturalUtils();
    this.shouldValidateGroupQuoteParameters = !!nlpClassifierParameters.shouldValidateGroupQuoteParameters;
    this.groupQuoteConfig = nlpClassifierParameters.groupQuoteConfig;
  }

  resolveText(request) {
    return new Promise(resolve => {
      const executor = async () => {
        let response = null;
        let dialog = null;
        let intentChange;
        let extractedData;
        try {
          response = await this.requestData(this.NLP_CLASSIFIER_LAYER_URL, {
            phrase: request.text,
            language: request.language.substring(0, 2),
            intentType: 'cotacao',
          });

          let intent = response.body.intent;

          if (!intent) {
            throw { message: response.statusMessage, code: response.statusCode };
          }

          if (Util.isQuote(intent)) {
            try {
              extractedData = await this.extractQuoteData(request);
              if (
                extractedData &&
                this.shouldValidateGroupQuoteParameters &&
                this.groupQuoteConfig &&
                this.groupQuoteConfig.enabled
              ) {
                if (this.validateGroupQuoteConfig(extractedData, this.groupQuoteConfig)) {
                  intentChange = { originalIntent: intent, ...this.groupQuoteConfig };
                  intent = GROUP_QUOTATION;
                }
              }
            } catch (err) {
              console.log('[NLPClassifierAccessor error] Trying extract Quote Data', err);
            }
          }

          dialog = this.utils.findDialogByIntent(request, intent);
          dialog.extractedData = extractedData;

          dialog.processingStep = {
            ...dialog.processingStep,
            text: request.text,
            language: request.language,
            resolver: 'NLP_CLASSIFIER',
            extraInfo: { ...response.body.trackingInfo, intentChange },
          };
        } catch (e) {
          const errorData = ErrorHandlerService.accessorErrorHandler(e);
          dialog = {
            processingStep: {
              fallbackReason: 'intent_not_found',
              intentFound: null,
              text: request.text,
              language: request.language,
              resolver: 'NLP_CLASSIFIER',
              errorData,
            },
          };
          console.log('[NLPClassifierAccessor error]', e);
        }
        resolve(dialog);
      };

      executor();
    });
  }

  validateGroupQuoteConfig(extractedData, groupQuoteConfig) {
    const { AmountAdults = 1, AmountChildren = 0, Rooms = 1 } = extractedData;
    const { reference, minimum } = groupQuoteConfig;
    let response = false;

    switch (reference) {
      case 'rooms':
        response = Rooms > minimum;
        break;
      case 'guests':
        response = AmountAdults + AmountChildren > minimum;
        break;
      case 'adults':
        response = AmountAdults > minimum;
        break;
    }
    return response;
  }

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

  isSupportedLanguage(language) {
    return this.supportedLanguages.some(
      supportedLanguage => supportedLanguage === language.substring(0, 2),
    );
  }

  async extractQuoteData(request) {
    request = await RequestPreprocessor.process(request);

    const awsLambdaCaller = new AWSLambdaCaller(request.config.CORE_LAMBDA_AWS);
    const quoteDataAccessor = new QuoteDataAccessor(awsLambdaCaller);

    return quoteDataAccessor.resolveText(request);
  }
}

module.exports = NLPClassifierAccessor;