@tiledesk/tiledesk-tybot-connector 0.5.0 → 0.5.1-rc1

package/utils/winston.js

@@ -0,0 +1,42 @@
+require('dotenv').config();
+var appRoot = require('app-root-path');
+var winston = require('winston');
+var level = process.env.LOG_LEVEL || "info";
+
+var options = {
+  file: {
+    level:level ,
+    filename: `${appRoot}/logs/app.log`,
+    handleExceptions: true,
+    json: false,
+    maxsize: 5242880, // 5MB
+    maxFiles: 5,
+    colorize: false,
+    format: winston.format.simple()
+  },
+  console: {
+    level: level,
+    handleExceptions: true,
+    json: true,
+    colorize: true,
+    // timestamp: true,
+    format: winston.format.simple()     
+  },
+};
+
+let logger = winston.createLogger({    
+  transports: [
+   new (winston.transports.Console)(options.console),
+   new (winston.transports.File)(options.file),
+  ],
+  exitOnError: false, // do not exit on handled exceptions
+});
+
+logger.stream = {
+  write: function(message, encoding) {
+    logger.info(message);
+  },
+};
+
+
+module.exports = logger;

package/TdCache copy.js

@@ -1,242 +0,0 @@
-const redis = require('redis');
-
-class TdCache {
-
-    constructor(config) {
-        this.redis_host = config.host;
-        this.redis_port = config.port;
-        this.redis_password = config.password;
-        this.client = null;
-    }
-
-    async connect(callback) {
-        // client = redis.createClient();
-        return new Promise( async (resolve, reject) => {
-            this.client = redis.createClient(
-                {
-                    host: this.redis_host,
-                    port: this.redis_port,
-                    password: this.redis_password
-                });
-            this.client.on('error', err => {
-                reject(err);
-                if (callback) {
-                    callback(err);
-                }
-            });
-            // this.client.on('connect', function() {
-            //     console.log('Redis Connected!');
-            // });
-            this.client.on('ready',function() {
-              console.log("connected")
-                resolve();
-                if (callback) {
-                    callback();
-                }
-                //console.log("Redis is ready.");
-            });
-        });
-    }
-
-    async set(key, value, options) {
-      //console.log("setting key value", key, value)
-      if (!options) {
-        options = {EX: 86400}
-      }
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            await this.client.set(
-              key,
-              value,
-              'EX', options.EX);
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.set(
-              key,
-              value);
-          }
-          catch(error) {
-            console.error("Error", error);
-            reject(error)
-          }
-        }
-        if (options && options.callback) {
-            options.callback();
-        }
-        //console.log("resolving...", key);
-        return resolve();
-      });
-    }
-
-    async incr(key) {
-      // console.log("incr key:", key)
-      return new Promise( async (resolve, reject) => {
-          try {
-            // console.log("incr here...key", key)
-            await this.client.incr(key);
-          }
-          catch(error) {
-            console.error("Error on incr:", error);
-            reject(error)
-          }
-        return resolve();
-      });
-    }
-
-    async hset(dict_key, key, value, options) {
-      //console.log("hsetting dict_key key value", dict_key, key, value)
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            await this.client.hset(
-              dict_key,
-              key,
-              value,
-              'EX', options.EX);
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.hset(
-              dict_key,
-              key,
-              value);
-          }
-          catch(error) {
-            console.error("Error", error);
-            reject(error)
-          }
-        }
-        if (options && options.callback) {
-            options.callback();
-        }
-        return resolve();
-      });
-    }
-
-    async hdel(dict_key, key, options) {
-      //console.log("hsetting dict_key key value", dict_key, key, value)
-      return new Promise( async (resolve, reject) => {
-        if (options && options.EX) {
-          //console.log("expires:", options.EX)
-          try {
-            await this.client.hdel(
-              dict_key,
-              key,
-              'EX', options.EX);
-          }
-          catch(error) {
-            reject(error)
-          }
-        }
-        else {
-          try {
-            //console.log("setting here...key", key, value)
-            await this.client.hdel(
-              dict_key,
-              key);
-          }
-          catch(error) {
-            console.error("Error", error);
-            reject(error);
-          }
-        }
-        if (options && options.callback) {
-            options.callback();
-        }
-        return resolve();
-      });
-    }
-    
-    async setJSON(key, value, options) {
-      const _string = JSON.stringify(value);
-      return await this.set(key, _string, options);
-    }
-    
-    async get(key, callback) {
-      //console.log("getting key", key)
-      return new Promise( async (resolve, reject) => {
-        this.client.get(key, (err, value) => {
-          if (err) {
-            reject(err);
-          }
-          else {
-            if (callback) {
-              callback(value);
-          }
-          return resolve(value);
-          }
-        });
-      });
-    }
-
-    async hgetall(dict_key, callback) {
-      //console.log("hgetting dics", dict_key);
-      return new Promise( async (resolve, reject) => {
-        this.client.hgetall(dict_key, (err, value) => {
-          if (err) {
-            reject(err);
-            if (callback) {
-              callback(err, null);
-            }
-          }
-          else {
-            if (callback) {
-              callback(null, value);
-            }
-            resolve(value);
-          }
-        });
-      });
-    }
-
-    async hget(dict_key, key, callback) {
-      //console.log("hgetting dics", dict_key);
-      return new Promise( async (resolve, reject) => {
-        this.client.hget(dict_key, key, (err, value) => {
-          if (err) {
-            reject(err);
-            if (callback) {
-              callback(err, null);
-            }
-          }
-          else {
-            if (callback) {
-              callback(null, value);
-            }
-            resolve(value);
-          }
-        });
-      });
-    }
-    
-    async getJSON(key, callback) {
-      const value = await this.get(key);
-      return JSON.parse(value);
-    }
-    
-    async del(key, callback) {
-      return new Promise( async (resolve, reject) => {
-        await this.client.del(key);
-        if (callback) {
-            callback();
-        }
-        return resolve();
-      })
-    }
-}
-
-module.exports = { TdCache };

