2016-02-16 08:46:47 +01:00
|
|
|
// Converse.js (A browser based XMPP chat client)
|
|
|
|
|
// http://conversejs.org
|
|
|
|
|
//
|
2017-02-13 15:37:17 +01:00
|
|
|
// Copyright (c) 2012-2017, Jan-Carel Brand <jc@opkode.com>
|
2016-02-16 08:46:47 +01:00
|
|
|
// Licensed under the Mozilla Public License (MPLv2)
|
|
|
|
|
//
|
2016-10-17 13:07:19 +02:00
|
|
|
/*global Backbone, define */
|
2016-02-16 08:46:47 +01:00
|
|
|
|
2016-02-13 23:58:50 +01:00
|
|
|
/* This is a Converse.js plugin which add support for multi-user chat rooms, as
|
|
|
|
|
* specified in XEP-0045 Multi-user chat.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
(function (root, factory) {
|
2017-02-13 15:37:17 +01:00
|
|
|
define([
|
2017-02-14 15:08:39 +01:00
|
|
|
"converse-core",
|
2016-09-23 10:54:55 +02:00
|
|
|
"tpl!chatarea",
|
|
|
|
|
"tpl!chatroom",
|
|
|
|
|
"tpl!chatroom_form",
|
|
|
|
|
"tpl!chatroom_nickname_form",
|
|
|
|
|
"tpl!chatroom_password_form",
|
|
|
|
|
"tpl!chatroom_sidebar",
|
2016-10-27 13:30:58 +02:00
|
|
|
"tpl!chatroom_toolbar",
|
2016-12-02 18:41:05 +01:00
|
|
|
"tpl!chatroom_head",
|
2016-09-23 10:54:55 +02:00
|
|
|
"tpl!chatrooms_tab",
|
|
|
|
|
"tpl!info",
|
|
|
|
|
"tpl!occupant",
|
|
|
|
|
"tpl!room_description",
|
|
|
|
|
"tpl!room_item",
|
|
|
|
|
"tpl!room_panel",
|
2017-02-14 11:19:01 +01:00
|
|
|
"awesomplete",
|
2016-06-09 11:01:54 +02:00
|
|
|
"converse-chatview"
|
2016-02-28 20:24:06 +01:00
|
|
|
], factory);
|
2016-09-23 10:54:55 +02:00
|
|
|
}(this, function (
|
2016-12-20 11:42:20 +01:00
|
|
|
converse,
|
2016-09-23 10:54:55 +02:00
|
|
|
tpl_chatarea,
|
|
|
|
|
tpl_chatroom,
|
|
|
|
|
tpl_chatroom_form,
|
|
|
|
|
tpl_chatroom_nickname_form,
|
|
|
|
|
tpl_chatroom_password_form,
|
|
|
|
|
tpl_chatroom_sidebar,
|
2016-10-27 13:30:58 +02:00
|
|
|
tpl_chatroom_toolbar,
|
2016-12-02 18:41:05 +01:00
|
|
|
tpl_chatroom_head,
|
2016-09-23 10:54:55 +02:00
|
|
|
tpl_chatrooms_tab,
|
|
|
|
|
tpl_info,
|
|
|
|
|
tpl_occupant,
|
|
|
|
|
tpl_room_description,
|
|
|
|
|
tpl_room_item,
|
2017-02-14 11:19:01 +01:00
|
|
|
tpl_room_panel,
|
|
|
|
|
Awesomplete
|
2016-09-23 10:54:55 +02:00
|
|
|
) {
|
2016-02-19 11:43:46 +01:00
|
|
|
"use strict";
|
2016-11-02 23:08:20 +01:00
|
|
|
var ROOMS_PANEL_ID = 'chatrooms';
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
// Strophe methods for building stanzas
|
2016-12-20 11:42:20 +01:00
|
|
|
var Strophe = converse.env.Strophe,
|
|
|
|
|
$iq = converse.env.$iq,
|
|
|
|
|
$build = converse.env.$build,
|
|
|
|
|
$msg = converse.env.$msg,
|
|
|
|
|
$pres = converse.env.$pres,
|
|
|
|
|
b64_sha1 = converse.env.b64_sha1,
|
|
|
|
|
utils = converse.env.utils;
|
2016-02-16 08:46:47 +01:00
|
|
|
// Other necessary globals
|
2016-12-20 11:42:20 +01:00
|
|
|
var $ = converse.env.jQuery,
|
|
|
|
|
_ = converse.env._,
|
|
|
|
|
moment = converse.env.moment;
|
2016-02-16 08:46:47 +01:00
|
|
|
|
|
|
|
|
// Add Strophe Namespaces
|
|
|
|
|
Strophe.addNamespace('MUC_ADMIN', Strophe.NS.MUC + "#admin");
|
|
|
|
|
Strophe.addNamespace('MUC_OWNER', Strophe.NS.MUC + "#owner");
|
|
|
|
|
Strophe.addNamespace('MUC_REGISTER', "jabber:iq:register");
|
|
|
|
|
Strophe.addNamespace('MUC_ROOMCONF', Strophe.NS.MUC + "#roomconfig");
|
|
|
|
|
Strophe.addNamespace('MUC_USER', Strophe.NS.MUC + "#user");
|
|
|
|
|
|
2016-12-20 11:42:20 +01:00
|
|
|
converse.plugins.add('converse-muc', {
|
2016-06-10 00:05:55 +02:00
|
|
|
/* Optional dependencies are other plugins which might be
|
|
|
|
|
* overridden or relied upon, if they exist, otherwise they're ignored.
|
2016-06-09 11:01:54 +02:00
|
|
|
*
|
|
|
|
|
* However, if the setting "strict_plugin_dependencies" is set to true,
|
2016-06-10 00:05:55 +02:00
|
|
|
* an error will be raised if the plugin is not found.
|
2016-06-09 11:01:54 +02:00
|
|
|
*
|
2016-06-10 00:05:55 +02:00
|
|
|
* NB: These plugins need to have already been loaded via require.js.
|
2016-06-09 11:01:54 +02:00
|
|
|
*/
|
|
|
|
|
optional_dependencies: ["converse-controlbox"],
|
2016-02-16 08:46:47 +01:00
|
|
|
|
|
|
|
|
overrides: {
|
|
|
|
|
// Overrides mentioned here will be picked up by converse.js's
|
|
|
|
|
// plugin architecture they will replace existing methods on the
|
|
|
|
|
// relevant objects or classes.
|
|
|
|
|
//
|
|
|
|
|
// New functions which don't exist yet can also be added.
|
2016-02-13 23:58:50 +01:00
|
|
|
|
|
|
|
|
Features: {
|
|
|
|
|
addClientFeatures: function () {
|
2017-02-02 19:29:38 +01:00
|
|
|
var _converse = this.__super__._converse;
|
2016-08-31 12:06:17 +02:00
|
|
|
this.__super__.addClientFeatures.apply(this, arguments);
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.allow_muc_invitations) {
|
|
|
|
|
_converse.connection.disco.addFeature('jabber:x:conference'); // Invites
|
2016-06-10 16:13:52 +02:00
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.allow_muc) {
|
|
|
|
|
_converse.connection.disco.addFeature(Strophe.NS.MUC);
|
2016-02-13 23:58:50 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
ControlBoxView: {
|
|
|
|
|
renderContactsPanel: function () {
|
2016-12-20 11:28:30 +01:00
|
|
|
var _converse = this.__super__._converse;
|
2016-08-31 12:06:17 +02:00
|
|
|
this.__super__.renderContactsPanel.apply(this, arguments);
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.allow_muc) {
|
|
|
|
|
this.roomspanel = new _converse.RoomsPanel({
|
2016-02-13 23:58:50 +01:00
|
|
|
'$parent': this.$el.find('.controlbox-panes'),
|
|
|
|
|
'model': new (Backbone.Model.extend({
|
2016-12-20 10:30:20 +01:00
|
|
|
id: b64_sha1('converse.roomspanel'+_converse.bare_jid), // Required by sessionStorage
|
|
|
|
|
browserStorage: new Backbone.BrowserStorage[_converse.storage](
|
|
|
|
|
b64_sha1('converse.roomspanel'+_converse.bare_jid))
|
2016-02-13 23:58:50 +01:00
|
|
|
}))()
|
|
|
|
|
});
|
|
|
|
|
this.roomspanel.render().model.fetch();
|
|
|
|
|
if (!this.roomspanel.model.get('nick')) {
|
|
|
|
|
this.roomspanel.model.save({
|
2016-12-20 10:30:20 +01:00
|
|
|
nick: Strophe.getNodeFromJid(_converse.bare_jid)
|
2016-02-13 23:58:50 +01:00
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onConnected: function () {
|
2016-12-20 11:28:30 +01:00
|
|
|
var _converse = this.__super__._converse;
|
2016-08-31 12:06:17 +02:00
|
|
|
this.__super__.onConnected.apply(this, arguments);
|
2016-10-27 10:08:05 +02:00
|
|
|
if (!this.model.get('connected')) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_.isUndefined(_converse.muc_domain)) {
|
|
|
|
|
_converse.features.off('add', this.featureAdded, this);
|
|
|
|
|
_converse.features.on('add', this.featureAdded, this);
|
2016-10-27 10:08:05 +02:00
|
|
|
// Features could have been added before the controlbox was
|
|
|
|
|
// initialized. We're only interested in MUC
|
2016-12-20 10:30:20 +01:00
|
|
|
var feature = _converse.features.findWhere({
|
2016-10-27 10:08:05 +02:00
|
|
|
'var': Strophe.NS.MUC
|
|
|
|
|
});
|
|
|
|
|
if (feature) {
|
|
|
|
|
this.featureAdded(feature);
|
2016-02-13 23:58:50 +01:00
|
|
|
}
|
2016-10-26 15:21:36 +02:00
|
|
|
} else {
|
2016-12-20 10:30:20 +01:00
|
|
|
this.setMUCDomain(_converse.muc_domain);
|
2016-10-26 15:21:36 +02:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
setMUCDomain: function (domain) {
|
|
|
|
|
this.roomspanel.model.save({'muc_domain': domain});
|
|
|
|
|
var $server= this.$el.find('input.new-chatroom-server');
|
|
|
|
|
if (!$server.is(':focus')) {
|
|
|
|
|
$server.val(this.roomspanel.model.get('muc_domain'));
|
2016-02-13 23:58:50 +01:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
featureAdded: function (feature) {
|
2016-12-20 11:28:30 +01:00
|
|
|
var _converse = this.__super__._converse;
|
2016-12-20 10:30:20 +01:00
|
|
|
if ((feature.get('var') === Strophe.NS.MUC) && (_converse.allow_muc)) {
|
2016-10-26 15:21:36 +02:00
|
|
|
this.setMUCDomain(feature.get('from'));
|
2016-02-13 23:58:50 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-28 20:24:06 +01:00
|
|
|
ChatBoxViews: {
|
|
|
|
|
onChatBoxAdded: function (item) {
|
2017-02-02 19:29:38 +01:00
|
|
|
var _converse = this.__super__._converse;
|
2016-02-28 20:24:06 +01:00
|
|
|
var view = this.get(item.get('id'));
|
2016-03-21 10:57:38 +01:00
|
|
|
if (!view && item.get('type') === 'chatroom') {
|
2016-12-20 10:30:20 +01:00
|
|
|
view = new _converse.ChatRoomView({'model': item});
|
2016-03-21 10:57:38 +01:00
|
|
|
return this.add(item.get('id'), view);
|
2016-02-28 20:24:06 +01:00
|
|
|
} else {
|
2016-08-31 12:06:17 +02:00
|
|
|
return this.__super__.onChatBoxAdded.apply(this, arguments);
|
2016-02-28 20:24:06 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
initialize: function () {
|
|
|
|
|
/* The initialize function gets called as soon as the plugin is
|
|
|
|
|
* loaded by converse.js's plugin machinery.
|
|
|
|
|
*/
|
2017-02-02 19:29:38 +01:00
|
|
|
var _converse = this._converse,
|
|
|
|
|
__ = _converse.__,
|
|
|
|
|
___ = _converse.___;
|
|
|
|
|
|
|
|
|
|
_converse.templates.chatarea = tpl_chatarea;
|
|
|
|
|
_converse.templates.chatroom = tpl_chatroom;
|
|
|
|
|
_converse.templates.chatroom_form = tpl_chatroom_form;
|
|
|
|
|
_converse.templates.chatroom_nickname_form = tpl_chatroom_nickname_form;
|
|
|
|
|
_converse.templates.chatroom_password_form = tpl_chatroom_password_form;
|
|
|
|
|
_converse.templates.chatroom_sidebar = tpl_chatroom_sidebar;
|
|
|
|
|
_converse.templates.chatroom_head = tpl_chatroom_head;
|
|
|
|
|
_converse.templates.chatrooms_tab = tpl_chatrooms_tab;
|
|
|
|
|
_converse.templates.info = tpl_info;
|
|
|
|
|
_converse.templates.occupant = tpl_occupant;
|
|
|
|
|
_converse.templates.room_description = tpl_room_description;
|
|
|
|
|
_converse.templates.room_item = tpl_room_item;
|
|
|
|
|
_converse.templates.room_panel = tpl_room_panel;
|
|
|
|
|
|
2016-12-04 17:53:35 +01:00
|
|
|
// XXX: Inside plugins, all calls to the translation machinery
|
|
|
|
|
// (e.g. utils.__) should only be done in the initialize function.
|
|
|
|
|
// If called before, we won't know what language the user wants,
|
|
|
|
|
// and it'll fallback to English.
|
|
|
|
|
|
|
|
|
|
/* http://xmpp.org/extensions/xep-0045.html
|
|
|
|
|
* ----------------------------------------
|
|
|
|
|
* 100 message Entering a room Inform user that any occupant is allowed to see the user's full JID
|
|
|
|
|
* 101 message (out of band) Affiliation change Inform user that his or her affiliation changed while not in the room
|
|
|
|
|
* 102 message Configuration change Inform occupants that room now shows unavailable members
|
|
|
|
|
* 103 message Configuration change Inform occupants that room now does not show unavailable members
|
|
|
|
|
* 104 message Configuration change Inform occupants that a non-privacy-related room configuration change has occurred
|
|
|
|
|
* 110 presence Any room presence Inform user that presence refers to one of its own room occupants
|
|
|
|
|
* 170 message or initial presence Configuration change Inform occupants that room logging is now enabled
|
|
|
|
|
* 171 message Configuration change Inform occupants that room logging is now disabled
|
|
|
|
|
* 172 message Configuration change Inform occupants that the room is now non-anonymous
|
|
|
|
|
* 173 message Configuration change Inform occupants that the room is now semi-anonymous
|
|
|
|
|
* 174 message Configuration change Inform occupants that the room is now fully-anonymous
|
|
|
|
|
* 201 presence Entering a room Inform user that a new room has been created
|
|
|
|
|
* 210 presence Entering a room Inform user that the service has assigned or modified the occupant's roomnick
|
|
|
|
|
* 301 presence Removal from room Inform user that he or she has been banned from the room
|
|
|
|
|
* 303 presence Exiting a room Inform all occupants of new room nickname
|
|
|
|
|
* 307 presence Removal from room Inform user that he or she has been kicked from the room
|
|
|
|
|
* 321 presence Removal from room Inform user that he or she is being removed from the room because of an affiliation change
|
|
|
|
|
* 322 presence Removal from room Inform user that he or she is being removed from the room because the room has been changed to members-only and the user is not a member
|
|
|
|
|
* 332 presence Removal from room Inform user that he or she is being removed from the room because of a system shutdown
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.muc = {
|
2016-12-04 17:53:35 +01:00
|
|
|
info_messages: {
|
|
|
|
|
100: __('This room is not anonymous'),
|
|
|
|
|
102: __('This room now shows unavailable members'),
|
|
|
|
|
103: __('This room does not show unavailable members'),
|
|
|
|
|
104: __('The room configuration has changed'),
|
|
|
|
|
170: __('Room logging is now enabled'),
|
|
|
|
|
171: __('Room logging is now disabled'),
|
|
|
|
|
172: __('This room is now no longer anonymous'),
|
|
|
|
|
173: __('This room is now semi-anonymous'),
|
|
|
|
|
174: __('This room is now fully-anonymous'),
|
|
|
|
|
201: __('A new room has been created')
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
disconnect_messages: {
|
|
|
|
|
301: __('You have been banned from this room'),
|
|
|
|
|
307: __('You have been kicked from this room'),
|
|
|
|
|
321: __("You have been removed from this room because of an affiliation change"),
|
|
|
|
|
322: __("You have been removed from this room because the room has changed to members-only and you're not a member"),
|
|
|
|
|
332: __("You have been removed from this room because the MUC (Multi-user chat) service is being shut down.")
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
action_info_messages: {
|
|
|
|
|
/* XXX: Note the triple underscore function and not double
|
|
|
|
|
* underscore.
|
|
|
|
|
*
|
|
|
|
|
* This is a hack. We can't pass the strings to __ because we
|
|
|
|
|
* don't yet know what the variable to interpolate is.
|
|
|
|
|
*
|
|
|
|
|
* Triple underscore will just return the string again, but we
|
|
|
|
|
* can then at least tell gettext to scan for it so that these
|
|
|
|
|
* strings are picked up by the translation machinery.
|
|
|
|
|
*/
|
2017-02-13 09:23:42 +01:00
|
|
|
301: ___("%1$s has been banned"),
|
|
|
|
|
303: ___("%1$s's nickname has changed"),
|
|
|
|
|
307: ___("%1$s has been kicked out"),
|
|
|
|
|
321: ___("%1$s has been removed because of an affiliation change"),
|
|
|
|
|
322: ___("%1$s has been removed for not being a member")
|
2016-12-04 17:53:35 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
new_nickname_messages: {
|
2017-02-13 09:23:42 +01:00
|
|
|
210: ___('Your nickname has been automatically set to: %1$s'),
|
|
|
|
|
303: ___('Your nickname has been changed to: %1$s')
|
2016-12-04 17:53:35 +01:00
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
// Configuration values for this plugin
|
2016-08-11 18:03:02 +02:00
|
|
|
// ====================================
|
|
|
|
|
// Refer to docs/source/configuration.rst for explanations of these
|
|
|
|
|
// configuration settings.
|
2016-03-13 17:16:53 +01:00
|
|
|
this.updateSettings({
|
2016-02-13 23:58:50 +01:00
|
|
|
allow_muc: true,
|
2016-08-11 18:03:02 +02:00
|
|
|
allow_muc_invitations: true,
|
|
|
|
|
auto_join_on_invite: false,
|
|
|
|
|
auto_join_rooms: [],
|
2016-03-17 13:24:26 +01:00
|
|
|
auto_list_rooms: false,
|
2016-02-19 10:36:01 +01:00
|
|
|
hide_muc_server: false,
|
2016-12-07 14:48:47 +01:00
|
|
|
muc_disable_moderator_commands: false,
|
2016-10-26 15:21:36 +02:00
|
|
|
muc_domain: undefined,
|
2016-08-11 18:03:02 +02:00
|
|
|
muc_history_max_stanzas: undefined,
|
|
|
|
|
muc_instant_rooms: true,
|
2016-10-27 13:30:58 +02:00
|
|
|
muc_nickname_from_jid: false,
|
|
|
|
|
visible_toolbar_buttons: {
|
|
|
|
|
'toggle_occupants': true
|
|
|
|
|
},
|
2016-03-13 17:16:53 +01:00
|
|
|
});
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.createChatRoom = function (settings) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Creates a new chat room, making sure that certain attributes
|
|
|
|
|
* are correct, for example that the "type" is set to
|
|
|
|
|
* "chatroom".
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
return _converse.chatboxviews.showChat(
|
2016-12-02 18:41:05 +01:00
|
|
|
_.extend(settings, {
|
|
|
|
|
'type': 'chatroom',
|
2016-12-05 07:03:44 +01:00
|
|
|
'affiliation': null,
|
|
|
|
|
'features_fetched': false,
|
|
|
|
|
'hidden': false,
|
|
|
|
|
'membersonly': false,
|
|
|
|
|
'moderated': false,
|
|
|
|
|
'nonanonymous': false,
|
|
|
|
|
'open': false,
|
|
|
|
|
'passwordprotected': false,
|
|
|
|
|
'persistent': false,
|
|
|
|
|
'public': false,
|
|
|
|
|
'semianonymous': false,
|
|
|
|
|
'temporary': false,
|
|
|
|
|
'unmoderated': false,
|
|
|
|
|
'unsecured': false,
|
|
|
|
|
'connection_status': Strophe.Status.DISCONNECTED
|
2016-12-02 18:41:05 +01:00
|
|
|
})
|
|
|
|
|
);
|
|
|
|
|
};
|
2016-02-16 08:46:47 +01:00
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatRoomView = _converse.ChatBoxView.extend({
|
2016-02-16 08:46:47 +01:00
|
|
|
/* Backbone View which renders a chat room, based upon the view
|
2016-03-19 23:16:00 +01:00
|
|
|
* for normal one-on-one chat boxes.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
length: 300,
|
|
|
|
|
tagName: 'div',
|
2016-11-22 17:42:58 +01:00
|
|
|
className: 'chatbox chatroom hidden',
|
2016-03-20 00:03:00 +01:00
|
|
|
is_chatroom: true,
|
2016-02-16 08:46:47 +01:00
|
|
|
events: {
|
|
|
|
|
'click .close-chatbox-button': 'close',
|
|
|
|
|
'click .configure-chatroom-button': 'configureChatRoom',
|
|
|
|
|
'click .toggle-smiley': 'toggleEmoticonMenu',
|
|
|
|
|
'click .toggle-smiley ul li': 'insertEmoticon',
|
|
|
|
|
'click .toggle-clear': 'clearChatRoomMessages',
|
|
|
|
|
'click .toggle-call': 'toggleCall',
|
|
|
|
|
'click .toggle-occupants a': 'toggleOccupants',
|
2016-05-30 11:45:39 +02:00
|
|
|
'click .new-msgs-indicator': 'viewUnreadMessages',
|
2016-07-26 11:04:05 +02:00
|
|
|
'click .occupant': 'onOccupantClicked',
|
2016-10-28 15:31:53 +02:00
|
|
|
'keypress .chat-textarea': 'keyPressed'
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
initialize: function () {
|
2016-12-05 07:03:44 +01:00
|
|
|
var that = this;
|
2016-02-16 08:46:47 +01:00
|
|
|
this.model.messages.on('add', this.onMessageAdded, this);
|
2016-04-05 13:23:16 +02:00
|
|
|
this.model.on('show', this.show, this);
|
|
|
|
|
this.model.on('destroy', this.hide, this);
|
2016-08-12 16:40:04 +02:00
|
|
|
this.model.on('change:chat_state', this.sendChatState, this);
|
2016-12-02 18:41:05 +01:00
|
|
|
this.model.on('change:affiliation', this.renderHeading, this);
|
|
|
|
|
this.model.on('change:name', this.renderHeading, this);
|
2016-04-05 13:23:16 +02:00
|
|
|
|
2016-12-04 13:32:14 +01:00
|
|
|
this.createOccupantsView();
|
2016-12-05 07:03:44 +01:00
|
|
|
this.render().insertIntoDOM(); // TODO: hide chat area until messages received.
|
|
|
|
|
// XXX: adding the event below to the declarative events map doesn't work.
|
2016-05-25 15:14:12 +02:00
|
|
|
// The code that gets executed because of that looks like this:
|
|
|
|
|
// this.$el.on('scroll', '.chat-content', this.markScrolled.bind(this));
|
|
|
|
|
// Which for some reason doesn't work.
|
|
|
|
|
// So working around that fact here:
|
|
|
|
|
this.$el.find('.chat-content').on('scroll', this.markScrolled.bind(this));
|
2016-12-05 07:03:44 +01:00
|
|
|
|
|
|
|
|
this.getRoomFeatures().always(function () {
|
2016-12-09 20:15:16 +01:00
|
|
|
that.join();
|
|
|
|
|
that.fetchMessages();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.emit('chatRoomOpened', that);
|
2016-12-05 07:03:44 +01:00
|
|
|
});
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-04 13:32:14 +01:00
|
|
|
createOccupantsView: function () {
|
|
|
|
|
/* Create the ChatRoomOccupantsView Backbone.View
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
this.occupantsview = new _converse.ChatRoomOccupantsView({
|
|
|
|
|
model: new _converse.ChatRoomOccupants()
|
2016-12-04 13:32:14 +01:00
|
|
|
});
|
2016-12-20 10:30:20 +01:00
|
|
|
var id = b64_sha1('converse.occupants'+_converse.bare_jid+this.model.get('jid'));
|
2016-12-04 13:32:14 +01:00
|
|
|
this.occupantsview.model.browserStorage = new Backbone.BrowserStorage.session(id);
|
|
|
|
|
this.occupantsview.chatroomview = this;
|
|
|
|
|
this.occupantsview.render();
|
|
|
|
|
this.occupantsview.model.fetch({add:true});
|
|
|
|
|
},
|
|
|
|
|
|
2016-06-03 13:56:00 +02:00
|
|
|
insertIntoDOM: function () {
|
2016-12-20 10:30:20 +01:00
|
|
|
var view = _converse.chatboxviews.get("controlbox");
|
2016-06-16 17:15:27 +02:00
|
|
|
if (view) {
|
|
|
|
|
this.$el.insertAfter(view.$el);
|
2016-06-03 18:47:23 +02:00
|
|
|
} else {
|
|
|
|
|
$('#conversejs').prepend(this.$el);
|
|
|
|
|
}
|
2016-06-03 13:56:00 +02:00
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
render: function () {
|
|
|
|
|
this.$el.attr('id', this.model.get('box_id'))
|
2016-12-20 10:30:20 +01:00
|
|
|
.html(_converse.templates.chatroom());
|
2016-12-02 18:41:05 +01:00
|
|
|
this.renderHeading();
|
2016-02-16 08:46:47 +01:00
|
|
|
this.renderChatArea();
|
2016-10-17 13:07:19 +02:00
|
|
|
utils.refreshWebkit();
|
2016-02-16 08:46:47 +01:00
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-02 18:41:05 +01:00
|
|
|
generateHeadingHTML: function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Pure function which returns the heading HTML to be
|
|
|
|
|
* rendered.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
return _converse.templates.chatroom_head(
|
2016-12-02 18:41:05 +01:00
|
|
|
_.extend(this.model.toJSON(), {
|
|
|
|
|
info_close: __('Close and leave this room'),
|
|
|
|
|
info_configure: __('Configure this room'),
|
|
|
|
|
}));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
renderHeading: function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Render the heading UI of the chat room.
|
|
|
|
|
*/
|
2016-12-02 18:41:05 +01:00
|
|
|
this.el.querySelector('.chat-head-chatroom').innerHTML = this.generateHeadingHTML();
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
renderChatArea: function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Render the UI container in which chat room messages will
|
|
|
|
|
* appear.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
if (!this.$('.chat-area').length) {
|
|
|
|
|
this.$('.chatroom-body').empty()
|
|
|
|
|
.append(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.chatarea({
|
2016-05-28 10:55:03 +02:00
|
|
|
'unread_msgs': __('You have unread messages'),
|
2016-12-20 10:30:20 +01:00
|
|
|
'show_toolbar': _converse.show_toolbar,
|
2016-02-16 08:46:47 +01:00
|
|
|
'label_message': __('Message')
|
|
|
|
|
}))
|
2016-12-04 13:32:14 +01:00
|
|
|
.append(this.occupantsview.$el);
|
2016-10-27 13:30:58 +02:00
|
|
|
this.renderToolbar(tpl_chatroom_toolbar);
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$content = this.$el.find('.chat-content');
|
|
|
|
|
}
|
|
|
|
|
this.toggleOccupants(null, true);
|
|
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2017-02-15 21:30:32 +01:00
|
|
|
getExtraMessageClasses: function (attrs) {
|
|
|
|
|
var extra_classes = _converse.ChatBoxView.prototype
|
|
|
|
|
.getExtraMessageClasses.apply(this, arguments);
|
|
|
|
|
|
|
|
|
|
if (this.is_chatroom && attrs.sender === 'them' &&
|
|
|
|
|
(new RegExp("\\b"+this.model.get('nick')+"\\b")).test(attrs.message)
|
|
|
|
|
) {
|
|
|
|
|
// Add special class to mark groupchat messages
|
|
|
|
|
// in which we are mentioned.
|
|
|
|
|
extra_classes += ' mentioned';
|
|
|
|
|
}
|
|
|
|
|
return extra_classes;
|
|
|
|
|
},
|
|
|
|
|
|
2016-10-27 13:30:58 +02:00
|
|
|
getToolbarOptions: function () {
|
|
|
|
|
return _.extend(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatBoxView.prototype.getToolbarOptions.apply(this, arguments),
|
2016-10-27 13:30:58 +02:00
|
|
|
{
|
|
|
|
|
label_hide_occupants: __('Hide the list of occupants'),
|
2016-12-20 10:30:20 +01:00
|
|
|
show_occupants_toggle: this.is_chatroom && _converse.visible_toolbar_buttons.toggle_occupants
|
2016-10-27 13:30:58 +02:00
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
2016-03-28 13:42:33 +02:00
|
|
|
close: function (ev) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Close this chat box, which implies leaving the room as
|
|
|
|
|
* well.
|
|
|
|
|
*/
|
2016-03-28 13:42:33 +02:00
|
|
|
this.leave();
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
toggleOccupants: function (ev, preserve_state) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Show or hide the right sidebar containing the chat
|
|
|
|
|
* occupants (and the invite widget).
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
if (ev) {
|
|
|
|
|
ev.preventDefault();
|
|
|
|
|
ev.stopPropagation();
|
|
|
|
|
}
|
|
|
|
|
if (preserve_state) {
|
|
|
|
|
// Bit of a hack, to make sure that the sidebar's state doesn't change
|
|
|
|
|
this.model.set({hidden_occupants: !this.model.get('hidden_occupants')});
|
|
|
|
|
}
|
|
|
|
|
if (!this.model.get('hidden_occupants')) {
|
|
|
|
|
this.model.save({hidden_occupants: true});
|
2016-06-10 17:05:49 +02:00
|
|
|
this.$('.icon-hide-users').removeClass('icon-hide-users').addClass('icon-show-users');
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$('.occupants').addClass('hidden');
|
|
|
|
|
this.$('.chat-area').addClass('full');
|
|
|
|
|
this.scrollDown();
|
|
|
|
|
} else {
|
|
|
|
|
this.model.save({hidden_occupants: false});
|
2016-06-10 17:05:49 +02:00
|
|
|
this.$('.icon-show-users').removeClass('icon-show-users').addClass('icon-hide-users');
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$('.chat-area').removeClass('full');
|
|
|
|
|
this.$('div.occupants').removeClass('hidden');
|
|
|
|
|
this.scrollDown();
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-26 11:04:05 +02:00
|
|
|
onOccupantClicked: function (ev) {
|
|
|
|
|
/* When an occupant is clicked, insert their nickname into
|
|
|
|
|
* the chat textarea input.
|
|
|
|
|
*/
|
|
|
|
|
this.insertIntoTextArea(ev.target.textContent);
|
|
|
|
|
},
|
|
|
|
|
|
2017-01-26 15:49:02 +01:00
|
|
|
requestMemberList: function (chatroom_jid, affiliation) {
|
2016-12-06 16:18:33 +01:00
|
|
|
/* Send an IQ stanza to the server, asking it for the
|
|
|
|
|
* member-list of this room.
|
|
|
|
|
*
|
|
|
|
|
* See: http://xmpp.org/extensions/xep-0045.html#modifymember
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
2017-01-26 15:49:02 +01:00
|
|
|
* (String) chatroom_jid: The JID of the chatroom for
|
|
|
|
|
* which the member-list is being requested
|
2016-12-06 19:34:54 +01:00
|
|
|
* (String) affiliation: The specific member list to
|
|
|
|
|
* fetch. 'admin', 'owner' or 'member'.
|
2016-12-06 16:18:33 +01:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A promise which resolves once the list has been
|
|
|
|
|
* retrieved.
|
|
|
|
|
*/
|
|
|
|
|
var deferred = new $.Deferred();
|
2016-12-06 19:34:54 +01:00
|
|
|
affiliation = affiliation || 'member';
|
2017-01-26 15:49:02 +01:00
|
|
|
var iq = $iq({to: chatroom_jid, type: "get"})
|
2016-12-06 16:18:33 +01:00
|
|
|
.c("query", {xmlns: Strophe.NS.MUC_ADMIN})
|
2016-12-06 19:34:54 +01:00
|
|
|
.c("item", {'affiliation': affiliation});
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.sendIQ(iq, deferred.resolve, deferred.reject);
|
2016-12-06 16:18:33 +01:00
|
|
|
return deferred.promise();
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
parseMemberListIQ: function (iq) {
|
|
|
|
|
/* Given an IQ stanza with a member list, create an array of member
|
|
|
|
|
* objects.
|
|
|
|
|
*/
|
|
|
|
|
return _.map(
|
|
|
|
|
$(iq).find('query[xmlns="'+Strophe.NS.MUC_ADMIN+'"] item'),
|
|
|
|
|
function (item) {
|
|
|
|
|
return {
|
|
|
|
|
'jid': item.getAttribute('jid'),
|
|
|
|
|
'affiliation': item.getAttribute('affiliation'),
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-07 12:30:28 +01:00
|
|
|
computeAffiliationsDelta: function (exclude_existing, remove_absentees, new_list, old_list) {
|
|
|
|
|
/* Given two lists of objects with 'jid', 'affiliation' and
|
|
|
|
|
* 'reason' properties, return a new list containing
|
|
|
|
|
* those objects that are new, changed or removed
|
2016-12-06 16:18:33 +01:00
|
|
|
* (depending on the 'remove_absentees' boolean).
|
|
|
|
|
*
|
2016-12-06 20:39:16 +01:00
|
|
|
* The affiliations for new and changed members stay the
|
|
|
|
|
* same, for removed members, the affiliation is set to 'none'.
|
2016-12-06 16:18:33 +01:00
|
|
|
*
|
2016-12-07 12:30:28 +01:00
|
|
|
* The 'reason' property is not taken into account when
|
|
|
|
|
* comparing whether affiliations have been changed.
|
|
|
|
|
*
|
2016-12-06 16:18:33 +01:00
|
|
|
* Parameters:
|
2016-12-06 21:04:08 +01:00
|
|
|
* (Boolean) exclude_existing: Indicates whether JIDs from
|
2016-12-07 12:30:28 +01:00
|
|
|
* the new list which are also in the old list
|
2016-12-06 21:04:08 +01:00
|
|
|
* (regardless of affiliation) should be excluded
|
|
|
|
|
* from the delta. One reason to do this
|
|
|
|
|
* would be when you want to add a JID only if it
|
|
|
|
|
* doesn't have *any* existing affiliation at all.
|
2016-12-06 20:39:16 +01:00
|
|
|
* (Boolean) remove_absentees: Indicates whether JIDs
|
2016-12-07 12:30:28 +01:00
|
|
|
* from the old list which are not in the new list
|
2016-12-06 20:39:16 +01:00
|
|
|
* should be considered removed and therefore be
|
|
|
|
|
* included in the delta with affiliation set
|
|
|
|
|
* to 'none'.
|
2016-12-07 12:30:28 +01:00
|
|
|
* (Array) new_list: Array containing the new affiliations
|
|
|
|
|
* (Array) old_list: Array containing the old affiliations
|
2016-12-06 16:18:33 +01:00
|
|
|
*/
|
2017-01-26 15:49:02 +01:00
|
|
|
var new_jids = _.map(new_list, 'jid');
|
|
|
|
|
var old_jids = _.map(old_list, 'jid');
|
2016-12-07 12:30:28 +01:00
|
|
|
|
2016-12-06 20:39:16 +01:00
|
|
|
// Get the new affiliations
|
2016-12-07 12:30:28 +01:00
|
|
|
var delta = _.map(_.difference(new_jids, old_jids), function (jid) {
|
|
|
|
|
return new_list[_.indexOf(new_jids, jid)];
|
2016-12-06 20:39:16 +01:00
|
|
|
});
|
2016-12-06 21:04:08 +01:00
|
|
|
if (!exclude_existing) {
|
|
|
|
|
// Get the changed affiliations
|
2016-12-07 14:02:03 +01:00
|
|
|
delta = delta.concat(_.filter(new_list, function (item) {
|
|
|
|
|
var idx = _.indexOf(old_jids, item.jid);
|
2016-12-07 12:30:28 +01:00
|
|
|
if (idx >= 0) {
|
2016-12-07 14:02:03 +01:00
|
|
|
return item.affiliation !== old_list[idx].affiliation;
|
2016-12-06 21:04:08 +01:00
|
|
|
}
|
2016-12-07 12:30:28 +01:00
|
|
|
return false;
|
|
|
|
|
}));
|
2016-12-06 21:04:08 +01:00
|
|
|
}
|
2016-12-06 16:18:33 +01:00
|
|
|
if (remove_absentees) {
|
2016-12-06 20:39:16 +01:00
|
|
|
// Get the removed affiliations
|
2016-12-07 14:02:03 +01:00
|
|
|
delta = delta.concat(_.map(_.difference(old_jids, new_jids), function (jid) {
|
2016-12-07 12:30:28 +01:00
|
|
|
return {'jid': jid, 'affiliation': 'none'};
|
2016-12-07 14:02:03 +01:00
|
|
|
}));
|
2016-12-06 16:18:33 +01:00
|
|
|
}
|
2016-12-06 20:39:16 +01:00
|
|
|
return delta;
|
2016-12-06 16:18:33 +01:00
|
|
|
},
|
|
|
|
|
|
2017-01-26 15:49:02 +01:00
|
|
|
sendAffiliationIQ: function (chatroom_jid, affiliation, member) {
|
|
|
|
|
/* Send an IQ stanza specifying an affiliation change.
|
|
|
|
|
*
|
|
|
|
|
* Paremeters:
|
|
|
|
|
* (String) chatroom_jid: JID of the relevant room
|
|
|
|
|
* (String) affiliation: affiliation (could also be stored
|
|
|
|
|
* on the member object).
|
|
|
|
|
* (Object) member: Map containing the member's jid and
|
|
|
|
|
* optionally a reason and affiliation.
|
|
|
|
|
*/
|
|
|
|
|
var deferred = new $.Deferred();
|
|
|
|
|
var iq = $iq({to: chatroom_jid, type: "set"})
|
|
|
|
|
.c("query", {xmlns: Strophe.NS.MUC_ADMIN})
|
|
|
|
|
.c("item", {
|
|
|
|
|
'affiliation': member.affiliation || affiliation,
|
|
|
|
|
'jid': member.jid
|
|
|
|
|
});
|
|
|
|
|
if (!_.isUndefined(member.reason)) {
|
|
|
|
|
iq.c("reason", member.reason);
|
|
|
|
|
}
|
2016-12-23 05:38:08 +01:00
|
|
|
_converse.connection.sendIQ(iq, deferred.resolve, deferred.reject);
|
2017-01-26 15:49:02 +01:00
|
|
|
return deferred;
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-08 08:28:20 +01:00
|
|
|
setAffiliation: function (affiliation, members) {
|
2016-12-09 20:11:16 +01:00
|
|
|
/* Send IQ stanzas to the server to set an affiliation for
|
|
|
|
|
* the provided JIDs.
|
2016-12-08 08:28:20 +01:00
|
|
|
*
|
|
|
|
|
* See: http://xmpp.org/extensions/xep-0045.html#modifymember
|
|
|
|
|
*
|
2016-12-09 20:11:16 +01:00
|
|
|
* XXX: Prosody doesn't accept multiple JIDs' affiliations
|
|
|
|
|
* being set in one IQ stanza, so as a workaround we send
|
|
|
|
|
* a separate stanza for each JID.
|
|
|
|
|
* Related ticket: https://prosody.im/issues/issue/795
|
|
|
|
|
*
|
2016-12-08 08:28:20 +01:00
|
|
|
* Parameters:
|
2017-01-26 15:49:02 +01:00
|
|
|
* (String) affiliation: The affiliation
|
2016-12-08 08:28:20 +01:00
|
|
|
* (Object) members: A map of jids, affiliations and
|
|
|
|
|
* optionally reasons. Only those entries with the
|
|
|
|
|
* same affiliation as being currently set will be
|
|
|
|
|
* considered.
|
|
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A promise which resolves and fails depending on the
|
|
|
|
|
* XMPP server response.
|
|
|
|
|
*/
|
2016-12-09 20:11:16 +01:00
|
|
|
members = _.filter(members, function (member) {
|
|
|
|
|
// We only want those members who have the right
|
|
|
|
|
// affiliation (or none, which implies the provided
|
|
|
|
|
// one).
|
|
|
|
|
return _.isUndefined(member.affiliation) ||
|
|
|
|
|
member.affiliation === affiliation;
|
|
|
|
|
});
|
2017-01-26 15:49:02 +01:00
|
|
|
var promises = _.map(
|
|
|
|
|
members,
|
|
|
|
|
_.partial(this.sendAffiliationIQ, this.model.get('jid'), affiliation)
|
|
|
|
|
);
|
|
|
|
|
return $.when.apply($, promises);
|
2016-12-08 08:28:20 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-06 19:34:54 +01:00
|
|
|
setAffiliations: function (members, onSuccess, onError) {
|
2016-12-08 08:28:20 +01:00
|
|
|
/* Send IQ stanzas to the server to modify the
|
2016-12-06 19:34:54 +01:00
|
|
|
* affiliations in this room.
|
2016-12-05 11:50:01 +01:00
|
|
|
*
|
|
|
|
|
* See: http://xmpp.org/extensions/xep-0045.html#modifymember
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
2016-12-08 08:28:20 +01:00
|
|
|
* (Object) members: A map of jids, affiliations and optionally reasons
|
2016-12-05 11:50:01 +01:00
|
|
|
* (Function) onSuccess: callback for a succesful response
|
|
|
|
|
* (Function) onError: callback for an error response
|
|
|
|
|
*/
|
2016-12-06 20:39:16 +01:00
|
|
|
if (_.isEmpty(members)) {
|
2016-12-06 19:34:54 +01:00
|
|
|
// Succesfully updated with zero affilations :)
|
2016-12-06 16:18:33 +01:00
|
|
|
onSuccess(null);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2017-01-26 15:49:02 +01:00
|
|
|
var affiliations = _.uniq(_.map(members, 'affiliation'));
|
|
|
|
|
var promises = _.map(affiliations, _.partial(this.setAffiliation.bind(this), _, members));
|
2016-12-08 08:28:20 +01:00
|
|
|
$.when.apply($, promises).done(onSuccess).fail(onError);
|
2016-12-05 11:50:01 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-07 12:30:28 +01:00
|
|
|
marshallAffiliationIQs: function () {
|
2016-12-07 11:34:02 +01:00
|
|
|
/* Marshall a list of IQ stanzas into a map of JIDs and
|
|
|
|
|
* affiliations.
|
2016-12-07 12:30:28 +01:00
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* Any amount of XMLElement objects, representing the IQ
|
|
|
|
|
* stanzas.
|
2016-12-07 11:34:02 +01:00
|
|
|
*/
|
2017-01-26 15:49:02 +01:00
|
|
|
return _.flatMap(arguments, this.parseMemberListIQ);
|
2016-12-07 11:34:02 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-06 21:04:08 +01:00
|
|
|
getJidsWithAffiliations: function (affiliations) {
|
|
|
|
|
/* Returns a map of JIDs that have the affiliations
|
|
|
|
|
* as provided.
|
|
|
|
|
*/
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isString(affiliations)) {
|
2016-12-06 21:04:08 +01:00
|
|
|
affiliations = [affiliations];
|
|
|
|
|
}
|
|
|
|
|
var deferred = new $.Deferred();
|
2017-01-26 15:49:02 +01:00
|
|
|
var promises = _.map(affiliations, _.partial(this.requestMemberList, this.model.get('jid')));
|
2016-12-07 11:34:02 +01:00
|
|
|
$.when.apply($, promises).always(
|
2017-01-26 15:49:02 +01:00
|
|
|
_.flow(this.marshallAffiliationIQs.bind(this), deferred.resolve)
|
2016-12-07 11:34:02 +01:00
|
|
|
);
|
2016-12-06 21:04:08 +01:00
|
|
|
return deferred.promise();
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
updateMemberLists: function (members, affiliations, deltaFunc) {
|
2016-12-06 20:39:16 +01:00
|
|
|
/* Fetch the lists of users with the given affiliations.
|
|
|
|
|
* Then compute the delta between those users and
|
2016-12-06 16:18:33 +01:00
|
|
|
* the passed in members, and if it exists, send the delta
|
|
|
|
|
* to the XMPP server to update the member list.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
2016-12-06 20:39:16 +01:00
|
|
|
* (Object) members: Map of member jids and affiliations.
|
2016-12-06 19:34:54 +01:00
|
|
|
* (String|Array) affiliation: An array of affiliations or
|
|
|
|
|
* a string if only one affiliation.
|
2016-12-06 21:04:08 +01:00
|
|
|
* (Function) deltaFunc: The function to compute the delta
|
|
|
|
|
* between old and new member lists.
|
2016-12-06 16:18:33 +01:00
|
|
|
*
|
|
|
|
|
* Returns:
|
|
|
|
|
* A promise which is resolved once the list has been
|
|
|
|
|
* updated or once it's been established there's no need
|
|
|
|
|
* to update the list.
|
|
|
|
|
*/
|
2016-12-06 19:34:54 +01:00
|
|
|
var that = this;
|
2016-12-06 16:18:33 +01:00
|
|
|
var deferred = new $.Deferred();
|
2016-12-06 21:04:08 +01:00
|
|
|
this.getJidsWithAffiliations(affiliations).then(function (old_members) {
|
|
|
|
|
that.setAffiliations(
|
|
|
|
|
deltaFunc(members, old_members),
|
|
|
|
|
deferred.resolve,
|
|
|
|
|
deferred.reject
|
|
|
|
|
);
|
2016-12-06 19:34:54 +01:00
|
|
|
});
|
2016-12-06 16:18:33 +01:00
|
|
|
return deferred.promise();
|
|
|
|
|
},
|
|
|
|
|
|
2016-03-01 23:26:36 +01:00
|
|
|
directInvite: function (recipient, reason) {
|
2016-12-03 17:39:59 +01:00
|
|
|
/* Send a direct invitation as per XEP-0249
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (String) recipient - JID of the person being invited
|
|
|
|
|
* (String) reason - Optional reason for the invitation
|
|
|
|
|
*/
|
2016-12-05 11:50:01 +01:00
|
|
|
if (this.model.get('membersonly')) {
|
|
|
|
|
// When inviting to a members-only room, we first add
|
2016-12-06 21:04:08 +01:00
|
|
|
// the person to the member list by giving them an
|
|
|
|
|
// affiliation of 'member' (if they're not affiliated
|
|
|
|
|
// already), otherwise they won't be able to join.
|
|
|
|
|
var map = {}; map[recipient] = 'member';
|
|
|
|
|
var deltaFunc = _.partial(this.computeAffiliationsDelta, true, false);
|
2016-12-07 12:30:28 +01:00
|
|
|
this.updateMemberLists(
|
|
|
|
|
[{'jid': recipient, 'affiliation': 'member', 'reason': reason}],
|
|
|
|
|
['member', 'owner', 'admin'],
|
|
|
|
|
deltaFunc
|
|
|
|
|
);
|
2016-12-05 11:50:01 +01:00
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
var attrs = {
|
2016-12-03 17:39:59 +01:00
|
|
|
'xmlns': 'jabber:x:conference',
|
|
|
|
|
'jid': this.model.get('jid')
|
2016-02-16 08:46:47 +01:00
|
|
|
};
|
|
|
|
|
if (reason !== null) { attrs.reason = reason; }
|
|
|
|
|
if (this.model.get('password')) { attrs.password = this.model.get('password'); }
|
|
|
|
|
var invitation = $msg({
|
2016-12-20 10:30:20 +01:00
|
|
|
from: _converse.connection.jid,
|
2016-03-01 23:26:36 +01:00
|
|
|
to: recipient,
|
2016-12-20 10:30:20 +01:00
|
|
|
id: _converse.connection.getUniqueId()
|
2016-02-16 08:46:47 +01:00
|
|
|
}).c('x', attrs);
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.send(invitation);
|
|
|
|
|
_converse.emit('roomInviteSent', {
|
2016-03-01 23:26:36 +01:00
|
|
|
'room': this,
|
|
|
|
|
'recipient': recipient,
|
|
|
|
|
'reason': reason
|
|
|
|
|
});
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-08-12 14:52:33 +02:00
|
|
|
handleChatStateMessage: function (message) {
|
|
|
|
|
/* Override the method on the ChatBoxView base class to
|
|
|
|
|
* ignore <gone/> notifications in groupchats.
|
|
|
|
|
*
|
|
|
|
|
* As laid out in the business rules in XEP-0085
|
|
|
|
|
* http://xmpp.org/extensions/xep-0085.html#bizrules-groupchat
|
|
|
|
|
*/
|
2016-08-12 16:40:04 +02:00
|
|
|
if (message.get('fullname') === this.model.get('nick')) {
|
|
|
|
|
// Don't know about other servers, but OpenFire sends
|
|
|
|
|
// back to you your own chat state notifications.
|
|
|
|
|
// We ignore them here...
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
if (message.get('chat_state') !== _converse.GONE) {
|
|
|
|
|
_converse.ChatBoxView.prototype.handleChatStateMessage.apply(this, arguments);
|
2016-08-12 14:52:33 +02:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-08-12 16:40:04 +02:00
|
|
|
sendChatState: function () {
|
|
|
|
|
/* Sends a message with the status of the user in this chat session
|
|
|
|
|
* as taken from the 'chat_state' attribute of the chat box.
|
|
|
|
|
* See XEP-0085 Chat State Notifications.
|
|
|
|
|
*/
|
|
|
|
|
var chat_state = this.model.get('chat_state');
|
2016-12-20 10:30:20 +01:00
|
|
|
if (chat_state === _converse.GONE) {
|
2016-08-12 16:40:04 +02:00
|
|
|
// <gone/> is not applicable within MUC context
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.send(
|
2016-08-12 16:40:04 +02:00
|
|
|
$msg({'to':this.model.get('jid'), 'type': 'groupchat'})
|
|
|
|
|
.c(chat_state, {'xmlns': Strophe.NS.CHATSTATES}).up()
|
|
|
|
|
.c('no-store', {'xmlns': Strophe.NS.HINTS}).up()
|
|
|
|
|
.c('no-permanent-store', {'xmlns': Strophe.NS.HINTS})
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
sendChatRoomMessage: function (text) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Constuct a message stanza to be sent to this chat room,
|
|
|
|
|
* and send it to the server.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (String) text: The message text to be sent.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
var msgid = _converse.connection.getUniqueId();
|
2016-02-16 08:46:47 +01:00
|
|
|
var msg = $msg({
|
|
|
|
|
to: this.model.get('jid'),
|
2016-12-20 10:30:20 +01:00
|
|
|
from: _converse.connection.jid,
|
2016-02-16 08:46:47 +01:00
|
|
|
type: 'groupchat',
|
|
|
|
|
id: msgid
|
|
|
|
|
}).c("body").t(text).up()
|
2016-12-20 10:30:20 +01:00
|
|
|
.c("x", {xmlns: "jabber:x:event"}).c(_converse.COMPOSING);
|
|
|
|
|
_converse.connection.send(msg);
|
2016-02-16 08:46:47 +01:00
|
|
|
this.model.messages.create({
|
2016-05-25 11:00:25 +02:00
|
|
|
fullname: this.model.get('nick'),
|
2016-02-16 08:46:47 +01:00
|
|
|
sender: 'me',
|
|
|
|
|
time: moment().format(),
|
|
|
|
|
message: text,
|
|
|
|
|
msgid: msgid
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
modifyRole: function(room, nick, role, reason, onSuccess, onError) {
|
|
|
|
|
var item = $build("item", {nick: nick, role: role});
|
|
|
|
|
var iq = $iq({to: room, type: "set"}).c("query", {xmlns: Strophe.NS.MUC_ADMIN}).cnode(item.node);
|
|
|
|
|
if (reason !== null) { iq.c("reason", reason); }
|
2016-12-20 10:30:20 +01:00
|
|
|
return _converse.connection.sendIQ(iq.tree(), onSuccess, onError);
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
validateRoleChangeCommand: function (command, args) {
|
|
|
|
|
/* Check that a command to change a chat room user's role or
|
2016-03-19 23:16:00 +01:00
|
|
|
* affiliation has anough arguments.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
// TODO check if first argument is valid
|
|
|
|
|
if (args.length < 1 || args.length > 2) {
|
|
|
|
|
this.showStatusNotification(
|
|
|
|
|
__("Error: the \""+command+"\" command takes two arguments, the user's nickname and optionally a reason."),
|
|
|
|
|
true
|
|
|
|
|
);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
},
|
|
|
|
|
|
2016-03-16 10:03:00 +01:00
|
|
|
clearChatRoomMessages: function (ev) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Remove all messages from the chat room UI.
|
|
|
|
|
*/
|
2017-01-26 15:49:02 +01:00
|
|
|
if (!_.isUndefined(ev)) { ev.stopPropagation(); }
|
2016-03-16 10:03:00 +01:00
|
|
|
var result = confirm(__("Are you sure you want to clear the messages from this room?"));
|
|
|
|
|
if (result === true) {
|
|
|
|
|
this.$content.empty();
|
|
|
|
|
}
|
|
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
onCommandError: function () {
|
|
|
|
|
this.showStatusNotification(__("Error: could not execute the command"), true);
|
|
|
|
|
},
|
|
|
|
|
|
2016-08-12 14:52:33 +02:00
|
|
|
onMessageSubmitted: function (text) {
|
2016-02-16 08:46:47 +01:00
|
|
|
/* Gets called when the user presses enter to send off a
|
2016-03-19 23:16:00 +01:00
|
|
|
* message in a chat room.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (String) text - The message text.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.muc_disable_moderator_commands) {
|
2016-12-07 14:48:47 +01:00
|
|
|
return this.sendChatRoomMessage(text);
|
|
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
var match = text.replace(/^\s*/, "").match(/^\/(.*?)(?: (.*))?$/) || [false, '', ''],
|
2017-02-01 18:36:20 +01:00
|
|
|
args = match[2] && match[2].splitOnce(' ') || [],
|
|
|
|
|
command = match[1].toLowerCase();
|
|
|
|
|
switch (command) {
|
2016-02-16 08:46:47 +01:00
|
|
|
case 'admin':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-12-08 08:28:20 +01:00
|
|
|
this.setAffiliation('admin',
|
|
|
|
|
[{ 'jid': args[0],
|
|
|
|
|
'reason': args[1]
|
|
|
|
|
}]).fail(this.onCommandError.bind(this));
|
2016-02-16 08:46:47 +01:00
|
|
|
break;
|
|
|
|
|
case 'ban':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-12-08 08:28:20 +01:00
|
|
|
this.setAffiliation('outcast',
|
|
|
|
|
[{ 'jid': args[0],
|
|
|
|
|
'reason': args[1]
|
|
|
|
|
}]).fail(this.onCommandError.bind(this));
|
2016-02-16 08:46:47 +01:00
|
|
|
break;
|
|
|
|
|
case 'clear':
|
|
|
|
|
this.clearChatRoomMessages();
|
|
|
|
|
break;
|
|
|
|
|
case 'deop':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-02-16 08:46:47 +01:00
|
|
|
this.modifyRole(
|
|
|
|
|
this.model.get('jid'), args[0], 'occupant', args[1],
|
|
|
|
|
undefined, this.onCommandError.bind(this));
|
|
|
|
|
break;
|
|
|
|
|
case 'help':
|
|
|
|
|
this.showHelpMessages([
|
2017-02-01 18:36:20 +01:00
|
|
|
'<strong>/admin</strong>: ' +__("Change user's affiliation to admin"),
|
|
|
|
|
'<strong>/ban</strong>: ' +__('Ban user from room'),
|
|
|
|
|
'<strong>/clear</strong>: ' +__('Remove messages'),
|
|
|
|
|
'<strong>/deop</strong>: ' +__('Change user role to occupant'),
|
|
|
|
|
'<strong>/help</strong>: ' +__('Show this menu'),
|
|
|
|
|
'<strong>/kick</strong>: ' +__('Kick user from room'),
|
|
|
|
|
'<strong>/me</strong>: ' +__('Write in 3rd person'),
|
|
|
|
|
'<strong>/member</strong>: ' +__('Grant membership to a user'),
|
|
|
|
|
'<strong>/mute</strong>: ' +__("Remove user's ability to post messages"),
|
|
|
|
|
'<strong>/nick</strong>: ' +__('Change your nickname'),
|
|
|
|
|
'<strong>/op</strong>: ' +__('Grant moderator role to user'),
|
|
|
|
|
'<strong>/owner</strong>: ' +__('Grant ownership of this room'),
|
|
|
|
|
'<strong>/revoke</strong>: ' +__("Revoke user's membership"),
|
|
|
|
|
'<strong>/subject</strong>: ' +__('Set room subject'),
|
|
|
|
|
'<strong>/topic</strong>: ' +__('Set room subject (alias for /subject)'),
|
|
|
|
|
'<strong>/voice</strong>: ' +__('Allow muted user to post messages')
|
2016-02-16 08:46:47 +01:00
|
|
|
]);
|
|
|
|
|
break;
|
|
|
|
|
case 'kick':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-02-16 08:46:47 +01:00
|
|
|
this.modifyRole(
|
|
|
|
|
this.model.get('jid'), args[0], 'none', args[1],
|
|
|
|
|
undefined, this.onCommandError.bind(this));
|
|
|
|
|
break;
|
|
|
|
|
case 'mute':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-02-16 08:46:47 +01:00
|
|
|
this.modifyRole(
|
|
|
|
|
this.model.get('jid'), args[0], 'visitor', args[1],
|
|
|
|
|
undefined, this.onCommandError.bind(this));
|
|
|
|
|
break;
|
|
|
|
|
case 'member':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-12-08 08:28:20 +01:00
|
|
|
this.setAffiliation('member',
|
|
|
|
|
[{ 'jid': args[0],
|
|
|
|
|
'reason': args[1]
|
|
|
|
|
}]).fail(this.onCommandError.bind(this));
|
2016-02-16 08:46:47 +01:00
|
|
|
break;
|
|
|
|
|
case 'nick':
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.send($pres({
|
|
|
|
|
from: _converse.connection.jid,
|
2016-02-16 08:46:47 +01:00
|
|
|
to: this.getRoomJIDAndNick(match[2]),
|
2016-12-20 10:30:20 +01:00
|
|
|
id: _converse.connection.getUniqueId()
|
2016-02-16 08:46:47 +01:00
|
|
|
}).tree());
|
|
|
|
|
break;
|
|
|
|
|
case 'owner':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-12-08 08:28:20 +01:00
|
|
|
this.setAffiliation('owner',
|
|
|
|
|
[{ 'jid': args[0],
|
|
|
|
|
'reason': args[1]
|
|
|
|
|
}]).fail(this.onCommandError.bind(this));
|
2016-02-16 08:46:47 +01:00
|
|
|
break;
|
|
|
|
|
case 'op':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-02-16 08:46:47 +01:00
|
|
|
this.modifyRole(
|
|
|
|
|
this.model.get('jid'), args[0], 'moderator', args[1],
|
|
|
|
|
undefined, this.onCommandError.bind(this));
|
|
|
|
|
break;
|
|
|
|
|
case 'revoke':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-12-08 08:28:20 +01:00
|
|
|
this.setAffiliation('none',
|
|
|
|
|
[{ 'jid': args[0],
|
|
|
|
|
'reason': args[1]
|
|
|
|
|
}]).fail(this.onCommandError.bind(this));
|
2016-02-16 08:46:47 +01:00
|
|
|
break;
|
|
|
|
|
case 'topic':
|
2017-02-01 18:36:20 +01:00
|
|
|
case 'subject':
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.send(
|
2016-02-16 08:46:47 +01:00
|
|
|
$msg({
|
|
|
|
|
to: this.model.get('jid'),
|
2016-12-20 10:30:20 +01:00
|
|
|
from: _converse.connection.jid,
|
2016-02-16 08:46:47 +01:00
|
|
|
type: "groupchat"
|
|
|
|
|
}).c("subject", {xmlns: "jabber:client"}).t(match[2]).tree()
|
|
|
|
|
);
|
|
|
|
|
break;
|
|
|
|
|
case 'voice':
|
2017-02-01 18:36:20 +01:00
|
|
|
if (!this.validateRoleChangeCommand(command, args)) { break; }
|
2016-02-16 08:46:47 +01:00
|
|
|
this.modifyRole(
|
|
|
|
|
this.model.get('jid'), args[0], 'occupant', args[1],
|
|
|
|
|
undefined, this.onCommandError.bind(this));
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
this.sendChatRoomMessage(text);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-10-13 18:22:37 +02:00
|
|
|
handleMUCMessage: function (stanza) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Handler for all MUC messages sent to this chat room.
|
|
|
|
|
*
|
|
|
|
|
* MAM (message archive management XEP-0313) messages are
|
|
|
|
|
* ignored, since they're handled separately.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) stanza: The message stanza.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
var is_mam = $(stanza).find('[xmlns="'+Strophe.NS.MAM+'"]').length > 0;
|
2016-10-13 18:22:37 +02:00
|
|
|
if (is_mam) {
|
2016-02-16 08:46:47 +01:00
|
|
|
return true;
|
|
|
|
|
}
|
2016-12-04 13:05:25 +01:00
|
|
|
var configuration_changed = stanza.querySelector("status[code='104']");
|
|
|
|
|
var logging_enabled = stanza.querySelector("status[code='170']");
|
|
|
|
|
var logging_disabled = stanza.querySelector("status[code='171']");
|
|
|
|
|
var room_no_longer_anon = stanza.querySelector("status[code='172']");
|
|
|
|
|
var room_now_semi_anon = stanza.querySelector("status[code='173']");
|
|
|
|
|
var room_now_fully_anon = stanza.querySelector("status[code='173']");
|
|
|
|
|
if (configuration_changed || logging_enabled || logging_disabled ||
|
|
|
|
|
room_no_longer_anon || room_now_semi_anon || room_now_fully_anon) {
|
2016-12-05 07:03:44 +01:00
|
|
|
this.getRoomFeatures();
|
2016-12-04 13:05:25 +01:00
|
|
|
}
|
2017-01-26 15:49:02 +01:00
|
|
|
_.flow(this.showStatusMessages.bind(this), this.onChatRoomMessage.bind(this))(stanza);
|
2016-02-16 08:46:47 +01:00
|
|
|
return true;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
getRoomJIDAndNick: function (nick) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Utility method to construct the JID for the current user
|
|
|
|
|
* as occupant of the room.
|
|
|
|
|
*
|
|
|
|
|
* This is the room JID, with the user's nick added at the
|
|
|
|
|
* end.
|
|
|
|
|
*
|
|
|
|
|
* For example: room@conference.example.org/nickname
|
|
|
|
|
*/
|
2016-07-20 01:59:52 +02:00
|
|
|
if (nick) {
|
2016-07-20 15:59:02 +02:00
|
|
|
this.model.save({'nick': nick});
|
2016-07-20 01:59:52 +02:00
|
|
|
} else {
|
|
|
|
|
nick = this.model.get('nick');
|
|
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
var room = this.model.get('jid');
|
|
|
|
|
var node = Strophe.getNodeFromJid(room);
|
|
|
|
|
var domain = Strophe.getDomainFromJid(room);
|
|
|
|
|
return node + "@" + domain + (nick !== null ? "/" + nick : "");
|
|
|
|
|
},
|
|
|
|
|
|
2016-10-13 18:22:37 +02:00
|
|
|
registerHandlers: function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Register presence and message handlers for this chat
|
|
|
|
|
* room
|
|
|
|
|
*/
|
2016-10-13 18:22:37 +02:00
|
|
|
var room_jid = this.model.get('jid');
|
|
|
|
|
this.removeHandlers();
|
2016-12-20 10:30:20 +01:00
|
|
|
this.presence_handler = _converse.connection.addHandler(
|
2016-10-13 18:22:37 +02:00
|
|
|
this.onChatRoomPresence.bind(this),
|
|
|
|
|
Strophe.NS.MUC, 'presence', null, null, room_jid,
|
|
|
|
|
{'ignoreNamespaceFragment': true, 'matchBareFromJid': true}
|
|
|
|
|
);
|
2016-12-20 10:30:20 +01:00
|
|
|
this.message_handler = _converse.connection.addHandler(
|
2016-10-13 18:22:37 +02:00
|
|
|
this.handleMUCMessage.bind(this),
|
|
|
|
|
null, 'message', null, null, room_jid,
|
|
|
|
|
{'matchBareFromJid': true}
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
removeHandlers: function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Remove the presence and message handlers that were
|
|
|
|
|
* registered for this chat room.
|
|
|
|
|
*/
|
2016-10-13 18:22:37 +02:00
|
|
|
if (this.message_handler) {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.deleteHandler(this.message_handler);
|
2016-10-13 18:22:37 +02:00
|
|
|
delete this.message_handler;
|
|
|
|
|
}
|
|
|
|
|
if (this.presence_handler) {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.deleteHandler(this.presence_handler);
|
2016-10-13 18:22:37 +02:00
|
|
|
delete this.presence_handler;
|
|
|
|
|
}
|
|
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-20 01:59:52 +02:00
|
|
|
join: function (nick, password) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Join the chat room.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (String) nick: The user's nickname
|
|
|
|
|
* (String) password: Optional password, if required by
|
|
|
|
|
* the room.
|
|
|
|
|
*/
|
2016-12-05 07:03:44 +01:00
|
|
|
nick = nick ? nick : this.model.get('nick');
|
|
|
|
|
if (!nick) {
|
|
|
|
|
return this.checkForReservedNick();
|
|
|
|
|
}
|
2016-10-13 18:22:37 +02:00
|
|
|
this.registerHandlers();
|
2016-12-04 14:39:09 +01:00
|
|
|
if (this.model.get('connection_status') === Strophe.Status.CONNECTED) {
|
|
|
|
|
// We have restored a chat room from session storage,
|
|
|
|
|
// so we don't send out a presence stanza again.
|
2016-12-08 14:23:17 +01:00
|
|
|
return this;
|
2016-12-04 14:39:09 +01:00
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
var stanza = $pres({
|
2016-12-20 10:30:20 +01:00
|
|
|
'from': _converse.connection.jid,
|
2016-07-20 01:59:52 +02:00
|
|
|
'to': this.getRoomJIDAndNick(nick)
|
|
|
|
|
}).c("x", {'xmlns': Strophe.NS.MUC})
|
2016-12-20 10:30:20 +01:00
|
|
|
.c("history", {'maxstanzas': _converse.muc_history_max_stanzas}).up();
|
2016-02-16 08:46:47 +01:00
|
|
|
if (password) {
|
|
|
|
|
stanza.cnode(Strophe.xmlElement("password", [], password));
|
|
|
|
|
}
|
2016-12-04 14:39:09 +01:00
|
|
|
this.model.save('connection_status', Strophe.Status.CONNECTING);
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.send(stanza);
|
2016-12-05 07:03:44 +01:00
|
|
|
return this;
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-11-02 15:51:23 +01:00
|
|
|
cleanup: function () {
|
2016-12-04 14:39:09 +01:00
|
|
|
this.model.save('connection_status', Strophe.Status.DISCONNECTED);
|
2016-11-02 15:51:23 +01:00
|
|
|
this.removeHandlers();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatBoxView.prototype.close.apply(this, arguments);
|
2016-11-02 15:51:23 +01:00
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
leave: function(exit_msg) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Leave the chat room.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (String) exit_msg: Optional message to indicate your
|
|
|
|
|
* reason for leaving.
|
|
|
|
|
*/
|
2016-12-05 11:48:13 +01:00
|
|
|
this.hide();
|
2016-12-04 13:32:14 +01:00
|
|
|
this.occupantsview.model.reset();
|
|
|
|
|
this.occupantsview.model.browserStorage._clear();
|
2016-12-20 10:30:20 +01:00
|
|
|
if (!_converse.connection.connected ||
|
2016-12-05 07:03:44 +01:00
|
|
|
this.model.get('connection_status') === Strophe.Status.DISCONNECTED) {
|
2016-11-02 15:51:23 +01:00
|
|
|
// Don't send out a stanza if we're not connected.
|
|
|
|
|
this.cleanup();
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
var presence = $pres({
|
|
|
|
|
type: "unavailable",
|
2016-12-20 10:30:20 +01:00
|
|
|
from: _converse.connection.jid,
|
2016-02-16 08:46:47 +01:00
|
|
|
to: this.getRoomJIDAndNick()
|
|
|
|
|
});
|
|
|
|
|
if (exit_msg !== null) {
|
|
|
|
|
presence.c("status", exit_msg);
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.sendPresence(
|
2016-12-05 11:48:13 +01:00
|
|
|
presence,
|
|
|
|
|
this.cleanup.bind(this),
|
2016-11-02 15:51:23 +01:00
|
|
|
this.cleanup.bind(this),
|
2016-12-05 11:48:13 +01:00
|
|
|
2000
|
2016-11-02 15:51:23 +01:00
|
|
|
);
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
renderConfigurationForm: function (stanza) {
|
2016-12-03 17:39:59 +01:00
|
|
|
/* Renders a form given an IQ stanza containing the current
|
|
|
|
|
* room configuration.
|
|
|
|
|
*
|
|
|
|
|
* Returns a promise which resolves once the user has
|
|
|
|
|
* either submitted the form, or canceled it.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) stanza: The IQ stanza containing the room config.
|
|
|
|
|
*/
|
|
|
|
|
var that = this,
|
|
|
|
|
$body = this.$('.chatroom-body');
|
|
|
|
|
$body.children().addClass('hidden');
|
2016-12-04 14:06:34 +01:00
|
|
|
// Remove any existing forms
|
|
|
|
|
$body.find('form.chatroom-form').remove();
|
2016-12-20 10:30:20 +01:00
|
|
|
$body.append(_converse.templates.chatroom_form());
|
2016-12-03 17:39:59 +01:00
|
|
|
|
2016-12-04 14:06:34 +01:00
|
|
|
var $form = $body.find('form.chatroom-form'),
|
2016-02-16 08:46:47 +01:00
|
|
|
$fieldset = $form.children('fieldset:first'),
|
|
|
|
|
$stanza = $(stanza),
|
|
|
|
|
$fields = $stanza.find('field'),
|
|
|
|
|
title = $stanza.find('title').text(),
|
|
|
|
|
instructions = $stanza.find('instructions').text();
|
|
|
|
|
$fieldset.find('span.spinner').remove();
|
|
|
|
|
$fieldset.append($('<legend>').text(title));
|
|
|
|
|
if (instructions && instructions !== title) {
|
|
|
|
|
$fieldset.append($('<p class="instructions">').text(instructions));
|
|
|
|
|
}
|
|
|
|
|
_.each($fields, function (field) {
|
|
|
|
|
$fieldset.append(utils.xForm2webForm($(field), $stanza));
|
|
|
|
|
});
|
|
|
|
|
$form.append('<fieldset></fieldset>');
|
|
|
|
|
$fieldset = $form.children('fieldset:last');
|
|
|
|
|
$fieldset.append('<input type="submit" class="pure-button button-primary" value="'+__('Save')+'"/>');
|
|
|
|
|
$fieldset.append('<input type="button" class="pure-button button-cancel" value="'+__('Cancel')+'"/>');
|
2016-12-03 17:39:59 +01:00
|
|
|
$fieldset.find('input[type=button]').on('click', function (ev) {
|
|
|
|
|
ev.preventDefault();
|
|
|
|
|
that.cancelConfiguration();
|
|
|
|
|
});
|
|
|
|
|
$form.on('submit', function (ev) {
|
|
|
|
|
ev.preventDefault();
|
2016-12-04 13:05:56 +01:00
|
|
|
that.saveConfiguration(ev.target);
|
2016-12-03 17:39:59 +01:00
|
|
|
});
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
sendConfiguration: function(config, onSuccess, onError) {
|
2016-12-03 17:39:59 +01:00
|
|
|
/* Send an IQ stanza with the room configuration.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (Array) config: The room configuration
|
|
|
|
|
* (Function) onSuccess: Callback upon succesful IQ response
|
|
|
|
|
* The first parameter passed in is IQ containing the
|
|
|
|
|
* room configuration.
|
|
|
|
|
* The second is the response IQ from the server.
|
|
|
|
|
* (Function) onError: Callback upon error IQ response
|
|
|
|
|
* The first parameter passed in is IQ containing the
|
|
|
|
|
* room configuration.
|
|
|
|
|
* The second is the response IQ from the server.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
var iq = $iq({to: this.model.get('jid'), type: "set"})
|
|
|
|
|
.c("query", {xmlns: Strophe.NS.MUC_OWNER})
|
|
|
|
|
.c("x", {xmlns: Strophe.NS.XFORM, type: "submit"});
|
2016-12-03 17:39:59 +01:00
|
|
|
_.each(config || [], function (node) { iq.cnode(node).up(); });
|
|
|
|
|
onSuccess = _.isUndefined(onSuccess) ? _.noop : _.partial(onSuccess, iq.nodeTree);
|
|
|
|
|
onError = _.isUndefined(onError) ? _.noop : _.partial(onError, iq.nodeTree);
|
2016-12-20 10:30:20 +01:00
|
|
|
return _converse.connection.sendIQ(iq, onSuccess, onError);
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
saveConfiguration: function (form) {
|
|
|
|
|
/* Submit the room configuration form by sending an IQ
|
|
|
|
|
* stanza to the server.
|
|
|
|
|
*
|
|
|
|
|
* Returns a promise which resolves once the XMPP server
|
|
|
|
|
* has return a response IQ.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (HTMLElement) form: The configuration form DOM element.
|
|
|
|
|
*/
|
2017-02-14 17:55:32 +01:00
|
|
|
var deferred = new $.Deferred();
|
2016-02-16 08:46:47 +01:00
|
|
|
var that = this;
|
2016-12-03 17:39:59 +01:00
|
|
|
var $inputs = $(form).find(':input:not([type=button]):not([type=submit])'),
|
2016-02-16 08:46:47 +01:00
|
|
|
configArray = [];
|
|
|
|
|
$inputs.each(function () {
|
|
|
|
|
configArray.push(utils.webForm2xForm(this));
|
|
|
|
|
});
|
2017-02-14 17:55:32 +01:00
|
|
|
this.sendConfiguration(
|
|
|
|
|
configArray,
|
|
|
|
|
deferred.resolve,
|
|
|
|
|
deferred.reject
|
|
|
|
|
);
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$el.find('div.chatroom-form-container').hide(
|
|
|
|
|
function () {
|
|
|
|
|
$(this).remove();
|
|
|
|
|
that.$el.find('.chat-area').removeClass('hidden');
|
|
|
|
|
that.$el.find('.occupants').removeClass('hidden');
|
|
|
|
|
});
|
2017-02-14 17:55:32 +01:00
|
|
|
return deferred.promise();
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-11-20 17:42:11 +01:00
|
|
|
autoConfigureChatRoom: function (stanza) {
|
|
|
|
|
/* Automatically configure room based on the
|
|
|
|
|
* 'roomconfigure' data on this view's model.
|
2016-12-03 17:39:59 +01:00
|
|
|
*
|
|
|
|
|
* Returns a promise which resolves once a response IQ has
|
|
|
|
|
* been received.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) stanza: IQ stanza from the server,
|
|
|
|
|
* containing the configuration.
|
2016-11-20 17:42:11 +01:00
|
|
|
*/
|
|
|
|
|
var that = this, configArray = [],
|
|
|
|
|
$fields = $(stanza).find('field'),
|
|
|
|
|
count = $fields.length,
|
|
|
|
|
config = this.model.get('roomconfig');
|
|
|
|
|
|
|
|
|
|
$fields.each(function () {
|
|
|
|
|
var fieldname = this.getAttribute('var').replace('muc#roomconfig_', ''),
|
|
|
|
|
type = this.getAttribute('type'),
|
|
|
|
|
value;
|
|
|
|
|
if (fieldname in config) {
|
|
|
|
|
switch (type) {
|
|
|
|
|
case 'boolean':
|
|
|
|
|
value = config[fieldname] ? 1 : 0;
|
|
|
|
|
break;
|
|
|
|
|
case 'list-multi':
|
|
|
|
|
// TODO: we don't yet handle "list-multi" types
|
|
|
|
|
value = this.innerHTML;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
value = config[fieldname];
|
|
|
|
|
}
|
|
|
|
|
this.innerHTML = $build('value').t(value);
|
|
|
|
|
}
|
|
|
|
|
configArray.push(this);
|
|
|
|
|
if (!--count) {
|
2016-12-04 13:05:56 +01:00
|
|
|
that.sendConfiguration(configArray);
|
2016-11-20 17:42:11 +01:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
cancelConfiguration: function () {
|
|
|
|
|
/* Remove the configuration form without submitting and
|
|
|
|
|
* return to the chat view.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
var that = this;
|
|
|
|
|
this.$el.find('div.chatroom-form-container').hide(
|
|
|
|
|
function () {
|
|
|
|
|
$(this).remove();
|
|
|
|
|
that.$el.find('.chat-area').removeClass('hidden');
|
|
|
|
|
that.$el.find('.occupants').removeClass('hidden');
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
fetchRoomConfiguration: function (handler) {
|
|
|
|
|
/* Send an IQ stanza to fetch the room configuration data.
|
|
|
|
|
* Returns a promise which resolves once the response IQ
|
|
|
|
|
* has been received.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (Function) handler: The handler for the response IQ
|
|
|
|
|
*/
|
|
|
|
|
var that = this;
|
|
|
|
|
var deferred = new $.Deferred();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.sendIQ(
|
2016-11-20 17:42:11 +01:00
|
|
|
$iq({
|
|
|
|
|
'to': this.model.get('jid'),
|
|
|
|
|
'type': "get"
|
2016-12-02 19:12:40 +01:00
|
|
|
}).c("query", {xmlns: Strophe.NS.MUC_OWNER}),
|
2016-12-03 17:39:59 +01:00
|
|
|
function (iq) {
|
|
|
|
|
if (handler) {
|
|
|
|
|
handler.apply(that, arguments);
|
|
|
|
|
}
|
|
|
|
|
deferred.resolve(iq);
|
|
|
|
|
},
|
|
|
|
|
deferred.reject // errback
|
2016-02-16 08:46:47 +01:00
|
|
|
);
|
2016-12-03 17:39:59 +01:00
|
|
|
return deferred.promise();
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-05 07:03:44 +01:00
|
|
|
getRoomFeatures: function () {
|
2016-12-04 13:05:25 +01:00
|
|
|
/* Fetch the room disco info, parse it and then
|
2016-12-03 17:39:59 +01:00
|
|
|
* save it on the Backbone.Model of this chat rooms.
|
|
|
|
|
*/
|
2016-12-05 07:03:44 +01:00
|
|
|
var deferred = new $.Deferred();
|
2016-12-03 17:39:59 +01:00
|
|
|
var that = this;
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.disco.info(this.model.get('jid'), null,
|
2016-12-04 13:05:25 +01:00
|
|
|
function (iq) {
|
2016-12-05 11:50:01 +01:00
|
|
|
/*
|
2016-12-05 07:03:44 +01:00
|
|
|
* See http://xmpp.org/extensions/xep-0045.html#disco-roominfo
|
|
|
|
|
*
|
|
|
|
|
* <identity
|
|
|
|
|
* category='conference'
|
|
|
|
|
* name='A Dark Cave'
|
|
|
|
|
* type='text'/>
|
|
|
|
|
* <feature var='http://jabber.org/protocol/muc'/>
|
|
|
|
|
* <feature var='muc_passwordprotected'/>
|
|
|
|
|
* <feature var='muc_hidden'/>
|
|
|
|
|
* <feature var='muc_temporary'/>
|
|
|
|
|
* <feature var='muc_open'/>
|
|
|
|
|
* <feature var='muc_unmoderated'/>
|
|
|
|
|
* <feature var='muc_nonanonymous'/>
|
2016-12-03 17:39:59 +01:00
|
|
|
*/
|
2016-12-05 07:03:44 +01:00
|
|
|
var features = {
|
|
|
|
|
'features_fetched': true
|
|
|
|
|
};
|
2016-12-04 13:05:25 +01:00
|
|
|
_.each(iq.querySelectorAll('feature'), function (field) {
|
|
|
|
|
var fieldname = field.getAttribute('var');
|
|
|
|
|
if (!fieldname.startsWith('muc_')) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
2016-12-05 07:03:44 +01:00
|
|
|
features[fieldname.replace('muc_', '')] = true;
|
2016-12-04 13:05:25 +01:00
|
|
|
});
|
2016-12-05 07:03:44 +01:00
|
|
|
that.model.save(features);
|
|
|
|
|
return deferred.resolve();
|
|
|
|
|
},
|
|
|
|
|
deferred.reject
|
2016-12-04 13:05:25 +01:00
|
|
|
);
|
2016-12-05 07:03:44 +01:00
|
|
|
return deferred.promise();
|
2016-12-03 17:39:59 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
configureChatRoom: function (ev) {
|
|
|
|
|
/* Start the process of configuring a chat room, either by
|
|
|
|
|
* rendering a configuration form, or by auto-configuring
|
|
|
|
|
* based on the "roomconfig" data stored on the
|
|
|
|
|
* Backbone.Model.
|
|
|
|
|
*
|
|
|
|
|
* Stores the new configuration on the Backbone.Model once
|
|
|
|
|
* completed.
|
|
|
|
|
*
|
|
|
|
|
* Paremeters:
|
|
|
|
|
* (Event) ev: DOM event that might be passed in if this
|
|
|
|
|
* method is called due to a user action. In this
|
|
|
|
|
* case, auto-configure won't happen, regardless of
|
|
|
|
|
* the settings.
|
|
|
|
|
*/
|
|
|
|
|
var that = this;
|
|
|
|
|
if (_.isUndefined(ev) && this.model.get('auto_configure')) {
|
2016-12-04 13:05:25 +01:00
|
|
|
this.fetchRoomConfiguration().then(that.autoConfigureChatRoom.bind(that));
|
2016-12-03 17:39:59 +01:00
|
|
|
} else {
|
2017-01-26 15:49:02 +01:00
|
|
|
if (!_.isUndefined(ev) && ev.preventDefault) {
|
2016-12-03 17:39:59 +01:00
|
|
|
ev.preventDefault();
|
|
|
|
|
}
|
2016-12-04 16:11:09 +01:00
|
|
|
this.showSpinner();
|
2016-12-04 13:05:25 +01:00
|
|
|
this.fetchRoomConfiguration().then(that.renderConfigurationForm.bind(that));
|
2016-12-03 17:39:59 +01:00
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-07-19 16:18:40 +02:00
|
|
|
submitNickname: function (ev) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Get the nickname value from the form and then join the
|
|
|
|
|
* chat room with it.
|
|
|
|
|
*/
|
2016-07-19 16:18:40 +02:00
|
|
|
ev.preventDefault();
|
|
|
|
|
var $nick = this.$el.find('input[name=nick]');
|
|
|
|
|
var nick = $nick.val();
|
|
|
|
|
if (!nick) {
|
|
|
|
|
$nick.addClass('error');
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
$nick.removeClass('error');
|
|
|
|
|
}
|
|
|
|
|
this.$el.find('.chatroom-form-container').replaceWith('<span class="spinner centered"/>');
|
2016-07-20 01:59:52 +02:00
|
|
|
this.join(nick);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
checkForReservedNick: function () {
|
2016-09-23 09:41:55 +02:00
|
|
|
/* User service-discovery to ask the XMPP server whether
|
2016-07-20 01:59:52 +02:00
|
|
|
* this user has a reserved nickname for this room.
|
|
|
|
|
* If so, we'll use that, otherwise we render the nickname
|
|
|
|
|
* form.
|
|
|
|
|
*/
|
|
|
|
|
this.showSpinner();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.sendIQ(
|
2016-07-20 01:59:52 +02:00
|
|
|
$iq({
|
|
|
|
|
'to': this.model.get('jid'),
|
2016-12-20 10:30:20 +01:00
|
|
|
'from': _converse.connection.jid,
|
2016-07-20 01:59:52 +02:00
|
|
|
'type': "get"
|
|
|
|
|
}).c("query", {
|
|
|
|
|
'xmlns': Strophe.NS.DISCO_INFO,
|
|
|
|
|
'node': 'x-roomuser-item'
|
|
|
|
|
}),
|
|
|
|
|
this.onNickNameFound.bind(this),
|
2016-08-11 14:00:52 +02:00
|
|
|
this.onNickNameNotFound.bind(this)
|
2016-07-20 01:59:52 +02:00
|
|
|
);
|
2016-12-05 07:03:44 +01:00
|
|
|
return this;
|
2016-07-20 01:59:52 +02:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onNickNameFound: function (iq) {
|
|
|
|
|
/* We've received an IQ response from the server which
|
|
|
|
|
* might contain the user's reserved nickname.
|
2016-12-04 10:43:39 +01:00
|
|
|
* If no nickname is found we either render a form for
|
|
|
|
|
* them to specify one, or we try to join the room with the
|
|
|
|
|
* node of the user's JID.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) iq: The received IQ stanza
|
2016-07-20 01:59:52 +02:00
|
|
|
*/
|
|
|
|
|
var nick = $(iq)
|
|
|
|
|
.find('query[node="x-roomuser-item"] identity')
|
|
|
|
|
.attr('name');
|
|
|
|
|
if (!nick) {
|
2016-08-11 14:00:52 +02:00
|
|
|
this.onNickNameNotFound();
|
2016-07-20 01:59:52 +02:00
|
|
|
} else {
|
|
|
|
|
this.join(nick);
|
|
|
|
|
}
|
2016-07-19 16:18:40 +02:00
|
|
|
},
|
|
|
|
|
|
2016-08-11 14:00:52 +02:00
|
|
|
onNickNameNotFound: function (message) {
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.muc_nickname_from_jid) {
|
2016-08-11 14:00:52 +02:00
|
|
|
// We try to enter the room with the node part of
|
|
|
|
|
// the user's JID.
|
2016-12-20 10:30:20 +01:00
|
|
|
this.join(Strophe.unescapeNode(Strophe.getNodeFromJid(_converse.bare_jid)));
|
2016-08-11 14:00:52 +02:00
|
|
|
} else {
|
|
|
|
|
this.renderNicknameForm(message);
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-08-11 14:19:43 +02:00
|
|
|
getDefaultNickName: function () {
|
|
|
|
|
/* The default nickname (used when muc_nickname_from_jid is true)
|
|
|
|
|
* is the node part of the user's JID.
|
|
|
|
|
* We put this in a separate method so that it can be
|
|
|
|
|
* overridden by plugins.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
return Strophe.unescapeNode(Strophe.getNodeFromJid(_converse.bare_jid));
|
2016-08-11 14:19:43 +02:00
|
|
|
},
|
|
|
|
|
|
2016-08-11 14:00:52 +02:00
|
|
|
onNicknameClash: function (presence) {
|
|
|
|
|
/* When the nickname is already taken, we either render a
|
|
|
|
|
* form for the user to choose a new nickname, or we
|
|
|
|
|
* try to make the nickname unique by adding an integer to
|
|
|
|
|
* it. So john will become john-2, and then john-3 and so on.
|
|
|
|
|
*
|
|
|
|
|
* Which option is take depends on the value of
|
|
|
|
|
* muc_nickname_from_jid.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.muc_nickname_from_jid) {
|
2016-08-11 14:00:52 +02:00
|
|
|
var nick = presence.getAttribute('from').split('/')[1];
|
2016-08-11 14:19:43 +02:00
|
|
|
if (nick === this.getDefaultNickName()) {
|
2016-08-11 14:00:52 +02:00
|
|
|
this.join(nick + '-2');
|
|
|
|
|
} else {
|
|
|
|
|
var del= nick.lastIndexOf("-");
|
|
|
|
|
var num = nick.substring(del+1, nick.length);
|
|
|
|
|
this.join(nick.substring(0, del+1) + String(Number(num)+1));
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
this.renderNicknameForm(
|
|
|
|
|
__("The nickname you chose is reserved or currently in use, please choose a different one.")
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-20 10:16:08 +02:00
|
|
|
renderNicknameForm: function (message) {
|
2016-08-11 14:00:52 +02:00
|
|
|
/* Render a form which allows the user to choose their
|
|
|
|
|
* nickname.
|
|
|
|
|
*/
|
2016-07-19 16:18:40 +02:00
|
|
|
this.$('.chatroom-body').children().addClass('hidden');
|
|
|
|
|
this.$('span.centered.spinner').remove();
|
2017-01-26 15:49:02 +01:00
|
|
|
if (!_.isString(message)) {
|
2016-07-20 10:16:08 +02:00
|
|
|
message = '';
|
|
|
|
|
}
|
2016-07-19 16:18:40 +02:00
|
|
|
this.$('.chatroom-body').append(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.chatroom_nickname_form({
|
2016-07-19 16:18:40 +02:00
|
|
|
heading: __('Please choose your nickname'),
|
|
|
|
|
label_nickname: __('Nickname'),
|
2016-07-20 10:16:08 +02:00
|
|
|
label_join: __('Enter room'),
|
|
|
|
|
validation_message: message
|
2016-07-19 16:18:40 +02:00
|
|
|
}));
|
|
|
|
|
this.$('.chatroom-form').on('submit', this.submitNickname.bind(this));
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
submitPassword: function (ev) {
|
|
|
|
|
ev.preventDefault();
|
|
|
|
|
var password = this.$el.find('.chatroom-form').find('input[type=password]').val();
|
|
|
|
|
this.$el.find('.chatroom-form-container').replaceWith('<span class="spinner centered"/>');
|
2016-07-20 01:59:52 +02:00
|
|
|
this.join(this.model.get('nick'), password);
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
renderPasswordForm: function () {
|
2016-11-07 15:09:13 +01:00
|
|
|
this.$('.chatroom-body').children().addClass('hidden');
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$('span.centered.spinner').remove();
|
|
|
|
|
this.$('.chatroom-body').append(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.chatroom_password_form({
|
2016-02-16 08:46:47 +01:00
|
|
|
heading: __('This chatroom requires a password'),
|
|
|
|
|
label_password: __('Password: '),
|
|
|
|
|
label_submit: __('Submit')
|
|
|
|
|
}));
|
|
|
|
|
this.$('.chatroom-form').on('submit', this.submitPassword.bind(this));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
showDisconnectMessage: function (msg) {
|
2016-11-07 15:09:13 +01:00
|
|
|
this.$('.chat-area').addClass('hidden');
|
|
|
|
|
this.$('.occupants').addClass('hidden');
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$('span.centered.spinner').remove();
|
|
|
|
|
this.$('.chatroom-body').append($('<p>'+msg+'</p>'));
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-02 18:41:05 +01:00
|
|
|
getMessageFromStatus: function (stat, stanza, is_self) {
|
|
|
|
|
/* Parameters:
|
|
|
|
|
* (XMLElement) stat: A <status> element.
|
|
|
|
|
* (Boolean) is_self: Whether the element refers to the
|
|
|
|
|
* current user.
|
|
|
|
|
* (XMLElement) stanza: The original stanza received.
|
|
|
|
|
*/
|
|
|
|
|
var code = stat.getAttribute('code'),
|
|
|
|
|
from_nick;
|
2016-11-21 13:55:19 +01:00
|
|
|
if (is_self && code === "210") {
|
2016-12-02 18:41:05 +01:00
|
|
|
from_nick = Strophe.unescapeNode(Strophe.getResourceFromJid(stanza.getAttribute('from')));
|
2016-12-20 10:30:20 +01:00
|
|
|
return __(_converse.muc.new_nickname_messages[code], from_nick);
|
2016-11-21 13:55:19 +01:00
|
|
|
} else if (is_self && code === "303") {
|
2016-12-02 18:41:05 +01:00
|
|
|
return __(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.muc.new_nickname_messages[code],
|
2016-12-02 18:41:05 +01:00
|
|
|
stanza.querySelector('x item').getAttribute('nick')
|
|
|
|
|
);
|
2016-12-20 10:30:20 +01:00
|
|
|
} else if (!is_self && (code in _converse.muc.action_info_messages)) {
|
2016-12-02 18:41:05 +01:00
|
|
|
from_nick = Strophe.unescapeNode(Strophe.getResourceFromJid(stanza.getAttribute('from')));
|
2016-12-20 10:30:20 +01:00
|
|
|
return __(_converse.muc.action_info_messages[code], from_nick);
|
|
|
|
|
} else if (code in _converse.muc.info_messages) {
|
|
|
|
|
return _converse.muc.info_messages[code];
|
2016-11-21 13:55:19 +01:00
|
|
|
} else if (code !== '110') {
|
|
|
|
|
if (stat.textContent) {
|
|
|
|
|
// Sometimes the status contains human readable text and not a code.
|
|
|
|
|
return stat.textContent;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return;
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-05 07:03:44 +01:00
|
|
|
saveAffiliationAndRole: function (pres) {
|
2016-12-03 17:39:59 +01:00
|
|
|
/* Parse the presence stanza for the current user's
|
|
|
|
|
* affiliation.
|
2016-12-02 18:41:05 +01:00
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) pres: A <presence> stanza.
|
2016-03-19 23:16:00 +01:00
|
|
|
*/
|
2016-12-02 18:41:05 +01:00
|
|
|
// XXX: For some inexplicable reason, the following line of
|
|
|
|
|
// code works in tests, but not with live data, even though
|
|
|
|
|
// the passed in stanza looks exactly the same to me:
|
|
|
|
|
// var item = pres.querySelector('x[xmlns="'+Strophe.NS.MUC_USER+'"] item');
|
|
|
|
|
// If we want to eventually get rid of jQuery altogether,
|
|
|
|
|
// then the Sizzle selector library might still be needed
|
|
|
|
|
// here.
|
|
|
|
|
var item = $(pres).find('x[xmlns="'+Strophe.NS.MUC_USER+'"] item').get(0);
|
2016-12-05 07:03:44 +01:00
|
|
|
if (_.isUndefined(item)) { return; }
|
2016-11-21 13:55:19 +01:00
|
|
|
var jid = item.getAttribute('jid');
|
2016-12-20 10:30:20 +01:00
|
|
|
if (Strophe.getBareJidFromJid(jid) === _converse.bare_jid) {
|
2016-12-05 07:03:44 +01:00
|
|
|
var affiliation = item.getAttribute('affiliation');
|
|
|
|
|
var role = item.getAttribute('role');
|
|
|
|
|
if (affiliation) {
|
|
|
|
|
this.model.save({'affiliation': affiliation});
|
|
|
|
|
}
|
|
|
|
|
if (role) {
|
|
|
|
|
this.model.save({'role': role});
|
|
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
}
|
2016-12-02 18:41:05 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
parseXUserElement: function (x, stanza, is_self) {
|
|
|
|
|
/* Parse the passed-in <x xmlns='http://jabber.org/protocol/muc#user'>
|
|
|
|
|
* element and construct a map containing relevant
|
|
|
|
|
* information.
|
|
|
|
|
*/
|
|
|
|
|
// 1. Get notification messages based on the <status> elements.
|
2016-11-21 13:55:19 +01:00
|
|
|
var statuses = x.querySelectorAll('status');
|
2016-12-02 18:41:05 +01:00
|
|
|
var mapper = _.partial(this.getMessageFromStatus, _, stanza, is_self);
|
2016-11-21 13:55:19 +01:00
|
|
|
var notification = {
|
|
|
|
|
'messages': _.reject(_.map(statuses, mapper), _.isUndefined),
|
|
|
|
|
};
|
2016-12-02 18:41:05 +01:00
|
|
|
// 2. Get disconnection messages based on the <status> elements
|
2017-01-26 15:49:02 +01:00
|
|
|
var codes = _.invokeMap(statuses, Element.prototype.getAttribute, 'code');
|
2016-12-20 10:30:20 +01:00
|
|
|
var disconnection_codes = _.intersection(codes, _.keys(_converse.muc.disconnect_messages));
|
2016-11-21 13:55:19 +01:00
|
|
|
var disconnected = is_self && disconnection_codes.length > 0;
|
|
|
|
|
if (disconnected) {
|
|
|
|
|
notification.disconnected = true;
|
2016-12-20 10:30:20 +01:00
|
|
|
notification.disconnection_message = _converse.muc.disconnect_messages[disconnection_codes[0]];
|
2016-11-21 13:55:19 +01:00
|
|
|
}
|
2016-12-02 18:41:05 +01:00
|
|
|
// 3. Find the reason and actor from the <item> element
|
|
|
|
|
var item = x.querySelector('item');
|
|
|
|
|
// By using querySelector above, we assume here there is
|
|
|
|
|
// one <item> per <x xmlns='http://jabber.org/protocol/muc#user'>
|
|
|
|
|
// element. This appears to be a safe assumption, since
|
|
|
|
|
// each <x/> element pertains to a single user.
|
|
|
|
|
if (!_.isNull(item)) {
|
|
|
|
|
var reason = item.querySelector('reason');
|
|
|
|
|
if (reason) {
|
|
|
|
|
notification.reason = reason ? reason.textContent : undefined;
|
|
|
|
|
}
|
|
|
|
|
var actor = item.querySelector('actor');
|
|
|
|
|
if (actor) {
|
|
|
|
|
notification.actor = actor ? actor.getAttribute('nick') : undefined;
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
return notification;
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-11-21 13:55:19 +01:00
|
|
|
displayNotificationsforUser: function (notification) {
|
|
|
|
|
/* Given the notification object generated by
|
|
|
|
|
* parseXUserElement, display any relevant messages and
|
|
|
|
|
* information to the user.
|
2016-03-19 23:16:00 +01:00
|
|
|
*/
|
2016-11-21 13:55:19 +01:00
|
|
|
var that = this;
|
|
|
|
|
if (notification.disconnected) {
|
|
|
|
|
this.showDisconnectMessage(notification.disconnection_message);
|
2016-11-21 14:10:36 +01:00
|
|
|
if (notification.actor) {
|
|
|
|
|
this.showDisconnectMessage(__(___('This action was done by <strong>%1$s</strong>.'), notification.actor));
|
|
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
if (notification.reason) {
|
2016-11-21 14:10:36 +01:00
|
|
|
this.showDisconnectMessage(__(___('The reason given is: <em>"%1$s"</em>.'), notification.reason));
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2016-12-04 14:39:09 +01:00
|
|
|
this.model.save('connection_status', Strophe.Status.DISCONNECTED);
|
2016-02-16 08:46:47 +01:00
|
|
|
return;
|
|
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
_.each(notification.messages, function (message) {
|
2016-12-20 10:30:20 +01:00
|
|
|
that.$content.append(_converse.templates.info({'message': message}));
|
2016-11-21 13:55:19 +01:00
|
|
|
});
|
|
|
|
|
if (notification.reason) {
|
|
|
|
|
this.showStatusNotification(__('The reason given is: "'+notification.reason+'"'), true);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
if (notification.messages.length) {
|
2016-05-27 14:53:07 +02:00
|
|
|
this.scrollDown();
|
|
|
|
|
}
|
2016-11-21 13:55:19 +01:00
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
showStatusMessages: function (stanza) {
|
2016-11-21 13:55:19 +01:00
|
|
|
/* Check for status codes and communicate their purpose to the user.
|
|
|
|
|
* See: http://xmpp.org/registrar/mucstatus.html
|
2016-12-03 17:39:59 +01:00
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) stanza: The message or presence stanza
|
|
|
|
|
* containing the status codes.
|
2016-11-21 13:55:19 +01:00
|
|
|
*/
|
2016-12-03 17:39:59 +01:00
|
|
|
var is_self = stanza.querySelectorAll("status[code='110']").length;
|
|
|
|
|
|
|
|
|
|
// Unfortunately this doesn't work (returns empty list)
|
|
|
|
|
// var elements = stanza.querySelectorAll('x[xmlns="'+Strophe.NS.MUC_USER+'"]');
|
2017-01-26 15:49:02 +01:00
|
|
|
var elements = _.filter(
|
|
|
|
|
stanza.querySelectorAll('x'),
|
|
|
|
|
function (x) {
|
|
|
|
|
return x.getAttribute('xmlns') === Strophe.NS.MUC_USER;
|
|
|
|
|
}
|
|
|
|
|
);
|
2016-11-21 13:55:19 +01:00
|
|
|
var notifications = _.map(
|
2016-11-30 18:39:53 +01:00
|
|
|
elements,
|
2016-12-02 18:41:05 +01:00
|
|
|
_.partial(this.parseXUserElement.bind(this), _, stanza, is_self)
|
2016-11-21 13:55:19 +01:00
|
|
|
);
|
|
|
|
|
_.each(notifications, this.displayNotificationsforUser.bind(this));
|
2016-12-02 18:41:05 +01:00
|
|
|
return stanza;
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-08-11 14:00:52 +02:00
|
|
|
showErrorMessage: function (presence) {
|
2016-02-16 08:46:47 +01:00
|
|
|
// We didn't enter the room, so we must remove it from the MUC
|
|
|
|
|
// add-on
|
2016-08-11 14:00:52 +02:00
|
|
|
var $error = $(presence).find('error');
|
2016-02-16 08:46:47 +01:00
|
|
|
if ($error.attr('type') === 'auth') {
|
|
|
|
|
if ($error.find('not-authorized').length) {
|
|
|
|
|
this.renderPasswordForm();
|
|
|
|
|
} else if ($error.find('registration-required').length) {
|
|
|
|
|
this.showDisconnectMessage(__('You are not on the member list of this room'));
|
|
|
|
|
} else if ($error.find('forbidden').length) {
|
|
|
|
|
this.showDisconnectMessage(__('You have been banned from this room'));
|
|
|
|
|
}
|
|
|
|
|
} else if ($error.attr('type') === 'modify') {
|
|
|
|
|
if ($error.find('jid-malformed').length) {
|
|
|
|
|
this.showDisconnectMessage(__('No nickname was specified'));
|
|
|
|
|
}
|
|
|
|
|
} else if ($error.attr('type') === 'cancel') {
|
|
|
|
|
if ($error.find('not-allowed').length) {
|
|
|
|
|
this.showDisconnectMessage(__('You are not allowed to create new rooms'));
|
|
|
|
|
} else if ($error.find('not-acceptable').length) {
|
|
|
|
|
this.showDisconnectMessage(__("Your nickname doesn't conform to this room's policies"));
|
|
|
|
|
} else if ($error.find('conflict').length) {
|
2016-08-11 14:00:52 +02:00
|
|
|
this.onNicknameClash(presence);
|
2016-02-16 08:46:47 +01:00
|
|
|
} else if ($error.find('item-not-found').length) {
|
|
|
|
|
this.showDisconnectMessage(__("This room does not (yet) exist"));
|
|
|
|
|
} else if ($error.find('service-unavailable').length) {
|
2016-04-04 12:34:23 +02:00
|
|
|
this.showDisconnectMessage(__("This room has reached its maximum number of occupants"));
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-20 01:59:52 +02:00
|
|
|
showSpinner: function () {
|
|
|
|
|
this.$('.chatroom-body').children().addClass('hidden');
|
|
|
|
|
this.$el.find('.chatroom-body').prepend('<span class="spinner centered"/>');
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-19 16:18:40 +02:00
|
|
|
hideSpinner: function () {
|
|
|
|
|
/* Check if the spinner is being shown and if so, hide it.
|
|
|
|
|
* Also make sure then that the chat area and occupants
|
|
|
|
|
* list are both visible.
|
|
|
|
|
*/
|
|
|
|
|
var that = this;
|
|
|
|
|
var $spinner = this.$el.find('.spinner');
|
|
|
|
|
if ($spinner.length) {
|
|
|
|
|
$spinner.hide(function () {
|
|
|
|
|
$(this).remove();
|
|
|
|
|
that.$el.find('.chat-area').removeClass('hidden');
|
|
|
|
|
that.$el.find('.occupants').removeClass('hidden');
|
2016-08-18 11:08:12 +02:00
|
|
|
that.scrollDown();
|
2016-07-19 16:18:40 +02:00
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-03 17:39:59 +01:00
|
|
|
createInstantRoom: function () {
|
|
|
|
|
/* Sends an empty IQ config stanza to inform the server that the
|
|
|
|
|
* room should be created with its default configuration.
|
|
|
|
|
*
|
2016-12-04 13:05:25 +01:00
|
|
|
* See http://xmpp.org/extensions/xep-0045.html#createroom-instant
|
2016-12-03 17:39:59 +01:00
|
|
|
*/
|
2017-02-14 17:55:32 +01:00
|
|
|
this.saveConfiguration().then(this.getRoomFeatures.bind(this));
|
2016-12-03 17:39:59 +01:00
|
|
|
},
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
onChatRoomPresence: function (pres) {
|
2016-12-03 17:39:59 +01:00
|
|
|
/* Handles all MUC presence stanzas.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) pres: The stanza
|
|
|
|
|
*/
|
2016-12-04 13:05:25 +01:00
|
|
|
if (pres.getAttribute('type') === 'error') {
|
2016-12-04 14:39:09 +01:00
|
|
|
this.model.save('connection_status', Strophe.Status.DISCONNECTED);
|
2016-08-11 14:00:52 +02:00
|
|
|
this.showErrorMessage(pres);
|
2016-12-04 13:05:25 +01:00
|
|
|
return true;
|
2016-12-05 11:50:01 +01:00
|
|
|
}
|
2016-12-04 13:05:25 +01:00
|
|
|
var show_status_messages = true;
|
|
|
|
|
var is_self = pres.querySelector("status[code='110']");
|
|
|
|
|
var new_room = pres.querySelector("status[code='201']");
|
|
|
|
|
|
|
|
|
|
if (is_self) {
|
2016-12-05 07:03:44 +01:00
|
|
|
this.saveAffiliationAndRole(pres);
|
2016-12-04 13:05:25 +01:00
|
|
|
}
|
|
|
|
|
if (is_self && new_room) {
|
|
|
|
|
// This is a new room. It will now be configured
|
|
|
|
|
// and the configuration cached on the
|
|
|
|
|
// Backbone.Model.
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.muc_instant_rooms) {
|
2016-12-04 13:05:25 +01:00
|
|
|
this.createInstantRoom(); // Accept default configuration
|
|
|
|
|
} else {
|
|
|
|
|
this.configureChatRoom();
|
|
|
|
|
if (!this.model.get('auto_configure')) {
|
|
|
|
|
// We don't show status messages if the
|
|
|
|
|
// configuration form is being shown.
|
|
|
|
|
show_status_messages = false;
|
2016-08-12 12:39:57 +02:00
|
|
|
}
|
2016-12-03 17:39:59 +01:00
|
|
|
}
|
2016-12-05 07:03:44 +01:00
|
|
|
} else if (!this.model.get('features_fetched') &&
|
|
|
|
|
this.model.get('connection_status') !== Strophe.Status.CONNECTED) {
|
|
|
|
|
// The features for this room weren't fetched yet, perhaps
|
|
|
|
|
// because it's a new room without locking (in which
|
|
|
|
|
// case Prosody doesn't send a 201 status).
|
|
|
|
|
// This is the first presence received for the room, so
|
|
|
|
|
// a good time to fetch the features.
|
|
|
|
|
this.getRoomFeatures();
|
2016-12-04 13:05:25 +01:00
|
|
|
}
|
|
|
|
|
if (show_status_messages) {
|
|
|
|
|
this.hideSpinner().showStatusMessages(pres);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2016-12-04 13:05:25 +01:00
|
|
|
this.occupantsview.updateOccupantsOnPresence(pres);
|
2016-12-05 07:03:44 +01:00
|
|
|
if (this.model.get('role') !== 'none') {
|
|
|
|
|
this.model.save('connection_status', Strophe.Status.CONNECTED);
|
|
|
|
|
}
|
2016-10-13 18:22:37 +02:00
|
|
|
return true;
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
|
|
|
|
|
2016-05-27 14:53:07 +02:00
|
|
|
setChatRoomSubject: function (sender, subject) {
|
|
|
|
|
this.$el.find('.chatroom-topic').text(subject).attr('title', subject);
|
|
|
|
|
// For translators: the %1$s and %2$s parts will get replaced by the user and topic text respectively
|
|
|
|
|
// Example: Topic set by JC Brand to: Hello World!
|
|
|
|
|
this.$content.append(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.info({
|
2016-05-27 14:53:07 +02:00
|
|
|
'message': __('Topic set by %1$s to: %2$s', sender, subject)
|
|
|
|
|
}));
|
|
|
|
|
this.scrollDown();
|
|
|
|
|
},
|
|
|
|
|
|
2016-11-24 02:07:32 +01:00
|
|
|
onChatRoomMessage: function (message) {
|
2016-12-04 13:05:25 +01:00
|
|
|
/* Given a <message> stanza, create a message
|
|
|
|
|
* Backbone.Model if appropriate.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) msg: The received message stanza
|
|
|
|
|
*/
|
2016-11-24 02:07:32 +01:00
|
|
|
var original_stanza = message,
|
|
|
|
|
forwarded = message.querySelector('forwarded'),
|
|
|
|
|
delay;
|
|
|
|
|
if (!_.isNull(forwarded)) {
|
|
|
|
|
message = forwarded.querySelector('message');
|
|
|
|
|
delay = forwarded.querySelector('delay');
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2016-11-24 02:07:32 +01:00
|
|
|
var jid = message.getAttribute('from'),
|
|
|
|
|
msgid = message.getAttribute('id'),
|
2016-02-16 08:46:47 +01:00
|
|
|
resource = Strophe.getResourceFromJid(jid),
|
|
|
|
|
sender = resource && Strophe.unescapeNode(resource) || '',
|
2016-11-24 02:07:32 +01:00
|
|
|
subject = _.propertyOf(message.querySelector('subject'))('textContent'),
|
2016-05-25 10:31:35 +02:00
|
|
|
dupes = msgid && this.model.messages.filter(function (msg) {
|
|
|
|
|
// Find duplicates.
|
|
|
|
|
// Some bots (like HAL in the prosody chatroom)
|
|
|
|
|
// respond to commands with the same ID as the
|
|
|
|
|
// original message. So we also check the sender.
|
|
|
|
|
return msg.get('msgid') === msgid && msg.get('fullname') === sender;
|
|
|
|
|
});
|
2016-05-25 11:22:27 +02:00
|
|
|
if (dupes && dupes.length) {
|
2016-05-25 10:31:35 +02:00
|
|
|
return true;
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
if (subject) {
|
2016-05-27 14:53:07 +02:00
|
|
|
this.setChatRoomSubject(sender, subject);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
if (sender === '') {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2016-11-24 02:07:32 +01:00
|
|
|
this.model.createMessage(message, delay, original_stanza);
|
2016-02-16 08:46:47 +01:00
|
|
|
if (sender !== this.model.get('nick')) {
|
|
|
|
|
// We only emit an event if it's not our own message
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.emit('message', message);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
},
|
2016-03-14 17:04:27 +01:00
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
fetchArchivedMessages: function (options) {
|
|
|
|
|
/* Fetch archived chat messages from the XMPP server.
|
2016-03-19 23:16:00 +01:00
|
|
|
*
|
|
|
|
|
* Then, upon receiving them, call onChatRoomMessage
|
|
|
|
|
* so that they are displayed inside it.
|
|
|
|
|
*/
|
2016-12-04 15:44:43 +01:00
|
|
|
var that = this;
|
2016-12-20 10:30:20 +01:00
|
|
|
if (!_converse.features.findWhere({'var': Strophe.NS.MAM})) {
|
|
|
|
|
_converse.log("Attempted to fetch archived messages but this user's server doesn't support XEP-0313");
|
2016-02-16 08:46:47 +01:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
this.addSpinner();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.api.archive.query(_.extend(options, {'groupchat': true}),
|
2016-02-16 08:46:47 +01:00
|
|
|
function (messages) {
|
2016-12-04 15:44:43 +01:00
|
|
|
that.clearSpinner();
|
2016-02-16 08:46:47 +01:00
|
|
|
if (messages.length) {
|
2017-01-26 15:49:02 +01:00
|
|
|
_.each(messages, that.onChatRoomMessage.bind(that));
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2016-12-04 15:44:43 +01:00
|
|
|
},
|
2016-02-16 08:46:47 +01:00
|
|
|
function () {
|
2016-12-04 15:44:43 +01:00
|
|
|
that.clearSpinner();
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.log("Error while trying to fetch archived messages", "error");
|
2016-12-04 15:44:43 +01:00
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatRoomOccupant = Backbone.Model.extend({
|
2016-07-19 14:45:25 +02:00
|
|
|
initialize: function (attributes) {
|
|
|
|
|
this.set(_.extend({
|
2016-12-20 10:30:20 +01:00
|
|
|
'id': _converse.connection.getUniqueId(),
|
2016-07-19 14:45:25 +02:00
|
|
|
}, attributes));
|
2016-07-18 16:11:04 +02:00
|
|
|
}
|
|
|
|
|
});
|
2016-07-19 14:45:25 +02:00
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatRoomOccupantView = Backbone.View.extend({
|
2016-02-19 10:36:01 +01:00
|
|
|
tagName: 'li',
|
|
|
|
|
initialize: function () {
|
|
|
|
|
this.model.on('change', this.render, this);
|
|
|
|
|
this.model.on('destroy', this.destroy, this);
|
|
|
|
|
},
|
2016-07-26 11:04:05 +02:00
|
|
|
|
2016-02-19 10:36:01 +01:00
|
|
|
render: function () {
|
2016-12-20 10:30:20 +01:00
|
|
|
var new_el = _converse.templates.occupant(
|
2016-07-26 08:59:34 +02:00
|
|
|
_.extend(
|
|
|
|
|
this.model.toJSON(), {
|
2016-07-26 11:04:05 +02:00
|
|
|
'hint_occupant': __('Click to mention this user in your message.'),
|
|
|
|
|
'desc_moderator': __('This user is a moderator.'),
|
|
|
|
|
'desc_occupant': __('This user can send messages in this room.'),
|
|
|
|
|
'desc_visitor': __('This user can NOT send messages in this room.')
|
2016-07-26 08:59:34 +02:00
|
|
|
})
|
2016-02-19 10:36:01 +01:00
|
|
|
);
|
2016-07-18 16:11:04 +02:00
|
|
|
var $parents = this.$el.parents();
|
|
|
|
|
if ($parents.length) {
|
|
|
|
|
this.$el.replaceWith(new_el);
|
|
|
|
|
this.setElement($parents.first().children('#'+this.model.get('id')), true);
|
|
|
|
|
this.delegateEvents();
|
|
|
|
|
} else {
|
|
|
|
|
this.$el.replaceWith(new_el);
|
|
|
|
|
this.setElement(new_el, true);
|
|
|
|
|
}
|
2016-02-19 10:36:01 +01:00
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
destroy: function () {
|
|
|
|
|
this.$el.remove();
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatRoomOccupants = Backbone.Collection.extend({
|
|
|
|
|
model: _converse.ChatRoomOccupant
|
2016-02-19 10:36:01 +01:00
|
|
|
});
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.ChatRoomOccupantsView = Backbone.Overview.extend({
|
2016-02-19 10:36:01 +01:00
|
|
|
tagName: 'div',
|
|
|
|
|
className: 'occupants',
|
|
|
|
|
|
|
|
|
|
initialize: function () {
|
|
|
|
|
this.model.on("add", this.onOccupantAdded, this);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
render: function () {
|
|
|
|
|
this.$el.html(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.chatroom_sidebar({
|
|
|
|
|
'allow_muc_invitations': _converse.allow_muc_invitations,
|
2016-04-07 12:35:07 +02:00
|
|
|
'label_invitation': __('Invite'),
|
2016-02-19 10:36:01 +01:00
|
|
|
'label_occupants': __('Occupants')
|
|
|
|
|
})
|
|
|
|
|
);
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.allow_muc_invitations) {
|
2017-02-14 11:19:01 +01:00
|
|
|
_converse.api.waitUntil('rosterContactsFetched').then(this.initInviteWidget.bind(this));
|
2016-06-10 16:13:52 +02:00
|
|
|
}
|
|
|
|
|
return this;
|
2016-02-19 10:36:01 +01:00
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onOccupantAdded: function (item) {
|
2016-07-19 15:04:02 +02:00
|
|
|
var view = this.get(item.get('id'));
|
2016-02-19 10:36:01 +01:00
|
|
|
if (!view) {
|
2016-12-20 10:30:20 +01:00
|
|
|
view = this.add(item.get('id'), new _converse.ChatRoomOccupantView({model: item}));
|
2016-02-19 10:36:01 +01:00
|
|
|
} else {
|
|
|
|
|
delete view.model; // Remove ref to old model to help garbage collection
|
|
|
|
|
view.model = item;
|
|
|
|
|
view.initialize();
|
|
|
|
|
}
|
|
|
|
|
this.$('.occupant-list').append(view.render().$el);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
parsePresence: function (pres) {
|
|
|
|
|
var id = Strophe.getResourceFromJid(pres.getAttribute("from"));
|
|
|
|
|
var data = {
|
|
|
|
|
nick: id,
|
|
|
|
|
type: pres.getAttribute("type"),
|
|
|
|
|
states: []
|
|
|
|
|
};
|
|
|
|
|
_.each(pres.childNodes, function (child) {
|
|
|
|
|
switch (child.nodeName) {
|
|
|
|
|
case "status":
|
|
|
|
|
data.status = child.textContent || null;
|
|
|
|
|
break;
|
|
|
|
|
case "show":
|
|
|
|
|
data.show = child.textContent || null;
|
|
|
|
|
break;
|
|
|
|
|
case "x":
|
|
|
|
|
if (child.getAttribute("xmlns") === Strophe.NS.MUC_USER) {
|
|
|
|
|
_.each(child.childNodes, function (item) {
|
|
|
|
|
switch (item.nodeName) {
|
|
|
|
|
case "item":
|
|
|
|
|
data.affiliation = item.getAttribute("affiliation");
|
|
|
|
|
data.role = item.getAttribute("role");
|
|
|
|
|
data.jid = item.getAttribute("jid");
|
|
|
|
|
data.nick = item.getAttribute("nick") || data.nick;
|
|
|
|
|
break;
|
|
|
|
|
case "status":
|
|
|
|
|
if (item.getAttribute("code")) {
|
|
|
|
|
data.states.push(item.getAttribute("code"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return data;
|
|
|
|
|
},
|
|
|
|
|
|
2016-07-19 15:04:02 +02:00
|
|
|
findOccupant: function (data) {
|
|
|
|
|
/* Try to find an existing occupant based on the passed in
|
|
|
|
|
* data object.
|
|
|
|
|
*
|
|
|
|
|
* If we have a JID, we use that as lookup variable,
|
|
|
|
|
* otherwise we use the nick. We don't always have both,
|
|
|
|
|
* but should have at least one or the other.
|
|
|
|
|
*/
|
2016-07-18 16:11:04 +02:00
|
|
|
var jid = Strophe.getBareJidFromJid(data.jid);
|
|
|
|
|
if (jid !== null) {
|
2016-07-19 15:04:02 +02:00
|
|
|
return this.model.where({'jid': jid}).pop();
|
2016-07-18 16:11:04 +02:00
|
|
|
} else {
|
2016-07-19 15:04:02 +02:00
|
|
|
return this.model.where({'nick': data.nick}).pop();
|
2016-07-18 16:11:04 +02:00
|
|
|
}
|
2016-07-19 15:04:02 +02:00
|
|
|
},
|
2016-07-18 16:11:04 +02:00
|
|
|
|
2016-07-19 15:04:02 +02:00
|
|
|
updateOccupantsOnPresence: function (pres) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Given a presence stanza, update the occupant models
|
|
|
|
|
* based on its contents.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) pres: The presence stanza
|
|
|
|
|
*/
|
2016-07-19 15:04:02 +02:00
|
|
|
var data = this.parsePresence(pres);
|
|
|
|
|
if (data.type === 'error') {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
var occupant = this.findOccupant(data);
|
2016-02-19 10:36:01 +01:00
|
|
|
switch (data.type) {
|
|
|
|
|
case 'unavailable':
|
2016-07-26 08:59:34 +02:00
|
|
|
if (occupant) { occupant.destroy(); }
|
2016-02-19 10:36:01 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
2016-07-26 08:59:34 +02:00
|
|
|
var jid = Strophe.getBareJidFromJid(data.jid);
|
|
|
|
|
var attributes = _.extend(data, {
|
2016-07-18 16:11:04 +02:00
|
|
|
'jid': jid ? jid : undefined,
|
2016-07-26 08:59:34 +02:00
|
|
|
'resource': data.jid ? Strophe.getResourceFromJid(data.jid) : undefined
|
2016-07-18 16:11:04 +02:00
|
|
|
});
|
2016-02-19 10:36:01 +01:00
|
|
|
if (occupant) {
|
2016-07-18 16:11:04 +02:00
|
|
|
occupant.save(attributes);
|
2016-02-19 10:36:01 +01:00
|
|
|
} else {
|
2016-07-18 16:11:04 +02:00
|
|
|
this.model.create(attributes);
|
2016-02-19 10:36:01 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
2017-02-14 14:33:31 +01:00
|
|
|
promptForInvite: function (suggestion) {
|
|
|
|
|
var reason = prompt(
|
|
|
|
|
__(___('You are about to invite %1$s to the chat room "%2$s". '), suggestion.text.label, this.model.get('id')) +
|
|
|
|
|
__("You may optionally include a message, explaining the reason for the invitation.")
|
|
|
|
|
);
|
|
|
|
|
if (reason !== null) {
|
|
|
|
|
this.chatroomview.directInvite(suggestion.text.value, reason);
|
|
|
|
|
}
|
|
|
|
|
suggestion.target.value = '';
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
inviteFormSubmitted: function (evt) {
|
|
|
|
|
evt.preventDefault();
|
|
|
|
|
var el = evt.target.querySelector('input.invited-contact');
|
|
|
|
|
this.promptForInvite({
|
|
|
|
|
'target': el,
|
|
|
|
|
'text': {
|
|
|
|
|
'label': el.value,
|
|
|
|
|
'value': el.value
|
|
|
|
|
}});
|
|
|
|
|
},
|
|
|
|
|
|
2016-02-19 10:36:01 +01:00
|
|
|
initInviteWidget: function () {
|
2017-02-14 14:33:31 +01:00
|
|
|
var form = this.el.querySelector('form.room-invite');
|
|
|
|
|
form.addEventListener('submit', this.inviteFormSubmitted.bind(this));
|
2017-02-14 11:19:01 +01:00
|
|
|
var el = this.el.querySelector('input.invited-contact');
|
|
|
|
|
var list = _converse.roster.map(function (item) {
|
|
|
|
|
var label = item.get('fullname') || item.get('jid');
|
|
|
|
|
return {'label': label, 'value':item.get('jid')};
|
|
|
|
|
});
|
|
|
|
|
var awesomplete = new Awesomplete(el, {
|
|
|
|
|
'minChars': 1,
|
|
|
|
|
'list': list
|
2016-02-19 10:36:01 +01:00
|
|
|
});
|
2017-02-14 14:33:31 +01:00
|
|
|
el.addEventListener('awesomplete-selectcomplete', this.promptForInvite.bind(this));
|
2016-02-19 10:36:01 +01:00
|
|
|
return this;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.RoomsPanel = Backbone.View.extend({
|
2016-02-16 08:46:47 +01:00
|
|
|
/* Backbone View which renders the "Rooms" tab and accompanying
|
2016-03-19 23:16:00 +01:00
|
|
|
* panel in the control box.
|
|
|
|
|
*
|
|
|
|
|
* In this panel, chat rooms can be listed, joined and new rooms
|
|
|
|
|
* can be created.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
tagName: 'div',
|
|
|
|
|
className: 'controlbox-pane',
|
|
|
|
|
id: 'chatrooms',
|
|
|
|
|
events: {
|
|
|
|
|
'submit form.add-chatroom': 'createChatRoom',
|
|
|
|
|
'click input#show-rooms': 'showRooms',
|
|
|
|
|
'click a.open-room': 'createChatRoom',
|
2016-10-18 11:04:36 +02:00
|
|
|
'click a.room-info': 'toggleRoomInfo',
|
2016-02-16 08:46:47 +01:00
|
|
|
'change input[name=server]': 'setDomain',
|
|
|
|
|
'change input[name=nick]': 'setNick'
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
initialize: function (cfg) {
|
|
|
|
|
this.$parent = cfg.$parent;
|
|
|
|
|
this.model.on('change:muc_domain', this.onDomainChange, this);
|
|
|
|
|
this.model.on('change:nick', this.onNickChange, this);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
render: function () {
|
|
|
|
|
this.$parent.append(
|
|
|
|
|
this.$el.html(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.room_panel({
|
|
|
|
|
'server_input_type': _converse.hide_muc_server && 'hidden' || 'text',
|
|
|
|
|
'server_label_global_attr': _converse.hide_muc_server && ' hidden' || '',
|
2016-02-16 08:46:47 +01:00
|
|
|
'label_room_name': __('Room name'),
|
|
|
|
|
'label_nickname': __('Nickname'),
|
|
|
|
|
'label_server': __('Server'),
|
|
|
|
|
'label_join': __('Join Room'),
|
|
|
|
|
'label_show_rooms': __('Show rooms')
|
|
|
|
|
})
|
2016-11-02 23:08:20 +01:00
|
|
|
));
|
2016-02-16 08:46:47 +01:00
|
|
|
this.$tabs = this.$parent.parent().find('#controlbox-tabs');
|
2016-11-02 23:08:20 +01:00
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
var controlbox = _converse.chatboxes.get('controlbox');
|
|
|
|
|
this.$tabs.append(_converse.templates.chatrooms_tab({
|
2016-11-02 23:08:20 +01:00
|
|
|
'label_rooms': __('Rooms'),
|
|
|
|
|
'is_current': controlbox.get('active-panel') === ROOMS_PANEL_ID
|
|
|
|
|
}));
|
|
|
|
|
if (controlbox.get('active-panel') !== ROOMS_PANEL_ID) {
|
|
|
|
|
this.$el.addClass('hidden');
|
|
|
|
|
}
|
2016-02-16 08:46:47 +01:00
|
|
|
return this;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onDomainChange: function (model) {
|
|
|
|
|
var $server = this.$el.find('input.new-chatroom-server');
|
|
|
|
|
$server.val(model.get('muc_domain'));
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.auto_list_rooms) {
|
2016-02-16 08:46:47 +01:00
|
|
|
this.updateRoomsList();
|
|
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onNickChange: function (model) {
|
|
|
|
|
var $nick = this.$el.find('input.new-chatroom-nick');
|
|
|
|
|
$nick.val(model.get('nick'));
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
informNoRoomsFound: function () {
|
|
|
|
|
var $available_chatrooms = this.$el.find('#available-chatrooms');
|
|
|
|
|
// For translators: %1$s is a variable and will be replaced with the XMPP server name
|
|
|
|
|
$available_chatrooms.html('<dt>'+__('No rooms on %1$s',this.model.get('muc_domain'))+'</dt>');
|
|
|
|
|
$('input#show-rooms').show().siblings('span.spinner').remove();
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
onRoomsFound: function (iq) {
|
|
|
|
|
/* Handle the IQ stanza returned from the server, containing
|
2016-03-19 23:16:00 +01:00
|
|
|
* all its public rooms.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
var name, jid, i, fragment,
|
|
|
|
|
$available_chatrooms = this.$el.find('#available-chatrooms');
|
|
|
|
|
this.rooms = $(iq).find('query').find('item');
|
|
|
|
|
if (this.rooms.length) {
|
|
|
|
|
// For translators: %1$s is a variable and will be
|
|
|
|
|
// replaced with the XMPP server name
|
|
|
|
|
$available_chatrooms.html('<dt>'+__('Rooms on %1$s',this.model.get('muc_domain'))+'</dt>');
|
|
|
|
|
fragment = document.createDocumentFragment();
|
|
|
|
|
for (i=0; i<this.rooms.length; i++) {
|
|
|
|
|
name = Strophe.unescapeNode($(this.rooms[i]).attr('name')||$(this.rooms[i]).attr('jid'));
|
|
|
|
|
jid = $(this.rooms[i]).attr('jid');
|
|
|
|
|
fragment.appendChild($(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.room_item({
|
2016-02-16 08:46:47 +01:00
|
|
|
'name':name,
|
|
|
|
|
'jid':jid,
|
|
|
|
|
'open_title': __('Click to open this room'),
|
|
|
|
|
'info_title': __('Show more information on this room')
|
|
|
|
|
})
|
|
|
|
|
)[0]);
|
|
|
|
|
}
|
|
|
|
|
$available_chatrooms.append(fragment);
|
|
|
|
|
$('input#show-rooms').show().siblings('span.spinner').remove();
|
|
|
|
|
} else {
|
|
|
|
|
this.informNoRoomsFound();
|
|
|
|
|
}
|
|
|
|
|
return true;
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
updateRoomsList: function () {
|
|
|
|
|
/* Send and IQ stanza to the server asking for all rooms
|
2016-03-19 23:16:00 +01:00
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.sendIQ(
|
2016-02-16 08:46:47 +01:00
|
|
|
$iq({
|
|
|
|
|
to: this.model.get('muc_domain'),
|
2016-12-20 10:30:20 +01:00
|
|
|
from: _converse.connection.jid,
|
2016-02-16 08:46:47 +01:00
|
|
|
type: "get"
|
|
|
|
|
}).c("query", {xmlns: Strophe.NS.DISCO_ITEMS}),
|
|
|
|
|
this.onRoomsFound.bind(this),
|
|
|
|
|
this.informNoRoomsFound.bind(this)
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
showRooms: function () {
|
|
|
|
|
var $available_chatrooms = this.$el.find('#available-chatrooms');
|
|
|
|
|
var $server = this.$el.find('input.new-chatroom-server');
|
|
|
|
|
var server = $server.val();
|
|
|
|
|
if (!server) {
|
|
|
|
|
$server.addClass('error');
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
this.$el.find('input.new-chatroom-name').removeClass('error');
|
|
|
|
|
$server.removeClass('error');
|
|
|
|
|
$available_chatrooms.empty();
|
|
|
|
|
$('input#show-rooms').hide().after('<span class="spinner"/>');
|
|
|
|
|
this.model.save({muc_domain: server});
|
|
|
|
|
this.updateRoomsList();
|
|
|
|
|
},
|
|
|
|
|
|
2016-12-04 13:05:25 +01:00
|
|
|
insertRoomInfo: function (el, stanza) {
|
2016-10-18 11:04:36 +02:00
|
|
|
/* Insert room info (based on returned #disco IQ stanza)
|
2016-12-04 13:05:25 +01:00
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (HTMLElement) el: The HTML DOM element that should
|
|
|
|
|
* contain the info.
|
|
|
|
|
* (XMLElement) stanza: The IQ stanza containing the room
|
|
|
|
|
* info.
|
2016-10-18 11:04:36 +02:00
|
|
|
*/
|
|
|
|
|
var $stanza = $(stanza);
|
|
|
|
|
// All MUC features found here: http://xmpp.org/registrar/disco-features.html
|
2016-12-04 13:05:25 +01:00
|
|
|
$(el).find('span.spinner').replaceWith(
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.templates.room_description({
|
2016-10-18 11:04:36 +02:00
|
|
|
'desc': $stanza.find('field[var="muc#roominfo_description"] value').text(),
|
|
|
|
|
'occ': $stanza.find('field[var="muc#roominfo_occupants"] value').text(),
|
|
|
|
|
'hidden': $stanza.find('feature[var="muc_hidden"]').length,
|
|
|
|
|
'membersonly': $stanza.find('feature[var="muc_membersonly"]').length,
|
|
|
|
|
'moderated': $stanza.find('feature[var="muc_moderated"]').length,
|
|
|
|
|
'nonanonymous': $stanza.find('feature[var="muc_nonanonymous"]').length,
|
|
|
|
|
'open': $stanza.find('feature[var="muc_open"]').length,
|
|
|
|
|
'passwordprotected': $stanza.find('feature[var="muc_passwordprotected"]').length,
|
|
|
|
|
'persistent': $stanza.find('feature[var="muc_persistent"]').length,
|
|
|
|
|
'publicroom': $stanza.find('feature[var="muc_public"]').length,
|
|
|
|
|
'semianonymous': $stanza.find('feature[var="muc_semianonymous"]').length,
|
|
|
|
|
'temporary': $stanza.find('feature[var="muc_temporary"]').length,
|
|
|
|
|
'unmoderated': $stanza.find('feature[var="muc_unmoderated"]').length,
|
|
|
|
|
'label_desc': __('Description:'),
|
|
|
|
|
'label_occ': __('Occupants:'),
|
|
|
|
|
'label_features': __('Features:'),
|
|
|
|
|
'label_requires_auth': __('Requires authentication'),
|
|
|
|
|
'label_hidden': __('Hidden'),
|
|
|
|
|
'label_requires_invite': __('Requires an invitation'),
|
|
|
|
|
'label_moderated': __('Moderated'),
|
|
|
|
|
'label_non_anon': __('Non-anonymous'),
|
|
|
|
|
'label_open_room': __('Open room'),
|
|
|
|
|
'label_permanent_room': __('Permanent room'),
|
|
|
|
|
'label_public': __('Public'),
|
|
|
|
|
'label_semi_anon': __('Semi-anonymous'),
|
|
|
|
|
'label_temp_room': __('Temporary room'),
|
|
|
|
|
'label_unmoderated': __('Unmoderated')
|
|
|
|
|
})
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
toggleRoomInfo: function (ev) {
|
|
|
|
|
/* Show/hide extra information about a room in the listing.
|
|
|
|
|
*/
|
2016-02-16 08:46:47 +01:00
|
|
|
var target = ev.target,
|
2016-10-06 09:02:29 +02:00
|
|
|
$parent = $(target).parent('dd'),
|
|
|
|
|
$div = $parent.find('div.room-info');
|
2016-02-16 08:46:47 +01:00
|
|
|
if ($div.length) {
|
|
|
|
|
$div.remove();
|
|
|
|
|
} else {
|
2016-10-06 09:02:29 +02:00
|
|
|
$parent.find('span.spinner').remove();
|
|
|
|
|
$parent.append('<span class="spinner hor_centered"/>');
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.disco.info(
|
2016-12-04 13:05:25 +01:00
|
|
|
$(target).attr('data-room-jid'), null, _.partial(this.insertRoomInfo, $parent[0])
|
2016-10-18 11:04:36 +02:00
|
|
|
);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
createChatRoom: function (ev) {
|
|
|
|
|
ev.preventDefault();
|
2016-10-06 09:02:29 +02:00
|
|
|
var name, $name, server, $server, jid;
|
2016-02-16 08:46:47 +01:00
|
|
|
if (ev.type === 'click') {
|
|
|
|
|
name = $(ev.target).text();
|
|
|
|
|
jid = $(ev.target).attr('data-room-jid');
|
|
|
|
|
} else {
|
|
|
|
|
$name = this.$el.find('input.new-chatroom-name');
|
|
|
|
|
$server= this.$el.find('input.new-chatroom-server');
|
|
|
|
|
server = $server.val();
|
|
|
|
|
name = $name.val().trim();
|
|
|
|
|
$name.val(''); // Clear the input
|
|
|
|
|
if (name && server) {
|
|
|
|
|
jid = Strophe.escapeNode(name.toLowerCase()) + '@' + server.toLowerCase();
|
|
|
|
|
$name.removeClass('error');
|
|
|
|
|
$server.removeClass('error');
|
|
|
|
|
this.model.save({muc_domain: server});
|
|
|
|
|
} else {
|
|
|
|
|
if (!name) { $name.addClass('error'); }
|
|
|
|
|
if (!server) { $server.addClass('error'); }
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.createChatRoom({
|
2016-02-16 08:46:47 +01:00
|
|
|
'id': jid,
|
|
|
|
|
'jid': jid,
|
|
|
|
|
'name': name || Strophe.unescapeNode(Strophe.getNodeFromJid(jid)),
|
2016-03-21 10:57:38 +01:00
|
|
|
'type': 'chatroom',
|
2016-02-16 08:46:47 +01:00
|
|
|
'box_id': b64_sha1(jid)
|
|
|
|
|
});
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
setDomain: function (ev) {
|
|
|
|
|
this.model.save({muc_domain: ev.target.value});
|
|
|
|
|
},
|
|
|
|
|
|
|
|
|
|
setNick: function (ev) {
|
|
|
|
|
this.model.save({nick: ev.target.value});
|
|
|
|
|
}
|
|
|
|
|
});
|
2016-12-04 10:43:39 +01:00
|
|
|
/************************ End of ChatRoomView **********************/
|
|
|
|
|
|
2016-02-16 08:46:47 +01:00
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.onDirectMUCInvitation = function (message) {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* A direct MUC invitation to join a room has been received
|
|
|
|
|
* See XEP-0249: Direct MUC invitations.
|
|
|
|
|
*
|
|
|
|
|
* Parameters:
|
|
|
|
|
* (XMLElement) message: The message stanza containing the
|
|
|
|
|
* invitation.
|
|
|
|
|
*/
|
2016-03-22 08:49:25 +01:00
|
|
|
var $message = $(message),
|
|
|
|
|
$x = $message.children('x[xmlns="jabber:x:conference"]'),
|
|
|
|
|
from = Strophe.getBareJidFromJid($message.attr('from')),
|
|
|
|
|
room_jid = $x.attr('jid'),
|
|
|
|
|
reason = $x.attr('reason'),
|
2016-12-20 10:30:20 +01:00
|
|
|
contact = _converse.roster.get(from),
|
2016-03-22 08:49:25 +01:00
|
|
|
result;
|
|
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.auto_join_on_invite) {
|
2016-03-22 08:49:25 +01:00
|
|
|
result = true;
|
|
|
|
|
} else {
|
|
|
|
|
// Invite request might come from someone not your roster list
|
|
|
|
|
contact = contact? contact.get('fullname'): Strophe.getNodeFromJid(from);
|
|
|
|
|
if (!reason) {
|
|
|
|
|
result = confirm(
|
|
|
|
|
__(___("%1$s has invited you to join a chat room: %2$s"),
|
|
|
|
|
contact, room_jid)
|
|
|
|
|
);
|
|
|
|
|
} else {
|
|
|
|
|
result = confirm(
|
|
|
|
|
__(___('%1$s has invited you to join a chat room: %2$s, and left the following reason: "%3$s"'),
|
|
|
|
|
contact, room_jid, reason)
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (result === true) {
|
2016-12-20 10:30:20 +01:00
|
|
|
var chatroom = _converse.createChatRoom({
|
2016-03-22 08:49:25 +01:00
|
|
|
'id': room_jid,
|
|
|
|
|
'jid': room_jid,
|
|
|
|
|
'name': Strophe.unescapeNode(Strophe.getNodeFromJid(room_jid)),
|
2016-12-20 10:30:20 +01:00
|
|
|
'nick': Strophe.unescapeNode(Strophe.getNodeFromJid(_converse.connection.jid)),
|
2016-03-22 08:49:25 +01:00
|
|
|
'type': 'chatroom',
|
|
|
|
|
'box_id': b64_sha1(room_jid),
|
|
|
|
|
'password': $x.attr('password')
|
|
|
|
|
});
|
2017-01-26 15:49:02 +01:00
|
|
|
if (!_.includes(
|
2016-03-22 08:49:25 +01:00
|
|
|
[Strophe.Status.CONNECTING, Strophe.Status.CONNECTED],
|
|
|
|
|
chatroom.get('connection_status'))
|
|
|
|
|
) {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.chatboxviews.get(room_jid).join();
|
2016-03-22 08:49:25 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
};
|
2016-04-05 13:23:16 +02:00
|
|
|
|
2016-12-20 10:30:20 +01:00
|
|
|
if (_converse.allow_muc_invitations) {
|
2016-12-04 10:43:39 +01:00
|
|
|
var registerDirectInvitationHandler = function () {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.connection.addHandler(
|
2016-12-04 10:43:39 +01:00
|
|
|
function (message) {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.onDirectMUCInvitation(message);
|
2016-12-04 10:43:39 +01:00
|
|
|
return true;
|
|
|
|
|
}, 'jabber:x:conference', 'message');
|
|
|
|
|
};
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.on('connected', registerDirectInvitationHandler);
|
|
|
|
|
_converse.on('reconnected', registerDirectInvitationHandler);
|
2016-12-04 10:43:39 +01:00
|
|
|
}
|
|
|
|
|
|
2016-04-05 13:23:16 +02:00
|
|
|
var autoJoinRooms = function () {
|
2016-12-04 10:43:39 +01:00
|
|
|
/* Automatically join chat rooms, based on the
|
|
|
|
|
* "auto_join_rooms" configuration setting, which is an array
|
|
|
|
|
* of strings (room JIDs) or objects (with room JID and other
|
|
|
|
|
* settings).
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_.each(_converse.auto_join_rooms, function (room) {
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isString(room)) {
|
2017-02-02 19:29:38 +01:00
|
|
|
_converse.api.rooms.open(room);
|
2017-01-26 15:49:02 +01:00
|
|
|
} else if (_.isObject(room)) {
|
2017-02-02 19:29:38 +01:00
|
|
|
_converse.api.rooms.open(room.jid, room.nick);
|
2016-03-22 09:15:52 +01:00
|
|
|
} else {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.log('Invalid room criteria specified for "auto_join_rooms"', 'error');
|
2016-03-22 09:15:52 +01:00
|
|
|
}
|
|
|
|
|
});
|
2016-03-22 08:49:25 +01:00
|
|
|
};
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.on('chatBoxesFetched', autoJoinRooms);
|
2016-04-05 13:23:16 +02:00
|
|
|
|
2017-02-14 15:58:29 +01:00
|
|
|
_converse.getChatRoom = function (jid, attrs, fetcher) {
|
2016-06-16 17:20:11 +02:00
|
|
|
jid = jid.toLowerCase();
|
2017-02-14 15:58:29 +01:00
|
|
|
return _converse.getViewForChatBox(fetcher(_.extend({
|
2016-06-16 17:20:11 +02:00
|
|
|
'id': jid,
|
|
|
|
|
'jid': jid,
|
|
|
|
|
'name': Strophe.unescapeNode(Strophe.getNodeFromJid(jid)),
|
|
|
|
|
'type': 'chatroom',
|
|
|
|
|
'box_id': b64_sha1(jid)
|
2016-08-19 17:16:36 +02:00
|
|
|
}, attrs)));
|
2016-06-16 17:20:11 +02:00
|
|
|
};
|
|
|
|
|
|
2016-03-22 08:49:25 +01:00
|
|
|
/* We extend the default converse.js API to add methods specific to MUC
|
|
|
|
|
* chat rooms.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_.extend(_converse.api, {
|
2016-02-16 08:46:47 +01:00
|
|
|
'rooms': {
|
2016-06-03 10:22:31 +02:00
|
|
|
'close': function (jids) {
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isUndefined(jids)) {
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.chatboxviews.each(function (view) {
|
2016-06-03 10:22:31 +02:00
|
|
|
if (view.is_chatroom && view.model) {
|
|
|
|
|
view.close();
|
|
|
|
|
}
|
|
|
|
|
});
|
2017-01-26 15:49:02 +01:00
|
|
|
} else if (_.isString(jids)) {
|
2016-12-20 10:30:20 +01:00
|
|
|
var view = _converse.chatboxviews.get(jids);
|
2016-06-03 10:22:31 +02:00
|
|
|
if (view) { view.close(); }
|
|
|
|
|
} else {
|
2017-01-26 15:49:02 +01:00
|
|
|
_.each(jids, function (jid) {
|
2016-12-20 10:30:20 +01:00
|
|
|
var view = _converse.chatboxviews.get(jid);
|
2016-06-03 10:22:31 +02:00
|
|
|
if (view) { view.close(); }
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
},
|
2016-08-19 17:16:36 +02:00
|
|
|
'open': function (jids, attrs) {
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isString(attrs)) {
|
2016-08-19 17:16:36 +02:00
|
|
|
attrs = {'nick': attrs};
|
2017-01-26 15:49:02 +01:00
|
|
|
} else if (_.isUndefined(attrs)) {
|
2016-08-19 17:16:36 +02:00
|
|
|
attrs = {};
|
|
|
|
|
}
|
2016-11-30 11:00:12 +01:00
|
|
|
if (_.isUndefined(attrs.maximize)) {
|
|
|
|
|
attrs.maximize = false;
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
if (!attrs.nick && _converse.muc_nickname_from_jid) {
|
|
|
|
|
attrs.nick = Strophe.getNodeFromJid(_converse.bare_jid);
|
2016-10-13 18:22:37 +02:00
|
|
|
}
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isUndefined(jids)) {
|
2016-02-16 08:46:47 +01:00
|
|
|
throw new TypeError('rooms.open: You need to provide at least one JID');
|
2017-01-26 15:49:02 +01:00
|
|
|
} else if (_.isString(jids)) {
|
2017-02-14 15:58:29 +01:00
|
|
|
return _converse.getChatRoom(jids, attrs, _converse.createChatRoom);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2017-02-14 15:58:29 +01:00
|
|
|
return _.map(jids, _.partial(_converse.getChatRoom, _, attrs, _converse.createChatRoom));
|
2016-02-16 08:46:47 +01:00
|
|
|
},
|
2016-08-19 17:16:36 +02:00
|
|
|
'get': function (jids, attrs, create) {
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isString(attrs)) {
|
2016-08-19 17:16:36 +02:00
|
|
|
attrs = {'nick': attrs};
|
2017-01-26 15:49:02 +01:00
|
|
|
} else if (_.isUndefined(attrs)) {
|
2016-08-19 17:16:36 +02:00
|
|
|
attrs = {};
|
|
|
|
|
}
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isUndefined(jids)) {
|
2016-06-24 10:54:39 +02:00
|
|
|
var result = [];
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.chatboxes.each(function (chatbox) {
|
2016-06-24 10:54:39 +02:00
|
|
|
if (chatbox.get('type') === 'chatroom') {
|
2017-02-14 15:58:29 +01:00
|
|
|
result.push(_converse.getViewForChatBox(chatbox));
|
2016-06-24 10:54:39 +02:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2016-12-20 10:30:20 +01:00
|
|
|
var fetcher = _.partial(_converse.chatboxviews.getChatBox.bind(_converse.chatboxviews), _, create);
|
2016-08-19 17:16:36 +02:00
|
|
|
if (!attrs.nick) {
|
2016-12-20 10:30:20 +01:00
|
|
|
attrs.nick = Strophe.getNodeFromJid(_converse.bare_jid);
|
2016-06-16 17:20:11 +02:00
|
|
|
}
|
2017-01-26 15:49:02 +01:00
|
|
|
if (_.isString(jids)) {
|
2017-02-14 15:58:29 +01:00
|
|
|
return _converse.getChatRoom(jids, attrs, fetcher);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
2017-02-14 15:58:29 +01:00
|
|
|
return _.map(jids, _.partial(_converse.getChatRoom, _, attrs, fetcher));
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
2016-12-04 14:39:09 +01:00
|
|
|
|
|
|
|
|
var reconnectToChatRooms = function () {
|
|
|
|
|
/* Upon a reconnection event from converse, join again
|
|
|
|
|
* all the open chat rooms.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.chatboxviews.each(function (view) {
|
2016-12-04 14:39:09 +01:00
|
|
|
if (view.model.get('type') === 'chatroom') {
|
|
|
|
|
view.model.save('connection_status', Strophe.Status.DISCONNECTED);
|
2016-12-05 07:03:44 +01:00
|
|
|
view.join();
|
2016-12-04 14:39:09 +01:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.on('reconnected', reconnectToChatRooms);
|
2016-12-04 14:39:09 +01:00
|
|
|
|
|
|
|
|
var disconnectChatRooms = function () {
|
|
|
|
|
/* When disconnecting, or reconnecting, mark all chat rooms as
|
|
|
|
|
* disconnected, so that they will be properly entered again
|
|
|
|
|
* when fetched from session storage.
|
|
|
|
|
*/
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.chatboxes.each(function (model) {
|
2016-12-04 14:39:09 +01:00
|
|
|
if (model.get('type') === 'chatroom') {
|
|
|
|
|
model.save('connection_status', Strophe.Status.DISCONNECTED);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
};
|
2016-12-20 10:30:20 +01:00
|
|
|
_converse.on('reconnecting', disconnectChatRooms);
|
|
|
|
|
_converse.on('disconnecting', disconnectChatRooms);
|
2016-02-16 08:46:47 +01:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}));
|
