posiflow-telegram-connector 1.0.3

package/tiledesk/TiledeskTelegram.js

@@ -0,0 +1,304 @@
+const axios = require('axios').default;
+const FormData = require('form-data');
+const winston = require('../winston');
+
+class TiledeskTelegram {
+
+  /**
+   * Constructor for TiledeskTelegram
+   *
+   * @example
+   * const { TiledeskTelegram } = require('tiledesk-telegram');
+   * const twclient = new TiledeskTelegram({ BASE_URL: BASE_URL, telegram_token: telegram_token, TELEGRAM_API_URL: TELEGRAM_API_URL });
+   * 
+   * @param {Object} config JSON configuration.
+   * @param {string} config BASE_URL Mandatory. The base url of this application.
+   * @param {string} config.token Mandatory. Token required for authentication.
+   * @param {string} config.TELEGRAM_API_URL Mandatory. Url for telegram api.
+   * @param {boolean} options.log Optional. If true HTTP requests are logged.
+   */
+
+  constructor(config) {
+    if (!config) {
+      throw new Error('config is mandatory');
+    }
+
+    if (!config.BASE_URL) {
+      throw new Error('config.BASE_URL is mandatory');
+    }
+
+    if (!config.TELEGRAM_API_URL) {
+      throw new Error('config.TELEGRAM_API_URL is mandatory');
+    }
+
+    this.TELEGRAM_API_URL = config.TELEGRAM_API_URL;
+    this.BASE_URL = config.BASE_URL;
+    // others?
+
+    this.log = false;
+    if (config.log) {
+      this.log = config.log;
+    }
+
+  }
+
+  async send(telegram_token, message) {
+    return new Promise((resolve, reject) => {
+      if (message.photo) {
+        this.sendPhoto(telegram_token, message).then((response) => {
+          resolve(response);
+        }).catch((err) => {
+          reject(err);
+        })
+      } 
+      else if (message.video) {
+        this.sendVideo(telegram_token, message).then((response) => {
+          resolve(response);
+        }).catch((err) => {
+          reject(err);
+        })
+      } 
+      else if (message.document) {
+        this.sendDocument(telegram_token, message).then((response) => {
+          resolve(response);
+        }).catch((err) => {
+          reject(err);
+        })
+      } else {
+        this.sendMessage(telegram_token, message).then((response) => {
+          resolve(response);
+        }).catch((err) => {
+          reject(err);
+        })
+      }
+    })
+  }
+
+  async sendMessage(telegram_token, message) {
+    winston.verbose("(tgm) [TiledeskTelegram] Sending message...");
+    winston.debug("(tgm) [TiledeskTelegram] Sending message...", message);
+    
+    return await axios({
+      url: this.TELEGRAM_API_URL + `${telegram_token}/sendMessage`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      data: message,
+      method: 'POST'
+    }).then((response) => {
+      return response;
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] send message error: ", err.response.data);
+      return err;
+    })
+  }
+
+
+  async sendPhoto(telegram_token, message) {
+    winston.verbose("(tgm) [TiledeskTelegram] Sending message...");
+    winston.debug("(tgm) [TiledeskTelegram] Sending message...", message);
+
+    return await axios({
+      url: this.TELEGRAM_API_URL + `${telegram_token}/sendPhoto`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      data: message,
+      method: 'POST'
+    }).then((response) => {
+      return response;
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] send photo message error: " + err);
+      throw err;
+    })
+  }
+
+  async sendVideo(telegram_token, message) {
+    winston.verbose("(tgm) [TiledeskTelegram] Seding message...");
+    winston.debug("(tgm) [TiledeskTelegram] Sending message...", message);
+
+    return await axios({
+      url: this.TELEGRAM_API_URL + `${telegram_token}/sendVideo`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      data: message,
+      method: 'POST'
+    }).then((response) => {
+      return response;
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] send video message error: " + err);
+      return err;
+    })
+  }
+
+  async sendDocument(telegram_token, message) {
+    winston.verbose("(tgm) [TiledeskTelegram] Seding message...");
+    winston.debug("(tgm) [TiledeskTelegram] Sending message...", message);
+
+    return await axios({
+      url: this.TELEGRAM_API_URL + `${telegram_token}/sendDocument`,
+      headers: {
+        "Content-Type": "application/json"
+      },
+      data: message,
+      method: 'POST'
+    }).then((response) => {
+      return response;
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] send document message error: " + err);
+      return err;
+    })
+  }
+
+
+  async setWebhookEndpoint(projectId, telegram_token, callback) {
+    const URL = this.TELEGRAM_API_URL + `${telegram_token}/setwebhook`;
+    const data = {
+      "url": this.BASE_URL + `/telegram/?project_id=${projectId}`
+    }
+    console.log("data: ", data)
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: data,
+      method: 'POST'
+    };
+    let promise = new Promise((resolve, reject) => {
+      TiledeskTelegram.request(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            resolve(resbody);
+          }
+        }, true)
+    })
+    return promise;
+  }
+  
+  async deleteWebhookEndpoint(projectId, telegram_token, callback) {
+    const URL = this.TELEGRAM_API_URL + `${telegram_token}/deleteWebhook`;
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      method: 'POST'
+    };
+    let promise = new Promise((resolve, reject) => {
+      TiledeskTelegram.request(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            resolve(resbody);
+          }
+        }, true)
+    })
+    return promise;
+  }
+
+
+  async editMessageReplyMarkup(telegram_token, reply_markup_data, callback) {
+    const URL = this.TELEGRAM_API_URL + `${telegram_token}/editMessageReplyMarkup`;
+    const HTTPREQUEST = {
+      url: URL,
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      json: reply_markup_data,
+      method: 'GET'
+    };
+
+    let promise = new Promise((resolve, reject) => {
+      TiledeskTelegram.request(
+        HTTPREQUEST,
+        function(err, resbody) {
+          if (err) {
+            if (callback) {
+              callback(err);
+            }
+            reject(err);
+          }
+          else {
+            if (callback) {
+              callback(null, resbody);
+            }
+            resolve(resbody);
+          }
+        }, true)
+    })
+    return promise;
+  }
+
+
+  async downloadMedia(telegram_token, mediaId) {
+    winston.debug("(tgm) [TiledeskTelegram] Downloading media: ", mediaId)
+    
+    return await axios({
+      url: this.TELEGRAM_API_URL + `${telegram_token}/getFile?file_id=${mediaId}`,
+      headers: {
+        "Content-Type": "application/json",
+      },
+      method: "GET"
+    }).then((response) => {
+      winston.verbose("(tgm) [TiledeskTelegram] Download complete");
+      return response.data
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] Download failed!: " + err);
+      return err;
+    })
+  }
+
+
+  // HTTP REQUEST
+  static async request(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(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    }).catch((err) => {
+      winston.error("(tgm) [TiledeskTelegram] An error occured: ", err);
+      if (callback) {
+        callback("an error occured", null, null);
+      }
+    })
+  }
+
+
+}
+
+module.exports = { TiledeskTelegram }