package/TiledeskServices/utils.js

@@ -1,99 +0,0 @@
-let axios = require('axios');
-let https = require("https");
-
-class Utils {
-    constructor(){}
-
-
-    static myrequest(options, callback, log) {
-        if (log) {
-          console.log("** API URL:", options.url);
-          console.log("** Options:", JSON.stringify(options));
-        }
-        let axios_settings = {
-          url: options.url,
-          method: options.method,
-          data: options.json,
-          params: options.params,
-          headers: options.headers
-        }
-        // console.log("options.url.startsWith(https:)", options.url.startsWith("https:"))
-        // console.log("this.httpsOptions", this.httpsOptions)
-        
-        if (options.url.startsWith("https:") && options.httpsOptions) {
-          // console.log("Tiledesk Client v 0.9.x: url.startsWith https: && httpsOptions");
-          const httpsAgent = new https.Agent(options.httpsOptions);
-          axios_settings.httpsAgent = httpsAgent;
-        }
-        else if (options.url.startsWith("https:") && !options.httpsOptions) {
-          // HTTPS default is rejectUnauthorized: false
-          // console.log("Tiledesk Client v 0.9.x: url.startsWith https: && NOT httpsOptions");
-          const httpsAgent = new https.Agent({
-            rejectUnauthorized: false,
-          });
-          axios_settings.httpsAgent = httpsAgent;
-        }
-
-
-        
-        // console.log("Using axios settings:", axios_settings)
-        // axios(
-        //   {
-        //     url: options.url,
-        //     method: options.method,
-        //     data: options.json,
-        //     params: options.params,
-        //     httpsAgent: httpsAgent,
-        //     headers: options.headers
-        //   })
-        axios(axios_settings)
-        .then(function (res) {
-          if (log) {
-            console.log("Response for url:", options.url);
-            console.log("Response headers:\n", JSON.stringify(res.headers));
-            // console.log("******** Response for url:", res);
-          }
-          
-          if (res && res.status == 200 && res.data) {
-            if (callback) {
-              callback(null, res.data);
-            }
-          }
-          else {
-            
-            if (callback) {
-              callback(Utils.getErr({message: "Response status not 200"}, options, res), null, null);
-            }
-          }
-        })
-        .catch(function (error) {
-          // console.error(error); 
-          if (callback) {
-            callback(error, null, null);
-          }
-        });
-    }
-
-    static getErr(err, request, response) {
-        let res_err = {}
-        res_err.http_err = err;
-        res_err.http_request = request;
-        res_err.http_response = response;
-        return res_err;
-    }
-
-    static fixToken(token) {
-        if (token.startsWith('JWT ')) {
-            return token;
-        }
-        else {
-            return 'JWT ' + token;
-        }
-    }
-
-
-
-
-}
-
-module.exports = Utils