shared.js

const fs = require("fs");
const url = require("url");
const axios = require("axios");
const moment = require("moment");
const strings = require("string");
const dataset = require("./dataset");
const sys = require("child_process");

const cct_api = 'http://cct.r-broker.ru/api/';
const cct_key = 'y8Bzq1C0vIwhcrl98emy04JauUlWd7glhvUo2TcWBSkdMYzrKS'
              + 'KhQNMuoU_NecQJVNLIgRA4eeDTX4QFDA6np1VI0ctrmYJkcIQK'
              + 'muMgCjKzqHVSzZ2-n_0vefeFZPCMZJz4NO8xgrPwQ1OWgn_ACt'
              + 'be9DWhSR-yi_-u2k2NcF3Heg193PSKvov9QPlShLtq_UzdQfmb'
              + 'C9uS1-bukZFdFyQ9M6mO8Qnlyzm95ouQPODwqieKjiXIFkXUIW';

const file_sender = '../../htdocs/uploadgd/up.php';

const api_hook_url = 'https://ai.r-broker.ru/api/api.php';
const api_hook_key = 'kd56h4jfhj54f62hjf6d8YgjL9';
const api_hook = api_hook_url + '?key=' + api_hook_key;

const tg_wa_hook_url = 'https://ai.r-broker.ru/demo-hooks/voice-bot.php'
const ai_hooks_opts = { auth: { username: 'web', password: 'web' } };
const answering_machine_hook = 'https://ai.r-broker.ru/demo-hooks/check-answering-machine.php';

const mobile_codes = dataset.mobile_codes();

async function cct_api_service (service, api_request) {
  let post_data = JSON.stringify(api_request);
  let headers = {
    "Language": "ru-RU",
    "Authorization": "Bearer " + cct_key,
    "Content-Type": "application/json; charset=utf-8"
  };
  let config = { headers: headers };
  let result = await axios.post(cct_api + service, post_data, config);
  let wrong_data = { status: 'error', result: 'axios crashed' };
  if (result.data === null) return wrong_data
  if (result.data === undefined) return wrong_data;
  return result.data;
}