package/tiledesk/TiledeskTelegramTranslator.js

@@ -0,0 +1,300 @@
+const winston = require('../winston')
+
+class TiledeskTelegramTranslator {
+
+  /**
+   * Constructor for TiledeskTelegramTranslator
+   *
+   * @example
+   * const { TiledeskTelegramTranslator } = require('tiledesk-telegram-translator');
+   * const tlr = new TiledeskTelegramTranslator({ TELEGRAM_FILE_URL: TELEGRAM_FILE_URL});
+   * 
+   * @param {Object} config JSON configuration.
+   * @param {string} config.TELEGRAM_FILE_URL Mandatory. Url for telegram file.
+   */
+
+  static CHANNEL_NAME = "telegram";
+  static TELEGRAM_FILE_BASE_URL = "https://api.telegram.org/file/bot"
+
+  constructor() {
+
+    this.log = false;
+
+  }
+
+  async toTelegram(tiledeskChannelMessage, telegram_receiver) {
+
+    winston.debug("(tgm) [Translator] Tiledesk message: ", tiledeskChannelMessage);
+
+    let text = '';
+    if (tiledeskChannelMessage.text) {
+      text = tiledeskChannelMessage.text;
+    }
+
+    const telegram_message = {
+      chat_id: telegram_receiver,
+      parse_mode: "markdown"
+    }
+
+    if (tiledeskChannelMessage.type === 'frame') {
+      text = text + "\n\n👉 " + tiledeskChannelMessage.metadata.src
+      telegram_message.text = text;
+      return telegram_message;
+    }
+
+    // Metadata
+    if (tiledeskChannelMessage.metadata) {
+
+      if ((tiledeskChannelMessage.metadata.type && tiledeskChannelMessage.metadata.type.startsWith('image')) || tiledeskChannelMessage.type.startsWith('image')) {
+
+        telegram_message.photo = tiledeskChannelMessage.metadata.src;
+        telegram_message.caption = text;
+
+      }
+
+      else if ((tiledeskChannelMessage.metadata.type && tiledeskChannelMessage.metadata.type.startsWith('video')) || tiledeskChannelMessage.type.startsWith('video')) {
+
+        telegram_message.video = tiledeskChannelMessage.metadata.src
+        //telegram_message.caption = tiledeskChannelMessage.metadata.name || text;
+        telegram_message.caption = text;
+      }
+
+      else if ((tiledeskChannelMessage.metadata.type && tiledeskChannelMessage.metadata.type.startsWith('application')) || tiledeskChannelMessage.type.startsWith('application')) {
+        //else if (tiledeskChannelMessage.metadata.type.startsWith('application')) {
+
+        telegram_message.document = tiledeskChannelMessage.metadata.src;
+        //telegram_message.caption = tiledeskChannelMessage.text.substr(tiledeskChannelMessage.text.indexOf(')') + 1);  
+        telegram_message.caption = tiledeskChannelMessage.text
+
+      }
+
+      else {
+        winston.verbose("(tgm) [Translator] file type not supported");
+        return null;
+      }
+      
+      return telegram_message;
+
+    }
+
+
+    else if (tiledeskChannelMessage.attributes) {
+      if (tiledeskChannelMessage.attributes.attachment) {
+        if (tiledeskChannelMessage.attributes.attachment.buttons) {
+
+          let buttons = tiledeskChannelMessage.attributes.attachment.buttons;
+
+          // Using Reply Keyboard instead of Inline Keyboard
+          // This makes button clicks appear in chat history
+
+          let keyboard_buttons = [];
+
+          // Loop on buttons - process only 'text' and 'action' types for Reply Keyboard
+          for (let btn of buttons) {
+
+            if (btn.type == 'text') {
+              // Reply keyboard uses simple text buttons
+              // Each button in its own row (vertical layout)
+              keyboard_buttons.push([{ text: btn.value }]);
+            }
+
+            if (btn.type == 'action') {
+              // Action buttons also appear as text in Reply Keyboard
+              // The action will be triggered by the text message
+              let text_value = (btn.value.length > 36) ? btn.value.substr(0, 34) + '..' : btn.value;
+              keyboard_buttons.push([{ text: text_value }]);
+            }
+
+            // Note: URL buttons are not supported in Reply Keyboard
+            // They would need to remain as inline_keyboard if needed
+          }
+
+          telegram_message.text = tiledeskChannelMessage.text;
+          if (keyboard_buttons.length > 0) {
+            telegram_message.reply_markup = {
+              keyboard: keyboard_buttons,  // Each button in its own row
+              resize_keyboard: true,
+              one_time_keyboard: true  // Keyboard disappears after selection
+            }
+          }
+
+          return telegram_message;
+
+          // For Solution 2
+          // Loop on button of type = 'text' --> quick replies
+
+          /*
+          for (let btn of buttons) {
+            if (btn.type == 'text') {
+              quick_replies.push({ text: btn.value });
+            }
+          }
+ 
+          const data3 = {
+            chat_id: chatId,
+          }
+ 
+          if (quick_replies.length > 0) {
+            if (inline_buttons.length == 0) {
+              data3.text = payload.text;
+            } else {
+              data3.text = 'Here the problem'
+            }
+ 
+            data3.reply_markup = {
+              keyboard: [
+                quick_replies
+              ],
+              resize_keyboard: true,
+              one_time_keyboard: true
+            }
+            console.log("Data (Quick Replies): ", data3)
+            console.log("Quick Replies: ", data3.reply_markup.keyboard)
+ 
+            sendTelegramMessage(tg_token, data3).then((response) => {
+              console.log("SendTelegramMessage Response (quick replies): ", response)
+            }).catch((err) => {
+              console.log("Error SendTelegramMessage (quick replies): ", err)
+            })
+          }
+          */
+
+        } else {
+          winston.verbose("(tgm) [Translator] attributes attachment not supported");
+          return null;
+        }
+
+      } else {
+        telegram_message.text = tiledeskChannelMessage.text;
+        return telegram_message;
+      }
+    }
+
+    else {
+      telegram_message.text = tiledeskChannelMessage.text;
+      return telegram_message;
+    }
+
+
+
+  }
+
+  async toTiledesk(telegramChannelMessage, telegram_token, media_url) {
+
+    // Reply Keyboard sends regular messages, no callback_query handling needed
+
+    if (telegramChannelMessage.message) {
+
+      let message = telegramChannelMessage.message;
+
+      // Photo
+      if (message.photo) {
+        let image_url = TiledeskTelegramTranslator.TELEGRAM_FILE_BASE_URL + `${telegram_token}/${media_url}`;
+        let index = telegramChannelMessage.message.photo.length - 1;
+
+        var msg = {
+          text: message.caption || "Attached image",
+          senderFullname: message.from.first_name + " " + message.from.last_name,
+          channel: { name: TiledeskTelegramTranslator.CHANNEL_NAME },
+          type: "image",
+          metadata: {
+            src: image_url,
+            width: message.photo[index].width,
+            height: message.photo[index].height,
+          }
+        }
+        return msg;
+      }
+
+      // Video
+      else if (message.video) {
+        let video_url = TiledeskTelegramTranslator.TELEGRAM_FILE_BASE_URL + `${telegram_token}/${media_url}`;
+        winston.debug("(tgm) [Translator] video url: ", video_url)
+
+        var msg = {
+          text: "[" + message.video.file_name + "](" + video_url + ")",
+          senderFullname: message.from.first_name + " " + message.from.last_name,
+          channel: { name: TiledeskTelegramTranslator.CHANNEL_NAME },
+          type: "video",
+          metadata: {
+            src: video_url,
+            name: message.video.file_name,
+            type: message.video.mime_type
+          }
+        }
+        return msg;
+
+      }
+
+      // Document
+      else if (message.document) {
+        let document_url = TiledeskTelegramTranslator.TELEGRAM_FILE_BASE_URL + `${telegram_token}/${media_url}`;
+
+        var msg = {
+          text: "[" + message.document.file_name + "](" + document_url + ")",
+          senderFullname: message.from.first_name + " " + message.from.last_name,
+          channel: { name: TiledeskTelegramTranslator.CHANNEL_NAME },
+          type: "file",
+          metadata: {
+            name: message.document.file_name,
+            type: message.document.mime_type,
+            src: document_url
+          }
+        }
+        return msg;
+      }
+
+      // Text message
+      else {
+
+        var msg = {
+          text: telegramChannelMessage.message.text,
+          senderFullname: message.from.first_name + " " + message.from.last_name,
+          channel: { name: TiledeskTelegramTranslator.CHANNEL_NAME }
+        }
+        return msg;
+      }
+
+    }
+    else {
+      winston.verbose("(tgm) [Translator] Format not supported!")
+      return null;
+    }
+
+  }
+
+
+
+  // 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(TiledeskClient.getErr({ message: "Response status not 200" }, options, res), null, null);
+        }
+      }
+    }).catch((err) => {
+      winston.error("(tgm) [Translator] An error occured: ", err);
+      if (callback) {
+        callback("An error occurred", null, null);
+      }
+    })
+  }
+
+}
+
+module.exports = { TiledeskTelegramTranslator }

package/winston.js

@@ -0,0 +1,41 @@
+var appRoot = require('app-root-path');
+var winston = require('winston');
+var level = process.env.TELEGRAM_LOG || '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;