migme-seagull/lib/room.js

Migme Chat

'use strict';

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

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

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

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

var _chatEvent2 = _interopRequireDefault(_chatEvent);

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

var _dinghy2 = _interopRequireDefault(_dinghy);

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

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

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

var _events = require('events');

var _events2 = _interopRequireDefault(_events);

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

function ChatRoom(chat_id) {
  var dinghy = (0, _dinghy2.default)();
  var state = {
    chat_id: chat_id,
    chat_type: _config.DestinationType.public_chat
  };

  var room = Object.assign({}, _events2.default.prototype, {
    /**
    * Create a new chatroom
    * To create a new chatroom the user needs to be mig level 10 or higher.
    * @param {string} name - Name of chatroom. Max 15 characters.
    * @param {Ferry} ferry - Instance of Ferry
    * @param {Object} options - Additional options to be passed.
    * @return {Promise}
    * @example
    * chatroom.create('My new room', options)
    */

    create: function create(chatroom_name) {
      var options = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

      var fields = {
        chatroom_name: chatroom_name
      };
      Object.assign(fields, options);
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.CREATE_CHATROOM, fields);
      return dinghy.send(packet);
    },


    /**
    * Join a chatroom.
    * @return {Promise}
    * @param {string} destination - Room name
    * @example
    * chatroom.join('My new room')
    */
    join: function join(chat_id) {
      Object.assign(state, { chat_id: chat_id });

      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.JOIN_CHATROOM, {
        chatroom_name: chat_id
      });
      return dinghy.send(packet);
    },


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

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


    sendSticker: function sendSticker(sticker) {
      return (0, _messages.sendSticker)(dinghy, sticker, state);
    },

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

    /**
    * Sends a gift in the chatroom
    * @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, _messages.sendGift)(dinghy, Object.assign({}, state, {
        gift: gift,
        message: message,
        destination: destination
      }));
    },

    /**
    * Add Room to favorites
    * @return {Promise}
    * @example
    * chatroom.favorite()
    */
    favorite: function favorite() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.ADD_FAVORITE_CHATROOM, {
        chatroom_name: state.chat_id
      });
      return dinghy.send(packet);
    },


    /**
    * Remove Room from favorites
    * @return {Promise}
    * @example
    * chatroom.unfavorite()
    */
    unfavorite: function unfavorite() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.REMOVE_FAVORITE_CHATROOM, {
        chatroom_name: state.chat_id
      });
      return dinghy.send(packet);
    },


    /**
    * Get chatroom participants
    * @return {Promise}
    * @example
    * chatroom.participants()
    */
    participants: function participants() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.GET_CHATROOM_PARTICIPANTS, {
        chatroom_name: state.chat_id
      });
      return dinghy.send(packet);
    },


    /**
    * Kick a user from the chatroom
    * @return {Promise}
    * @example
    * chatroom.kick('exampleuser')
    */
    kick: function kick(username) {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.KICK_CHATROOM_PARTICIPANT, {
        chatroom_name: state.chat_id,
        username: username
      });
      return dinghy.send(packet);
    },


    /**
    * Mutes a user in the chatroom
    * @return {Promise}
    * @example
    * chatroom.mute('exampleuser')
    */
    mute: function mute(username) {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.MUTE_CHATROOM_PARTICIPANT, {
        chatroom_name: state.chat_id,
        username: username
      });
      return dinghy.send(packet);
    },


    /**
    * Mutes a user in the chatroom
    * @return {Promise}
    * @example
    * chatroom.mute('exampleuser')
    */
    unmute: function unmute(username) {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.UNMUTE_CHATROOM_PARTICIPANT, {
        chatroom_name: state.chat_id,
        username: username
      });
      return dinghy.send(packet);
    },


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

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

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

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

    /**
    * Leave the chatroom
    * @return {Promise}
    * @example
    * chatroom.leave()
    */
    leave: function leave() {
      var packet = new _migmeFerry.Packet(_migmeFerry.PacketType.LEAVE_CHATROOM, {
        chatroom_name: 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.public_chat) {
      room.emit(_chatEvent2.default.MESSAGE_RECEIVED, packet);
    }
  };

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

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