module.exports = exports = {

  empty (value) {
    if (value === undefined) return true;
    if (value === null) return true;
    const str = strings(value);
    if (str == "") return true;
    if (str.trim() == "") return true;
    return false;
  },

  // Веб-хук для отправки сообщений через Telegram и WhatsApp
  async tg_wa_hook (web_hook_data, db_name) {
    if (!(this.empty(db_name))) web_hook_data.db_name = db_name;
    let post_data = new url.URLSearchParams(web_hook_data);
    let result = {};
    let wrong_data = { status: 'error', detail: 'axios crashed' };
    try {
      result = await axios.post(tg_wa_hook_url, post_data, ai_hooks_opts);
    } catch (err) {
      wrong_data.detail = JSON.stringify(err, undefined, 2);
      result.data = wrong_data;
    }
    if (this.empty(result.data)) return wrong_data
    return result.data;
  },

  // Веб-хук для передачи отчёта о разговоре на машину AI
  async ai_api_hook (action, web_hook_data) {
    let api_hook_action = api_hook + '&action=' + action;
    let post_data = new url.URLSearchParams(web_hook_data);
    let result = {};
    let wrong_data = { status: 'error', detail: 'axios crashed' };
    try {
      result = await axios.post(api_hook_action, post_data);
    } catch (err) {
      wrong_data.detail = JSON.stringify(err, undefined, 2);
      result.data = wrong_data;
    }
    if (this.empty(result.data)) return wrong_data
    return result.data;
  },

  get_part_of_the_day() {
    ts = Date.now();
    let date_ob = new Date(ts);
    hours = date_ob.getHours();
    if (hours < 4) return 'night';
    if (hours < 12) return 'morning';
    if (hours < 16) return 'day';
    if (hours < 24) return 'evening';
    return 'night';
  },

  dasha_format(abonent_phone) {
    let clean_phone = abonent_phone.replace( /[^\d]/g, '' );
    var size = clean_phone.length;
    if (size == 11) {
      prefix = clean_phone.substring(0, 1);
      if (prefix == 8) {
        return "7" + clean_phone.substring(1);
      }
      return clean_phone
    }
    if (size == 10) {
      return "7" + clean_phone;
    }
    return clean_phone;
  },

  human_format(abonent_phone) {
    let clean_phone = abonent_phone.replace( /[^\d]/g, '' );
    var size = clean_phone.length;
    var human_phone = "";
    if (size < 4) return clean_phone;
    if (size == 11) {
      prefix = clean_phone.substring(0, 1);
      if (prefix == 8) human_phone = prefix; else human_phone = "+" + prefix;
      human_phone = human_phone + " (" + clean_phone.substring(1, 4);
      human_phone = human_phone + ") " + clean_phone.substring(4, 7);
      human_phone = human_phone + "-" + clean_phone.substring(7, 9);
      human_phone = human_phone + "-" + clean_phone.substring(9, 11);
      return human_phone;
    }
    if (size == 10) {
      human_phone = "+7";
      human_phone = human_phone + " (" + clean_phone.substring(0, 3);
      human_phone = human_phone + ") " + clean_phone.substring(3, 6);
      human_phone = human_phone + "-" + clean_phone.substring(6, 8);
      human_phone = human_phone + "-" + clean_phone.substring(8, 10);
      return human_phone;
    }
    const cuts = [ 2, 2, 3, 3 ];
    const divs = [ "-", "-", ") ", "(" ];
    let phone = clean_phone;
    for (var i = 0; i < 4; i ++) {
      if (size > cuts[i]) {
        size -= cuts[i];
        part = phone.substring(size, size + cuts[i]);
        human_phone = divs[i] + part + human_phone;
        phone = phone.substring(0, size);
      } else {
        var div = "";
        if (divs[i] == "(") div = divs[i];
        return div + phone + human_phone;
      }
    }
    return "+" + phone + " " + human_phone;
  },

  last_four_digits(abonent_phone) {
    let clean_phone = abonent_phone.replace( /[^\d]/g, '' );
    var size = clean_phone.length;
    let last_four = "";
    if (size > 3) {
      last_four = clean_phone.substring(size - 2, size);
      size -= 2;
      return clean_phone.substring(size - 2, size) + "-" + last_four;
    }
    return clean_phone;
  },

  // Веб-хук для извлечения чисел из текста через Т.У.К.
  async cct_numbers_from_text (text, option) {
    const service = 'markers-data';
    request = {
      debug: false,
      input: "text",
      channel: "client",
      multipliers: option,
      distance: { "min": 0.166667, "mid": 0.166667, "max": 0.166667 },
      language: "russian",
      text: text,
      triggers: [
        { name: "numbers", markers: [ { type: "number" } ] }
      ]
    };

    const response = await cct_api_service(service, request);

    let result = "";
    if (response.status !== "success") return result;
    for (trigger of response.result) {
      if (trigger.state === "on") {
        if (trigger.name === "numbers") {
          for (i in trigger.details) {
            found = trigger.details[i];
            for (j in found) {
              element = found[j];
              result = result + " " + element.value;
            }
          }
        }
      }
    }
    result = result.replace( /^\s+/, '' );
    return result;
  },

  // Веб-хук для извлечения дат из текста через Т.У.К.
  async cct_dates_from_text (text, option) {
    const service = 'markers-data';
    request = {
      debug: false,
      input: "text",
      channel: "client",
      multipliers: option,
      distance: { "min": 0.166667, "mid": 0.166667, "max": 0.166667 },
      language: "russian",
      text: text,
      triggers: [
        { name: "dates", markers: [ { type: "date time" } ] }
      ]
    };

    const response = await cct_api_service(service, request);

    let result = "";
    if (response.status !== "success") return result;
    for (trigger of response.result) {
      if (trigger.state === "on") {
        if (trigger.name === "dates") {
          for (i in trigger.details) {
            found = trigger.details[i];
            for (j in found) {
              element = found[j];
              pattern = element.pattern??"";
              if ((pattern === "%date%") && (result === ""))
                result = element.value;
            }
          }
        }
      }
    }

    if (result === "") return result;
    moment.locale("ru");
    result = moment(result, "YYYY-MM-DD").format("DD.MM.YYYY");
    return result;
  },

  // Веб-хук для извлечения времени из текста через Т.У.К.
  async cct_times_from_text (text, option) {
    const service = 'markers-data';
    request = {
      debug: false,
      input: "text",
      channel: "client",
      multipliers: option,
      distance: { "min": 0.166667, "mid": 0.166667, "max": 0.166667 },
      language: "russian",
      text: text,
      triggers: [
        { name: "times", markers: [ { type: "date time" } ] }
      ]
    };

    const response = await cct_api_service(service, request);

    let result = "";
    if (response.status !== "success") return result;
    for (trigger of response.result) {
      if (trigger.state === "on") {
        if (trigger.name === "times") {
          for (i in trigger.details) {
            found = trigger.details[i];
            for (j in found) {
              element = found[j];
              pattern = element.pattern??"";
              if ((pattern === "%time%") && (result === ""))
                result = element.value;
            }
          }
        }
      }
    }

    if (result === "") return { full: "", date: "", time: "", text: "" };
    moment.locale("ru");
    const result_date = result.replace( /\s.+$/, '' );
    const result_time = result.replace( /^.+\s/, '' );
    const result_text = moment(result_date, "YYYY-MM-DD").format("D MMMM")
                      + ' в ' + result_time;
    return {
       full: result,
       date: moment(result_date, "YYYY-MM-DD").format("DD.MM.YYYY"),
       time: result_time,
       text: result_text
    };
  },

  renew_last_log_file(last_text_file) {
    let sysCommand = 'cat ' + last_text_file + ' >log.txt';
    sys.exec(sysCommand, (error, stdout, stderr) => {
      if (error) {
        console.error(`error: ${error.message}`);
      }
      if (stderr) {
        console.error(`stderr: ${stderr}`);
      }
      // console.log(`stdout:\n${stdout}`);
    });
  },

  send_to_google_disk(file_name, file_mime) {
 /*
  * Сохранение файлов с отчётами на Google Disk отключено,
  * так как просмотр и анализ этих файлов именно на Google
  * Disk более не актуален, у всех разработчиков есть к ним
  * доступ по FTP
  *
    const sender = sys.spawn('php', [ file_sender, file_name, file_mime ]);

    sender.on("close", (code) => {
      if (code != 0)
        console.log("send 'file_name' to google disk return code: " + code);
    });

    sender.on("error", (error) => {
      console.log("send to google disk error: \n" + JSON.stringify(error, undefined, 2));
    });

    sender.stderr.on("data", (data) => {
      console.log("send to google disk stderr: \n" + data);
    });

    sender.stdout.on("data", (data) => {
      console.log("send to google disk stdout: \n" + data);
    });
  */
  },

  is_mobile_code(abonent_phone) {
    let clean_phone = abonent_phone.replace( /[^\d]/g, '' );
    var size = clean_phone.length;
    let phone_code = "";

    if (size > 6) {
      phone_code = clean_phone.substring(1, 4);
      }
    return (mobile_codes.indexOf(phone_code)!=-1);
  },

  str_pad(num, size, pad) {
    let str = "" + num;
    let len = str.length;
    while (len < size) {
      str = pad + str;
      len ++;
    }
    return str;
  },

  pid_name() {
    return this.str_pad(process.pid, 5, "0");
  },

  make_unique_app(app_suffix) {

    let app_suffix_file = './threads/' + app_suffix + '/app.dashaapp'
    if (fs.existsSync(app_suffix_file)) return './threads/' + app_suffix;

    let proc = sys.spawnSync('cp', [ '-rfp', './app', './threads/' + app_suffix ]);

    let exit_code = proc.status;
    let exit_data = proc.stdout.toString();

    let check_error = proc.error;
    let look_stderr = proc.stderr.toString();

    if (check_error) {
      console.log('error: ' + JSON.stringify(check_error, undefined, 2));
      return './app';
    }
    if (look_stderr) {
      console.log('stderr: ' + look_stderr);
      return './app';
    }
    app_data = fs.readFileSync('app/app.dashaapp');
    app_info = JSON.parse(app_data);
    let app_name = app_info.name + '-' + app_suffix;
    app_info.name = app_name;
    fs.writeFileSync(app_suffix_file, JSON.stringify(app_info, undefined, 2));
    return './threads/' + app_suffix;
  },

  drop_unique_app(app_suffix) {

    let proc = sys.spawnSync('rm', [ '-rf', './threads/' + app_suffix ]);

    let exit_code = proc.status;
    let exit_data = proc.stdout.toString();

    let check_error = proc.error;
    let look_stderr = proc.stderr.toString();

    if (check_error) {
      console.log('error: ' + JSON.stringify(check_error, undefined, 2));
      return false;
    }
    if (look_stderr) {
      console.log('stderr: ' + look_stderr);
      return false;
    }
    return true;
  },

  get_conversation_info(app, conv) {
    app_data = fs.readFileSync('app/app.dashaapp');
    app_info = JSON.parse(app_data);
    let app_name = app_info.name;
    app_name_full = app.applicationName;
    app_id = app.applicationId;
    job_id = conv._jobId;
    return {
      app_name: app_name,
      app_name_full: app_name_full,
      app_id: app_id,
      job_id: job_id
    };
  },

  // Веб-хук для проверки реплик по подозрению на автоответчик
  async check_answered_machine(text) {
    let post_data = new url.URLSearchParams({ text: text });
    let wrong_data = { status: 'error', load: 0, weight: -1, details: [] };
    try
    {
      var result = await axios.post(answering_machine_hook, post_data, ai_hooks_opts);
    }
    catch (err)
    {
      wrong_data.details = JSON.stringify(err, undefined, 2);
      result.data = wrong_data;
    }
    if (this.empty(result.data)) return wrong_data
    return result.data;
  }

};