migme-seagull/lib/group-chat.js

Migme Chat

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = GroupChat;

var _migmeFerry = require('migme-ferry');

var _chatEvent = require('./events/chat-event');

var _chatEvent2 = _interopRequireDefault(_chatEvent);

var _config = require('./config/config');

var _dinghy = require('./utils/dinghy');

var _dinghy2 = _interopRequireDefault(_dinghy);

var _messages2 = require('./messages');

var _emoticons = require('./emoticons');

var _config2 = require('./config');

var _events = require('events');

var _events2 = _interopRequireDefault(_events);

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
* GroupChat
*/
function GroupChat(chat_id) {
  var dinghy = (0, _dinghy2.default)();
  var state = {
    chat_id: chat_id,
    chat_type: _config.DestinationType.group
  };

  var group = Object.assign({}, _events2.default.prototype, {
    /**
    * Join a groupchat
    * @param {string} destination - Individual groups id.
    * @return {Promise}
    * @example
    * groupchat.join('XXXXXXXXXXXXXXXXX')
    */

    join: function join(chat_id) {
      if (state.chat_id) throw new Error('A chatgroup has already been joined');
      Object.assign(state, { chat_id: chat_id });
    },


    /**
    * Creates a new chat group
    * @param {Array} user_array - Array of usernames
    * @return {Promise}
    * @example
    * groupchat.create(['exampleuser', 'anotheruser'])
    */
    create: function create(user_array) {
      if (!(user_array instanceof Array)) {
        throw new Error('User array must be an array of strings');
      }

      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.CREATE_GROUP_CHAT, {
        invited_username_list: user_array
      });
      return dinghy.send(packet);
    },


    /**
    * Sends a message
    * @param {string} message - Message to send
    * @param {Object} options - Additional options to change in the packet
    * @return {Promise}
    * @example
    * groupchat.send('The message I want to send')
    */
    send: function send(content) {
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

      return (0, _messages2.send)(dinghy, Object.assign({ content: content }, options, state));
    },


    /**
    * Sends a sticker
    * @param {string} sticker - Sticker to send
    * @return {Promise}
    * @example
    * groupchat.sendSticker('HSthumbsup')
    */
    sendSticker: function sendSticker(sticker) {
      return (0, _messages2.sendSticker)(dinghy, sticker, state);
    },

    /**
    * Sends a gift in the groupchat
    * @param {string} gift - Gift to be sent
    * @param {string} message - Message to be sent
    * @param {string} destination - Username of user to send to. Default: "all"
    * @return {Promise}
    * @example
    * chatroom.sendGift('GiftName', 'Message to send with it', 'username')
    */
    sendGift: function sendGift(gift, message) {
      var destination = arguments.length <= 2 || arguments[2] === undefined ? 'all' : arguments[2];
      return (0, _messages2.sendGift)(dinghy, Object.assign({}, state, {
        gift: gift,
        message: message,
        destination: destination
      }));
    },

    sendMedia: function sendMedia(url) {
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
      return (0, _messages2.sendMedia)(dinghy, url, Object.assign(options, state));
    },

    /**
    * Get chat group participants
    * @return {Promise}
    * @example
    * groupchat.participants()
    */
    participants: function participants() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.GET_GROUP_CHAT_PARTICIPANTS, {
        group_chat_id: state.chat_id
      });
      return dinghy.send(packet);
    },


    /**
    * Invite users to a chat group
    * @return {Promise}
    * @example
    * groupchat.invite('exampleuser')
    * // or
    * groupchat.invite(['exampleuser', 'anotheruser'])
    */
    invite: function invite(users) {
      var usernames = void 0;
      if (typeof users === 'string') {
        usernames = [users];
      } else if (users instanceof Array) {
        usernames = users;
      } else {
        throw new Error('Please provide either an array of usernames or a string.');
      }
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.GROUP_CHAT_INVITE, {
        group_chat_id: state.chat_id,
        invited_username_list: usernames
      });
      return dinghy.send(packet);
    },


    getEmoticon: function getEmoticon(hotkey_list) {
      return (0, _emoticons.getEmoticon)(dinghy, hotkey_list);
    },

    /**
    * Set the chat group name
    * @param {string} name - Name of the chat
    * @return {Promise}
    * @example
    * groupchat.name('Some topic').then(res => {})
    */
    name: function name(chat_name) {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.SET_CHAT_NAME, Object.assign({ chat_name: chat_name }, state));
      return dinghy.send(packet);
    },


    /*
    * Get messages from chat
    * @return {Promise}
    * @example
    * groupchat.messages().then(res => {})
    */
    messages: function messages() {
      var options = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
      return (0, _messages2.messages)(dinghy, Object.assign(options, state));
    },

    /**
    * Pin a message
    * @return {Promise}
    * @example
    * chat.pin(packet).then(res => {})
    */
    pin: function pin(fields) {
      return (0, _messages2.pin)(dinghy, fields);
    },

    /**
    * Unpin a message
    * @return {Promise}
    * @example
    * chat.unpin(packet).then(res => {})
    */
    unpin: function unpin(fields) {
      return (0, _messages2.unpin)(dinghy, fields);
    },

    /**
    * Get chat pinned message
    * @return {Promise}
    * @example
    * chat.getPinnedMessage().then(res => {})
    */
    getPinnedMessage: function getPinnedMessage() {
      return (0, _messages2.getPinnedMessage)(dinghy, state);
    },

    /**
    * Leave the groupchat
    * @return {Promise}
    * @example
    * groupchat.leave()
    */
    leave: function leave() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.LEAVE_GROUP_CHAT, {
        group_chat_id: state.chat_id
      });
      return dinghy.send(packet);
    },
    destination: function destination() {
      return state.chat_id;
    },

    get dinghy() {
      return dinghy;
    }
  });

  var onPacketReceived = function onPacketReceived(e) {
    var packet = new _migmeFerry.Packet();
    packet.fromJSON(e);
    if (!dinghy.currentTransactions.has(packet.transactionId) && packet.fields.destination === state.chat_id && packet.fields.chat_type === _config.DestinationType.group) {
      group.emit(_chatEvent2.default.MESSAGE_RECEIVED, packet);
    }
  };

  _config2.ferry.on(_migmeFerry.FerryEvent.PACKET_RECEIVED, onPacketReceived);

  return group;
}
module.exports = exports['default'];