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 currHour12() {
    return moment()
      .local()
      .format('hh:mmA');
  }

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

    const item = _.chain(outerItem)
      .omit('children')
      .cloneDeep()
      .value();

    const itemString = JSON.stringify(item);
    if (!itemString.includes('{{')) {
      return outerItem;
    }

    session = _.cloneDeep(session);

    let result = item;
    if (item) {
      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,
    };
    const vars = Object.assign({}, mustacheExtensions, session);

    if (item) {
      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) {
                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) {
              let one = _.cloneDeep(template);
              session[itemVariable] = newContext;

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

              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;
    }
  }
};