asksuite-core/asksuite.tree.manager.general.js

const promisesTranslateTree = {};
const _ = require('lodash');
const PromiseBlue = require('bluebird');

class AsksuiteTreeManagerGeneral {
  constructor({
    CompanyMap,
    TreeMap,
    IntentsMap,
    AsksuiteUtil,
    AsksuiteService,
    InitMap,
    getLanguages,
    translator,
    wait,
  }) {
    this.CompanyMap = CompanyMap;
    this.TreeMap = TreeMap;
    this.getLanguages = getLanguages;
    this.IntentsMap = IntentsMap;
    this.AsksuiteUtil = AsksuiteUtil;
    this.translator = translator;
    this.AsksuiteService = AsksuiteService;
    this.InitMap = InitMap;
    this.wait = wait;
  }

  getLanguagesByCompany(chatTreeId) {
    const company =
      this.CompanyMap.get(chatTreeId) || this.CompanyMap.get(chatTreeId.split('.')[1]);
    if (company && !_.isEmpty(company.languages)) {
      return company.languages;
    }

    const languages = [];

    let flag = null;
    let languageFlag = null;
    const regex = /https:\/\/lipis\.github\.io\/flag-icon-css\/flags\/4x3\/(\w+)\.svg/;

    if (company && company.languageFlags) {
      const addLanguage = (attrLanguageFlag, defaultFlag, prefixLanguage, defaultLanguage) => {
        if ((languageFlag = _.get(company.languageFlags, attrLanguageFlag, ''))) {
          flag = _.get(languageFlag.match(regex), '1', defaultFlag);
          languages.push(`${prefixLanguage}-${flag}`);
        } else {
          languages.push(defaultLanguage);
        }
      };

      addLanguage('pt_br', 'br', 'pt', 'pt-br');
      languages.push('en-us');
      addLanguage('es', 'es', 'es', 'es-es');
    } else {
      return ['pt-br', 'en-us', 'es-es'];
    }

    return languages;
  }

  resolveDefaultLanguage(languages, language) {
    if (languages.includes(language)) {
      return language;
    }

    return _.find(languages, l => l.substring(0, 2) === language.substring(0, 2)) || language;
  }

  resolveLanguage(paramLanguage, companyId) {
    let languages = this.getLanguages();
    companyId = companyId || '';
    const company = this.CompanyMap.get(companyId) || this.CompanyMap.get(companyId.split('.')[1]);
    if (company && !_.isEmpty(company.languages)) {
      languages = _.filter(languages, l => _.includes(company.languages, l.formatIso));
    }
    return this.AsksuiteUtil.resolveLanguage(paramLanguage, languages);
  }

  flushTreeMapKeys(keys) {
    const languages = this.getLanguages();
    if (keys && Array.isArray(keys)) {
      languages.forEach(({ formatIso }) => {
        keys.forEach(key => {
          const treeInstance = this.resolveTreeInstance(formatIso);
          if (treeInstance.has(key)) {
            treeInstance.delete(key);
          }
        });
      });
    }
  }

  resolveTreeInstance(language, companyId) {
    language = this.resolveLanguage(language, companyId);
    if (!this.TreeMap.has(language)) {
      this.TreeMap.set(language, new Map());
    }

    return this.TreeMap.get(language);
  }

  isTreeAlreadyRegistred(chatTreeId, paramLanguage) {
    const company =
      this.CompanyMap.get(chatTreeId) || this.CompanyMap.get(chatTreeId.split('.')[1]);
    if (!paramLanguage && company) {
      return this.resolveTreeInstance(company.defaultLanguage, chatTreeId).has(chatTreeId);
    }
    return this.resolveTreeInstance(paramLanguage, chatTreeId).has(chatTreeId);
  }

  async recursiveDialog(map, node) {
    if (node.children) {
      node.children.forEach(async item => {
        map.set(item.dialog, item);
        await this.recursiveDialog(map, item);
      });
    }
  }

  async initTreeMap(map, tree) {
    map.set(tree.json.dialog, tree.json);
    await this.recursiveDialog(map, tree.json);
  }

  initTreeByLanguage(language, languageFrom, tree, needTranslate, languages) {
    const treeInstance = this.resolveTreeInstance(language, tree.chatTreeId);

    return new Promise((resolve, reject) => {
      (async () => {
        if (needTranslate) {
          console.time(`${tree.chatTreeId}: ${languageFrom} -> ${language}`);
          tree = await this.translator
            .translate(tree, language, languageFrom, languages)
            .catch(reject);
          console.timeEnd(`${tree.chatTreeId}: ${languageFrom} -> ${language}`);
        }
        await this.initTreeMap(treeInstance, tree).catch(reject);

        resolve();
      })();
    });
  }

  async initTreesByCompanyIDIfNeeded(idsTrees, paramLanguage) {
    return Promise.all(
      _.map(idsTrees, async idTree => {
        const language = this.resolveLanguage(paramLanguage, idTree);
        if (!this.isTreeAlreadyRegistred(idTree, language)) {
          await this.initTreeByCompanyID(idTree, language);
        }
      }),
    );
  }

  async initTreeByCompanyID(idTree, paramLanguage) {
    const language = this.resolveLanguage(paramLanguage, idTree);
    let key = `${idTree}`;
    if (language) {
      key += `-${language}`;
    }
    if (!this.InitMap.get(idTree) && !(language && this.InitMap.get(key))) {
      this.InitMap.set(key, true);
      const tree = await this.AsksuiteService.findTreeByCompanyId(idTree);
      const result = await this.initTree(tree, language).catch(e => {
        return { error: true, e };
      });
      this.InitMap.delete(key);
      if (result && result.error) {
        throw result.e;
      }
    } else {
      await this.wait.until(function() {
        return !this.InitMap.get(idTree) && !(language && this.InitMap.get(key));
      });
    }
  }

  async initTree(tree, language) {
    if (promisesTranslateTree[tree.chatTreeId]) {
      return promisesTranslateTree[tree.chatTreeId]
        .catch(e => console.log('error initTree', e))
        .then(() => this.initTree(tree, language));
    }

    promisesTranslateTree[tree.chatTreeId] = new Promise(resolve => {
      (async () => {
        console.log('init initTree', tree.chatTreeId);
        this.IntentsMap.set(tree.chatTreeId, tree.intents);

        let languages = this.getLanguagesByCompany(tree.chatTreeId);
        const defaultLanguage = this.resolveDefaultLanguage(languages, tree.defaultLanguage);

        if (language) {
          const lang = this.resolveDefaultLanguage(languages, language);
          languages = _.filter(languages, l => l === lang);

          if (
            !this.isTreeAlreadyRegistred(tree.chatTreeId, defaultLanguage) &&
            !_.includes(languages, defaultLanguage)
          ) {
            languages.push(defaultLanguage);
          }
        }

        const allLanguages = this.getLanguages();

        try {
          await PromiseBlue.map(
            languages,
            lang => {
              return this.initTreeByLanguage(
                lang,
                defaultLanguage,
                tree,
                lang !== defaultLanguage,
                allLanguages,
              );
            },
            { concurrency: 1 },
          );
        } catch (e) {
          console.log('error on initTree', e);
        } finally {
          console.log('end  initTree', tree.chatTreeId);
          resolve();
          delete promisesTranslateTree[tree.chatTreeId];
        }
      })();
    });

    return promisesTranslateTree[tree.chatTreeId];
  }
}

module.exports = {
  AsksuiteTreeManagerGeneral,
};