asksuite-core/util/DialogParsing.js

const _ = require('lodash');
const Mustache = require('mustache');
const moment = require('moment');

module.exports = class DialogParsing {
  constructor() {}

  static dateEncoded(date) {
    try {
      return encodeURIComponent(moment(date).format('DD/MM/YY'));
    } catch (e) {
      return date;
    }
  }

  static dateUSEncoded(date) {
    try {
      return encodeURIComponent(moment(date).format('MM/DD/YY'));
    } catch (e) {
      return date;
    }
  }

  static currDateEncoded() {
    return encodeURIComponent(moment().local().format('DD/MM/YY'));
  }

  static currDateUSEncoded() {
    return encodeURIComponent(moment().local().format('MM/DD/YY'));
  }

  static currHour24() {
    return moment().local().format('kk:mm');
  }

  static gid(groupId) {
    return groupId ? '#' + groupId : '';
  }

  static currHour12() {
    return moment().local().format('hh:mmA');
  }

  static getLeadName(session) {
    const name = _.get(session, 'user.name') || _.get(session, 'variables.lead_name');

    return name || '';
  }

  // get only first name
  static getLeadFirstName(session) {
    const name = this.getLeadName(session);
    const firstName = name.split(' ')[0];
    return firstName || '';
  }

  static resolveDialog(session, outerItem) {
    Mustache.templateCache = undefined;

    let item = _.omit(outerItem, 'children');

    const itemString = JSON.stringify(item);

    if (!itemString.includes('{{')) {
      return outerItem;
    }

    if (itemString.includes('#x2F;')) {
      item = JSON.parse(itemString.replace(///g, '/'));
    }

    let result = _.cloneDeep(item);
    session = _.cloneDeep(session);

    if (result) {
      if (
        result.iterator &&
        result.iterator.enabled &&
        result.iterator.itemName &&
        result.iterator.variableName
      ) {
        result = DialogParsing.resolveIterator(session, result);
      } else {
        result = DialogParsing.replaceVariablesDialog(session, result);
      }
    }

    // Clean up remaining mustache variables
    result = JSON.parse(Mustache.render(JSON.stringify(result), {}));

    result.children = outerItem.children;
    return result;
  }

  static replaceVariablesDialog(session, item) {
    let jsonString = null;

    const mustacheExtensions = {
      ArrivalDateEncoded: DialogParsing.dateEncoded(session.ArrivalDateString),
      DepartureDateEncoded: DialogParsing.dateEncoded(session.DepartureDateString),
      ArrivalDateUSEncoded: DialogParsing.dateUSEncoded(session.ArrivalDateString),
      DepartureDateUSEncoded: DialogParsing.dateUSEncoded(session.DepartureDateString),
      currDateEncoded: DialogParsing.currDateEncoded,
      currDateUSEncoded: DialogParsing.currDateUSEncoded,
      currHour24: DialogParsing.currHour24,
      currHour12: DialogParsing.currHour12,
      gid: DialogParsing.gid(session.groupId),
      leadName: DialogParsing.getLeadName(session),
      firstName: DialogParsing.getLeadFirstName(session),
      isWhatsApp: DialogParsing.isPlatform(session, 'whatsapp'),
      isFacebook: DialogParsing.isPlatform(session, 'facebook'),
      isChatWeb: DialogParsing.isPlatform(session, 'chat_web'),
      isGoogleBusinessMessages: DialogParsing.isPlatform(session, 'google_business_messages'),
      isInstagram: DialogParsing.isPlatform(session, 'instagram'),
      isCompanyOfficeHours: session.isCompanyOfficeHours,
    };
    const vars = Object.assign({}, mustacheExtensions, session);

    if (item) {
      // Types replacing
      if (_.includes(['form', 'form-view'], item.type)) {
        item.value = item.value.map((choice) => this.resolveIteratorFormItems(session, choice));
      }

      jsonString = JSON.stringify(item);
      jsonString = Mustache.render(jsonString, vars);
    }
    try {
      if (!jsonString) {
        throw new Error('Empty jsonString');
      }
      return JSON.parse(jsonString);
    } catch (e) {
      console.log(e);
      return item;
    }
  }

  static resolveIteratorFormItems(session, inputfield) {
    try {
      const field = _.cloneDeep(inputfield);
      if (
        field.type === 'choice' &&
        field.choices &&
        field.choices.length === 1 &&
        field.iterator &&
        field.iterator.enabled
      ) {
        const template = field.choices[0];
        field.choices = [];
        const iterateVariable = _.get(session, field.iterator.variableName, []);
        const itemVariable = field.iterator.itemName;
        if (iterateVariable && itemVariable) {
          if (iterateVariable.length) {
            for (const newContext of iterateVariable) {
              const one = _.cloneDeep(template);
              session[itemVariable] = newContext;
              const newOne = DialogParsing.replaceVariablesDialog(session, one);
              if (!newOne.value || !newOne.title) {
                // eslint-disable-next-line no-throw-literal
                throw "One or more variables didn't exist";
              }
              field.choices.push(newOne);
            }
            return field;
          }
        }
      }
    } catch (e) {
      console.error(session.companyId, "Couldn't parse form items");
    }
    return inputfield;
  }

  static resolveIterator(session, item) {
    try {
      const itemClone = _.cloneDeep(item);
      if (itemClone.value && itemClone.value.length === 1) {
        const iterateVariable = _.get(session, itemClone.iterator.variableName);
        const itemVariable = itemClone.iterator.itemName;
        if (iterateVariable && itemVariable) {
          const template = itemClone.value[0];
          itemClone.value = [];

          if (iterateVariable.length) {
            for (const newContext of iterateVariable) {
              const one = _.cloneDeep(template);
              session[itemVariable] = newContext;

              const newOne = DialogParsing.replaceVariablesDialog(session, one);
              itemClone.value.push(newOne);
            }
          } else {
            throw new Error('Returned array has empty data');
          }
        } else {
          throw new Error("Input variables don't exist");
        }

        return itemClone;
      }
      throw new Error("Item doesn't have value property or value is not unique");
    } catch (e) {
      console.log(e);
      item.value = []; // Prevent showing result
      if (item.iterator && item.iterator.onEmptyGoToDialog) {
        item.goToDialog = item.iterator.onEmptyGoToDialog;
      }
      return item;
    }
  }

  static isPlatform(session, platform) {
    // eslint-disable-next-line eqeqeq
    return session.source == platform;
  }
};