@tiledesk/tiledesk-voice-twilio-connector 0.1.28 → 0.2.0-rc3

package/tiledesk/TiledeskChannel.js

@@ -1,363 +0,0 @@
-const axios = require("axios").default;
-const jwt = require("jsonwebtoken");
-const { v4: uuidv4 } = require("uuid");
-const { promisify } = require('util');
-const fs = require('fs');
-
-/*UTILS*/
-const utils = require('./utils-message.js')
-const fileUtils = require('./fileUtils.js')
-const TYPE_MESSAGE = require('./constants').TYPE_MESSAGE
-const MESSAGE_TYPE_MINE = require('./constants').MESSAGE_TYPE_MINE
-const MESSAGE_TYPE_OTHERS = require('./constants').MESSAGE_TYPE_OTHERS
-const CHANNEL_NAME = require('./constants').CHANNEL_NAME
-
-const Redlock = require('redlock');
-const redisLock = require("redis-lock")
-
-
-const winston = require("../winston");
-
-class TiledeskChannel {
-
-
-  constructor(config) {
-    
-    if (!config) {
-      throw new Error("[TiledeskChannel] config is mandatory");
-    }
-    if (!config.API_URL) {
-      throw new Error("[TiledeskChannel] config.API_URL is mandatory");
-    }
-    if (!config.redis_client) {
-      throw new Error("[TiledeskChannel] config.redis_client is mandatory");
-    }
-      
-    this.log = false;
-    if (config.log) {
-      this.log = config.log;
-    }
-
-    this.API_URL = config.API_URL;
-    this.redis_client = config.redis_client
-    
-    
-    this.redlock = new Redlock([this.redis_client], {
-      // The expected clock drift; for more details see:
-      // http://redis.io/topics/distlock
-      driftFactor: 0.01, // multiplied by lock ttl to determine drift time
-
-      // The max number of times Redlock will attempt to lock a resource
-      // before erroring.
-      retryCount: 10,
-
-      // the time in ms between attempts
-      retryDelay: 1000, // time in ms
-
-    });
-    
-    this.redlock.on("error", (error) => {
-      // Ignore cases where a resource is explicitly marked as locked on a client.
-      console.log('ERRRRRR', error)
-    });
-    
-    this.lock = require("redis-lock")(this.redis_client);
-    
-
-    let _project_id = config.project_id
-    this.setProjectId = function(project_id) { _project_id = project_id; }
-    this.getProjectId = function() { return _project_id; }
-  }
-  
-  
-
-  async signIn(user_id, settings) {
-    // ani = calling phone number
-
-    winston.debug('[TiledeskChannel] sigIn settings', settings)
-    
-    let payload = {
-      _id: CHANNEL_NAME + '-' + user_id,
-      firstname: user_id,
-      lastname: "",
-      phone: user_id,
-      sub: "userexternal",
-      aud: "https://tiledesk.com/subscriptions/" + settings.subscriptionId,
-    };
-    let customToken = jwt.sign(payload, settings.secret);
-
-    return await axios({
-      url: this.API_URL + "/auth/signInWithCustomToken",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: "JWT " + customToken,
-      },
-      data: {},
-      method: "POST",
-    }).then( async (response) => {
-      if (!response.data) {
-        return null;
-      }
-      //response.data.token = await this.fixToken(response.data.token);
-      let token = await this.fixToken(response.data.token);
-
-      let data = {
-        token: token,
-        _id: response.data.user._id
-      };
-
-      return data       
-      
-    })
-    .catch((err) => {
-      winston.error("[TiledeskChannel] sign in error: ", err.response);
-      return null;
-    });
-  }
-  
-  async generateConversation(ani, callId){
-    return "support-group-" + this.getProjectId() + "-" + ani + "-" + CHANNEL_NAME + "-" + callId;
-  }
-
-  async getConversation(ani, callId, token) {
-    let new_request_id = await this.generateConversation(ani, callId)
-
-    return axios({
-      url: this.API_URL + "/" + this.getProjectId() + "/requests/me?channel=" + CHANNEL_NAME,
-      //url: this.API_URL + "/" + this.getProjectId() + "/requests/me",
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: token,
-      },
-      method: "GET",
-    }).then((response) => {
-        let request_id;
-        if (response.data.requests[0]) {
-          request_id = response.data.requests[0].request_id;
-          winston.debug("[TiledeskChannel] use already opened conversation: ", request_id);
-        } else {
-          request_id = new_request_id;
-          winston.debug("[TiledeskChannel] use new conversation: ", request_id);
-        }
-        return request_id;
-    }).catch((err) => {
-        winston.error("[TiledeskChannel] get requests error: ", err);
-        return null;
-    });
-  }
-  
-  async getDepartments(token) {
-
-    return new Promise( async (resolve, reject) => {
-      await axios({
-        url: this.API_URL + "/" + this.getProjectId() + "/departments/allstatus",
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': token 
-        },
-        method: 'GET'
-      }).then((response) => {
-        winston.debug("[TiledeskChannel] get departments response.data: ", response.data)
-        resolve(response.data)
-      }).catch((err) => {
-        winston.error("[TiledeskChannel] get departments error");
-        reject(err)
-      })
-    })
-  }
-
-  async send(tiledeskMessage, token, conversation_id) {
-
-    return axios({
-      url: this.API_URL + `/${this.getProjectId()}/requests/${conversation_id}/messages`,
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': token
-      },
-      data: tiledeskMessage,
-      method: 'POST'
-    }).then((response) => {
-      winston.debug("[TiledeskChannel] send message response: ", response.data);
-      return response.data; 
-    }).catch((err) => {
-      winston.error("[TiledeskChannel] send message: ", err.response?.data);
-      return null;
-    })
-
-  }
-  
-  
-  /** ADD MESSAGE TO REDIS QUEUE **/
-  async addMessageToQueue(message){
-    
-    /*SKIP INFO MESSAGES*/
-    if(utils.messageType(TYPE_MESSAGE.INFO, message)){
-       winston.debug("> SKIPPING INFO message: " + JSON.stringify(message) );
-       return;
-    }
-
-    /*SKIP CURRENT USER MESSAGES*/
-    if (message.sender.indexOf(CHANNEL_NAME) > -1) {
-      winston.debug("> SKIPPING ECHO message: " + JSON.stringify(message) );
-      return;
-    }
-
-    winston.debug("> SAVE message TO QUEUE: " + JSON.stringify(message) );
-    /*SAVE MESSAGE TO QUEUE WITH KET tiledesk:queue:+conversation_id*/
-    let conversation_id = message.recipient
-    let redis_data = [ message ]
-    //get redis data for current conversation
-    /*const queue = await this.redis_client.get('tiledesk:queue:'+conversation_id);
-    if (queue) {
-      redis_data = JSON.parse(queue); //overrride default value with the stored one
-      console.log('redis_dataaaaa lenght before -->', redis_data.length, new Date())
-      redis_data.push(message) //push new received message
-      console.log('redis_dataaaaa lenght after -->', redis_data.length, new Date())
-    }
-    //save data to redis
-    await this.redis_client.set('tiledesk:queue:'+conversation_id, JSON.stringify(redis_data), {'EX': 86400});
-    */
-    
-    //push element to queue list and set expiration time
-    await this.redis_client.rPush('tiledesk:queue:'+conversation_id, JSON.stringify(message));
-    this.redis_client.expire('tiledesk:queue:'+conversation_id, 86400)
-    await this.redis_client.publish('tiledesk:conversation:'+conversation_id, JSON.stringify(message));
-    
-  }
-
-  
-  /** GET MESSAGES FROM REDIS QUEUE LIST **/
-  async getMessagesFromQueue(conversation_id){
-    let messages= [];
-    
-    //get redis data list for current conversation
-    const queue = await this.redis_client.lRange('tiledesk:queue:'+conversation_id, 0, -1);
-    if(queue){
-      messages = queue.map(item => JSON.parse(item));
-      if(messages.length > 0){
-        return messages
-      }
-    }
-    return messages;
-  }
-
-  /** PUBLISH MESSAGE TO REDIS TOPIC  **/
-  async publishMessageToTopic(message){
-    
-    /*SKIP INFO MESSAGES*/
-    if(utils.messageType(TYPE_MESSAGE.INFO, message)){
-      winston.debug("> SKIPPING INFO message: " + JSON.stringify(message) );
-      return;
-    }
-
-    /*SKIP CURRENT USER MESSAGES*/
-    if (message.sender.indexOf("vxml") > -1) {
-      winston.debug("> SKIPPING ECHO message: " + JSON.stringify(message) );
-      return;
-    }
-
-    winston.debug("> SAVE message TO QUEUE: " + JSON.stringify(message) );
-
-    let conversation_id = message.recipient
-    //PUBLISH MESSAGE TO REDIS TOPIC WITH KET tiledesk:queue:+conversation_id
-    await this.redis_client.publish('tiledesk:conversation:'+conversation_id, JSON.stringify(message));
-  }
-
-  /** SUBSCRIBE TO REDIS TOPIC */
-  async subscribeToTopic(conversation_id){
-    const topic = `tiledesk:conversation:${conversation_id}`;
-    // console.log("subscribeToTopic: " + topic);
-
-    // duplichi il client principale
-    const subscriber = this.redis_client.duplicate();
-    await subscriber.connect();
-
-    let resolved = false; // flag per assicurarsi che risolva solo una volta
-
-    return new Promise((resolve, reject) => {
-      const cleanup = async () => {
-        try {
-          await subscriber.unsubscribe(topic);
-          await subscriber.quit();
-        } catch (err) {
-          // ignora errori di chiusura
-        }
-      };
-
-      subscriber.subscribe(topic, async (message) => {
-        if (resolved) return; // se già risolto, ignora altri messaggi
-        resolved = true;
-
-        try {
-          const json = JSON.parse(message);
-          resolve(json);
-        } catch (err) {
-          reject(err);
-        } finally {
-          cleanup(); // chiudi il subscriber appena arriva il primo messaggio
-        }
-      }).catch(async (err) => {
-        if (!resolved) {
-          resolved = true;
-          reject(err);
-          await cleanup();
-        }
-      });
-    });
-  }
-  
-  /** REMOVE MESSAGE FROM REDIS QUEUE LIST **/
-  async removeMessageFromQueue(conversation_id, message_id){
-    let redis_data = []
-    
-    //get redis data list for current conversation
-    const queue = await this.redis_client.lRange('tiledesk:queue:'+conversation_id, 0, -1);
-    if (queue) {
-      redis_data = queue.map(item => JSON.parse(item)); //overrride default value with the stored one
-      redis_data = redis_data.filter((msg) => msg._id === message_id)
-      
-      //remove current message from list (key, element, count=0 -> remove all elements equal to value)
-      await this.redis_client.lRem('tiledesk:queue:'+conversation_id, 0, JSON.stringify(redis_data[0]))
-    }
-    
-  }
-  
-  /** CLEAR QUEUE FROM REDIS **/
-  async clearQueue(conversation_id){
-    if(conversation_id){
-      await this.redis_client.del('tiledesk:queue:'+conversation_id)
-    }
-  }
-  
-  
-  
-  
-  async generateWaitTdMessage(ani, delayTime){
-    
-    
-    return {
-      text: '',
-      senderFullname: ani,
-      attributes: {
-        commands:[
-          { type: 'wait', time: delayTime}
-        ]
-      },
-      channel: { name: CHANNEL_NAME }
-    }
-  }
-  
-  
-  async fixToken(token) {
-    let index = token.lastIndexOf("JWT ");
-    if (index != -1) {
-      let new_token = token.substring(index + 4);
-      return "JWT " + new_token;
-    } else {
-      return "JWT " + token;
-    }
-  }
-  
-}
-
-module.exports = { TiledeskChannel };

