fbhelpernodejs/lib/responseMessages.js

Modulo para axuiliar a construção de bots

var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };

/**
 * Created by Junior on 30/01/2018.
 */
const axios = require('axios');
const helper = require('./responseHelper');
const WebSocket = require('ws');
const uuid = require('uuid/v4');

const env = process.env;
const queueStats = env.queueStats;
const open = env.rabbitmq && queueStats ? require('amqplib').connect(env.rabbitmq) : null;

module.exports = class ResponseMessages {
  constructor(TOKEN, URL, USER_ID, _IDPAGE, SENDER = true) {
    this.TOKEN = TOKEN;
    this.USER_ID = USER_ID;
    this.URL = URL;
    this.SENDER = SENDER;
    this._IDPAGE = _IDPAGE;
    this.TEST = process.env.NODE_ENV === 'test';
    this.MODEL = process.env.MODEL || 'facebook';
    this.ENTRY_DATE = new Date();
    this.UUID = uuid();
    if (this.TEST) {
      this.multiMessage = false;
      this.ws = new WebSocket('ws://localhost:5099');
      this.SENDER = false;
    }
  }

  sendText(messageText) {
    let messageData = {
      recipient: {
        id: this.USER_ID
      },

      message: {
        text: messageText
      }
    };

    return this.callSendAPI(messageData);
  }

  sendMedia(typeMedia, url, attachmentId) {
    if (!typeMedia) {
      console.log('Tipo não definido Media');
      return;
    }
    let messageData = {
      recipient: {
        id: this.USER_ID
      },

      message: null
    };

    if (attachmentId) {
      messageData.message = {
        attachment: {
          type: typeMedia,
          payload: {
            attachment_id: attachmentId
          }
        }
      };
    } else {
      messageData.message = {
        attachment: {
          type: typeMedia,
          payload: {
            url: url,
            is_reusable: true
          }
        }
      };
    }
    return this.callSendAPI(messageData);
  }

  sendButtons(buttons) {
    let messageData = {
      recipient: {
        id: this.USER_ID
      },

      message: {
        attachment: {
          type: 'template',
          payload: {
            template_type: 'button',
            text: buttons.text,
            buttons: buttons.elements
          }
        }
      }
    };

    return this.callSendAPI(messageData);
  }

  sendQReplies(qreplies) {
    let messageData = {
      recipient: {
        id: this.USER_ID
      },

      message: {
        text: qreplies.text,
        quick_replies: qreplies.elements
      }
    };

    return this.callSendAPI(messageData);
  }

  sendCarrossel(carrossel, qreplies) {
    try {
      let message = { attachment: { type: 'template', payload: { template_type: 'generic', elements: helper.Carrossel(carrossel) } } };

      if (qreplies) message.quick_replies = qreplies['elements'];

      let messageData = {
        recipient: {
          id: this.USER_ID
        },

        message
      };

      return this.callSendAPI(messageData);
    } catch (err) {
      console.warn(err);
    }
  }

  sendTyping(messageText) {
    let messageData = {
      recipient: {
        id: this.USER_ID
      },

      sender_action: 'typing_on'
    };

    return this.callSendAPI(messageData);
  }

  sendByType(message, qreplies) {
    // {value: ..., type: '...'}
    switch (message.type) {
      case 'text':
        return this.sendText(message.value);
      case 'image':
        return this.sendMedia(message.type, message.value);
      case 'video':
        return this.sendMedia(message.type, message.value);
      case 'carrossel':
        if (this.MODEL !== 'facebook') message = this.adjustsValues(message);
        return this.sendCarrossel(message.value, qreplies);
      case 'buttons':
        if (this.MODEL !== 'facebook') message = this.adjustsValues(message);
        return this.sendButtons(message.value);
      case 'quickreply':
        if (this.MODEL !== 'facebook') message = this.adjustsValues(message);
        return this.sendQReplies(message.value);
      default:
        console.log(`Tipo não encontrado: ${message.type}`);
        return null;
    }
  }

  callSendAPI(messageData) {
    if (this.SENDER) {
      return new Promise((resolve, reject) => {
        axios.post(`${this.URL}/messages/?access_token=${this.TOKEN}`, messageData).then(res => {
          resolve(res);
          this.sendToStats('output', messageData, res.data);
          // let recipientID = res.recipient_id
          // let messageID = res.message_id
        }).catch(err => {
          reject(_extends({}, err, { messageToSend: messageData }));
          if (err.response) {
            console.log('erro', err.response.data.error);
          } else console.log('erro', err);
        });
      });
    } else {
      if (this.TEST) {
        return new Promise(resolve => {
          this.sendMsgTest(messageData, resolve);
        });
      }
      return messageData;
    }
  }

  sendMsgTest(messageData, resolve) {
    if (this.ws.readyState === 0) {
      setTimeout(() => {
        return this.sendMsgTest(messageData);
      }, 50);
    } else {
      const send = JSON.stringify(_extends({}, messageData, { multiMessage: this.multiMessage }));
      this.ws.send(send);
      resolve(send);
    }
  }

  adjustsValues(message) {
    const { value, type } = message;
    switch (type) {
      case 'carrossel':
        let elements = value.elements.map(element => ({
          title: element.title,
          subtitle: element.subTitle,
          image: element.image,
          buttons: element.elements.map(button => ({
            payload: button.callback,
            type: button.type,
            title: button.title
          }))
        }));
        return { type, value: elements };
      case 'buttons':
        return {
          type,
          value: {
            text: value.value,
            elements: value.elements.map(button => ({
              payload: button.callback,
              type: button.type,
              title: button.title
            }))
          }
        };
      case 'quickreply':
        return {
          type,
          value: {
            text: value.value,
            elements: value.elements.map(button => ({
              payload: button.callback,
              content_type: button.type,
              title: button.title
            }))
          }
        };
    }
  }

  sendToStats(type, messageData, fbResponse) {
    if (open) {
      let responseDate = new Date();
      let data = {
        interactionId: this.UUID,
        platform: 'facebook',
        entryDate: this.ENTRY_DATE,
        responseDate: responseDate,
        message: messageData,
        user: this.USER_ID,
        page: this._IDPAGE,
        type,
        fbResponse
      };
      open.then(conn => conn.createChannel()).then(ch => ch.assertQueue(queueStats).then(ok => {
        ch.sendToQueue(queueStats, Buffer.from(JSON.stringify(data)));
      })).catch(console.warn);
    }
  }
};