package/tiledesk/TiledeskSubscriptionClient.js

@@ -1,135 +0,0 @@
-const axios = require("axios").default;
-const winston = require('../winston')
-
-class TiledeskSubscriptionClient {
-
-  /**
-   * Constructor for TiledeskSubscriptionClient
-   *
-   * @example
-   * const { TiledeskSubscriptionClient } = require('tiledesk-subscription-client');
-   * const tdClient = new TiledeskSubscriptionClient({API_URL: tiledeskApiUrl, token: jwt_token, log: log});
-   * @param {Object} config JSON configuration.
-   * @param {string} config.API_URL Mandatory. The Tiledesk api url.
-   * @param {string} config.token Optional. Token required for authentication.
-   * @param {boolean} config.log Optional. If true HTTP requests are logged.
-   */
-  constructor(config) {
-    if (!config) {
-      throw new Error('[TiledeskSubscriptionClient] config is mandatory');
-    }
-
-    if (!config.API_URL) {
-      throw new Error('[TiledeskSubscriptionClient] config.API_URL is mandatory');
-    }
-
-    this.project_id = config.project_id
-    this.API_URL = config.API_URL;
-    this.token = config.token;
-    this.config = config;
-    this.log = false;
-    if (config.log) {
-      this.log = config.log;
-    }
-    
-  }
-
-  async subscribe(subscription_info, callback) {
-    const URL = this.API_URL + `/${this.project_id}/subscriptions`;
-    const HTTPREQUEST = {
-      url: URL,
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': this.token
-      },
-      json: subscription_info,
-      method: 'POST'
-    };
-    let promise = new Promise((resolve, reject) => {
-      TiledeskSubscriptionClient.myrequest(
-        HTTPREQUEST,
-        function(err, resbody) {
-          if (err) {
-            if (callback) {
-              callback(err);
-            }
-            reject(err);
-          }
-          else {
-            if (callback) {
-              callback(null, resbody);
-            }
-            winston.debug("[TiledeskSubscriptionClient] Subscribed");
-            resolve(resbody);
-          }
-        }, true);
-
-    })
-    return promise;
-  }
-
-  unsubscribe(subscriptionId, callback) {
-    const URL = this.API_URL + `/${this.project_id}/subscriptions/${subscriptionId}`;
-    const HTTPREQUEST = {
-      url: URL,
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': this.token
-      },
-      method: 'DELETE'
-    };
-    let promise = new Promise((resolve, reject) => {
-      TiledeskSubscriptionClient.myrequest(
-        HTTPREQUEST,
-        function(err, resbody) {
-          if (err) {
-            if (callback) {
-              callback(err);
-            }
-            reject(err);
-          }
-          else {
-            if (callback) {
-              callback(null, resbody);
-            }
-            winston.debug("[TiledeskSubscriptionClient] Unsubscribed");
-            resolve(resbody);
-          }
-        }, true);
-    })
-    return promise;
-  }
-
-
-  // HTTP REQUEST
-
-  static async myrequest(options, callback, log) {
-    
-    return await axios({
-      url: options.url,
-      method: options.method,
-      data: options.json,
-      params: options.params,
-      headers: options.headers
-    }).then((res) => {
-      if (res && res.status == 200 && res.data) {
-        if (callback) {
-          callback(null, res.data);
-        }
-      }
-      else {
-        if (callback) {
-          callback("Response status not 200", null, null);
-          //callback({ message: "Response status not 200" }, options, res), null, null);
-        }
-      }
-    }).catch((err) => {
-      if (callback) {
-        callback(err, null, null);
-      }
-    })
-  }
-
-}
-
-module.exports = { TiledeskSubscriptionClient }

package/tiledesk/fileUtils.js

@@ -1,55 +0,0 @@
-const axios = require("axios").default;
-const axiosRetry = require('axios-retry').default;
-var winston = require('../winston');
-
-/*axiosRetry(axios, {
-    retries: 3,
-    retryDelay: (...arg) => axiosRetry.exponentialDelay(...arg, 100),
-    retryCondition(error) {
-
-        if (error.response) {
-            winston.info("(retryCondition) response status: " + error.response.status);
-            switch (error.response.status) {
-                // example: retry only if status is 500 or 501
-                case 404:
-                    return true;
-                default:
-                    return false;
-            }
-        } else {
-            winston.info("(retryCondition) no response status. Error message: " + error.message);
-            return false;
-        }
-    },
-    onRetry: (retryCount, error, requestConfig) => {
-        winston.info("retry count: " + retryCount);
-        winston.verbose("retry error: " + error.response.status + " " + error.response.statusText);
-    }
-})
-*/
-
-class FileUtils {
-
-  
-    async downloadFromUrl(url) {
-      
-        return new Promise(async (resolve, reject) => {
-          await axios({
-              url: url,
-              responseType: 'arraybuffer',
-              method: 'GET'
-            }).then((resbody) => {
-              const buffer = Buffer.from(resbody.data, 'binary');
-              resolve(buffer);
-              //resolve(resbody.data);
-            }).catch((err) => {
-              reject(err);
-            })       
-        })
-      
-    }
-}
-
-var fileUtils = new FileUtils();
-
-module.exports = fileUtils;