576 lines
24 KiB
JavaScript
576 lines
24 KiB
JavaScript
// Converse.js (A browser based XMPP chat client)
|
|
// https://conversejs.org
|
|
//
|
|
// Copyright (c) 2012-2017, Jan-Carel Brand <jc@opkode.com>
|
|
// Licensed under the Mozilla Public License (MPLv2)
|
|
//
|
|
/*global define */
|
|
|
|
/* This is a Converse.js plugin which add support for bookmarks specified
|
|
* in XEP-0048.
|
|
*/
|
|
|
|
import converse from "@converse/headless/converse-core";
|
|
import muc from "@converse/headless/converse-muc";
|
|
import tpl_bookmark from "templates/bookmark.html";
|
|
import tpl_bookmarks_list from "templates/bookmarks_list.html"
|
|
import tpl_chatroom_bookmark_form from "templates/chatroom_bookmark_form.html";
|
|
import tpl_chatroom_bookmark_toggle from "templates/chatroom_bookmark_toggle.html";
|
|
|
|
const { Backbone, Promise, Strophe, $iq, sizzle, _ } = converse.env;
|
|
const u = converse.env.utils;
|
|
|
|
|
|
converse.plugins.add('converse-bookmarks', {
|
|
|
|
/* Plugin dependencies are other plugins which might be
|
|
* overridden or relied upon, and therefore need to be loaded before
|
|
* this plugin.
|
|
*
|
|
* If the setting "strict_plugin_dependencies" is set to true,
|
|
* an error will be raised if the plugin is not found. By default it's
|
|
* false, which means these plugins are only loaded opportunistically.
|
|
*
|
|
* NB: These plugins need to have already been loaded via require.js.
|
|
*/
|
|
dependencies: ["converse-chatboxes", "converse-muc", "converse-muc-views"],
|
|
|
|
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.
|
|
|
|
ChatRoomView: {
|
|
events: {
|
|
'click .toggle-bookmark': 'toggleBookmark'
|
|
},
|
|
|
|
initialize () {
|
|
this.__super__.initialize.apply(this, arguments);
|
|
this.model.on('change:bookmarked', this.onBookmarked, this);
|
|
this.setBookmarkState();
|
|
},
|
|
|
|
renderBookmarkToggle () {
|
|
if (this.el.querySelector('.chat-head .toggle-bookmark')) {
|
|
return;
|
|
}
|
|
const { _converse } = this.__super__,
|
|
{ __ } = _converse;
|
|
|
|
const bookmark_button = tpl_chatroom_bookmark_toggle(
|
|
_.assignIn(this.model.toJSON(), {
|
|
'info_toggle_bookmark': this.model.get('bookmarked') ?
|
|
__('Unbookmark this groupchat') :
|
|
__('Bookmark this groupchat'),
|
|
'bookmarked': this.model.get('bookmarked')
|
|
}));
|
|
const close_button = this.el.querySelector('.close-chatbox-button');
|
|
close_button.insertAdjacentHTML('afterend', bookmark_button);
|
|
},
|
|
|
|
async renderHeading () {
|
|
this.__super__.renderHeading.apply(this, arguments);
|
|
const { _converse } = this.__super__;
|
|
if (_converse.allow_bookmarks) {
|
|
const supported = await _converse.checkBookmarksSupport();
|
|
if (supported) {
|
|
this.renderBookmarkToggle();
|
|
}
|
|
}
|
|
},
|
|
|
|
checkForReservedNick () {
|
|
/* Check if the user has a bookmark with a saved nickanme
|
|
* for this groupchat, and if so use it.
|
|
* Otherwise delegate to the super method.
|
|
*/
|
|
const { _converse } = this.__super__;
|
|
if (_.isUndefined(_converse.bookmarks) || !_converse.allow_bookmarks) {
|
|
return this.__super__.checkForReservedNick.apply(this, arguments);
|
|
}
|
|
const model = _converse.bookmarks.findWhere({'jid': this.model.get('jid')});
|
|
if (!_.isUndefined(model) && model.get('nick')) {
|
|
this.join(model.get('nick'));
|
|
} else {
|
|
return this.__super__.checkForReservedNick.apply(this, arguments);
|
|
}
|
|
},
|
|
|
|
onBookmarked () {
|
|
const { _converse } = this.__super__,
|
|
{ __ } = _converse;
|
|
|
|
const icon = this.el.querySelector('.toggle-bookmark');
|
|
if (_.isNull(icon)) {
|
|
return;
|
|
}
|
|
if (this.model.get('bookmarked')) {
|
|
icon.classList.add('button-on');
|
|
icon.title = __('Unbookmark this groupchat');
|
|
} else {
|
|
icon.classList.remove('button-on');
|
|
icon.title = __('Bookmark this groupchat');
|
|
}
|
|
},
|
|
|
|
setBookmarkState () {
|
|
/* Set whether the groupchat is bookmarked or not.
|
|
*/
|
|
const { _converse } = this.__super__;
|
|
if (!_.isUndefined(_converse.bookmarks)) {
|
|
const models = _converse.bookmarks.where({'jid': this.model.get('jid')});
|
|
if (!models.length) {
|
|
this.model.save('bookmarked', false);
|
|
} else {
|
|
this.model.save('bookmarked', true);
|
|
}
|
|
}
|
|
},
|
|
|
|
renderBookmarkForm () {
|
|
const { _converse } = this.__super__,
|
|
{ __ } = _converse,
|
|
body = this.el.querySelector('.chatroom-body');
|
|
|
|
_.each(body.children, child => child.classList.add('hidden'));
|
|
_.each(body.querySelectorAll('.chatroom-form-container'), u.removeElement);
|
|
|
|
body.insertAdjacentHTML(
|
|
'beforeend',
|
|
tpl_chatroom_bookmark_form({
|
|
'default_nick': this.model.get('nick'),
|
|
'heading': __('Bookmark this groupchat'),
|
|
'label_autojoin': __('Would you like this groupchat to be automatically joined upon startup?'),
|
|
'label_cancel': __('Cancel'),
|
|
'label_name': __('The name for this bookmark:'),
|
|
'label_nick': __('What should your nickname for this groupchat be?'),
|
|
'label_submit': __('Save'),
|
|
'name': this.model.get('name')
|
|
})
|
|
);
|
|
const form = body.querySelector('form.chatroom-form');
|
|
form.addEventListener('submit', ev => this.onBookmarkFormSubmitted(ev));
|
|
form.querySelector('.button-cancel').addEventListener('click', () => this.closeForm());
|
|
},
|
|
|
|
onBookmarkFormSubmitted (ev) {
|
|
ev.preventDefault();
|
|
const { _converse } = this.__super__;
|
|
_converse.bookmarks.createBookmark({
|
|
'jid': this.model.get('jid'),
|
|
'autojoin': _.get(ev.target.querySelector('input[name="autojoin"]'), 'checked') || false,
|
|
'name': _.get(ev.target.querySelector('input[name=name]'), 'value'),
|
|
'nick': _.get(ev.target.querySelector('input[name=nick]'), 'value')
|
|
});
|
|
u.removeElement(this.el.querySelector('div.chatroom-form-container'));
|
|
this.renderAfterTransition();
|
|
},
|
|
|
|
toggleBookmark (ev) {
|
|
if (ev) {
|
|
ev.preventDefault();
|
|
ev.stopPropagation();
|
|
}
|
|
const { _converse } = this.__super__;
|
|
const models = _converse.bookmarks.where({'jid': this.model.get('jid')});
|
|
if (!models.length) {
|
|
this.renderBookmarkForm();
|
|
} else {
|
|
_.forEach(models, function (model) {
|
|
model.destroy();
|
|
});
|
|
this.el.querySelector('.toggle-bookmark').classList.remove('button-on');
|
|
}
|
|
}
|
|
}
|
|
},
|
|
|
|
initialize () {
|
|
/* The initialize function gets called as soon as the plugin is
|
|
* loaded by converse.js's plugin machinery.
|
|
*/
|
|
const { _converse } = this,
|
|
{ __ } = _converse;
|
|
|
|
// Configuration values for this plugin
|
|
// ====================================
|
|
// Refer to docs/source/configuration.rst for explanations of these
|
|
// configuration settings.
|
|
_converse.api.settings.update({
|
|
allow_bookmarks: true,
|
|
allow_public_bookmarks: false,
|
|
hide_open_bookmarks: true
|
|
});
|
|
// Promises exposed by this plugin
|
|
_converse.api.promises.add('bookmarksInitialized');
|
|
|
|
// Pure functions on the _converse object
|
|
_.extend(_converse, {
|
|
removeBookmarkViaEvent (ev) {
|
|
/* Remove a bookmark as determined by the passed in
|
|
* event.
|
|
*/
|
|
ev.preventDefault();
|
|
const name = ev.target.getAttribute('data-bookmark-name');
|
|
const jid = ev.target.getAttribute('data-room-jid');
|
|
if (confirm(__("Are you sure you want to remove the bookmark \"%1$s\"?", name))) {
|
|
_.invokeMap(_converse.bookmarks.where({'jid': jid}), Backbone.Model.prototype.destroy);
|
|
}
|
|
},
|
|
|
|
addBookmarkViaEvent (ev) {
|
|
/* Add a bookmark as determined by the passed in
|
|
* event.
|
|
*/
|
|
ev.preventDefault();
|
|
const jid = ev.target.getAttribute('data-room-jid');
|
|
const chatroom = _converse.api.rooms.open(jid, {'bring_to_foreground': true});
|
|
_converse.chatboxviews.get(jid).renderBookmarkForm();
|
|
},
|
|
});
|
|
|
|
_converse.Bookmark = Backbone.Model;
|
|
|
|
_converse.Bookmarks = Backbone.Collection.extend({
|
|
model: _converse.Bookmark,
|
|
comparator: (item) => item.get('name').toLowerCase(),
|
|
|
|
initialize () {
|
|
this.on('add', _.flow(this.openBookmarkedRoom, this.markRoomAsBookmarked));
|
|
this.on('remove', this.markRoomAsUnbookmarked, this);
|
|
this.on('remove', this.sendBookmarkStanza, this);
|
|
|
|
const storage = _converse.config.get('storage'),
|
|
cache_key = `converse.room-bookmarks${_converse.bare_jid}`;
|
|
this.fetched_flag = cache_key+'fetched';
|
|
this.browserStorage = new Backbone.BrowserStorage[storage](cache_key);
|
|
},
|
|
|
|
openBookmarkedRoom (bookmark) {
|
|
if (bookmark.get('autojoin')) {
|
|
const groupchat = _converse.api.rooms.create(bookmark.get('jid'), bookmark.get('nick'));
|
|
if (!groupchat.get('hidden')) {
|
|
groupchat.trigger('show');
|
|
}
|
|
}
|
|
return bookmark;
|
|
},
|
|
|
|
fetchBookmarks () {
|
|
const deferred = u.getResolveablePromise();
|
|
if (this.browserStorage.records.length > 0) {
|
|
this.fetch({
|
|
'success': _.bind(this.onCachedBookmarksFetched, this, deferred),
|
|
'error': _.bind(this.onCachedBookmarksFetched, this, deferred)
|
|
});
|
|
} else if (! window.sessionStorage.getItem(this.fetched_flag)) {
|
|
// There aren't any cached bookmarks and the
|
|
// `fetched_flag` is off, so we query the XMPP server.
|
|
// If nothing is returned from the XMPP server, we set
|
|
// the `fetched_flag` to avoid calling the server again.
|
|
this.fetchBookmarksFromServer(deferred);
|
|
} else {
|
|
deferred.resolve();
|
|
}
|
|
return deferred;
|
|
},
|
|
|
|
onCachedBookmarksFetched (deferred) {
|
|
return deferred.resolve();
|
|
},
|
|
|
|
createBookmark (options) {
|
|
this.create(options);
|
|
this.sendBookmarkStanza().catch(iq => this.onBookmarkError(iq, options));
|
|
},
|
|
|
|
sendBookmarkStanza () {
|
|
const stanza = $iq({
|
|
'type': 'set',
|
|
'from': _converse.connection.jid,
|
|
})
|
|
.c('pubsub', {'xmlns': Strophe.NS.PUBSUB})
|
|
.c('publish', {'node': 'storage:bookmarks'})
|
|
.c('item', {'id': 'current'})
|
|
.c('storage', {'xmlns':'storage:bookmarks'});
|
|
this.each(model => {
|
|
stanza.c('conference', {
|
|
'name': model.get('name'),
|
|
'autojoin': model.get('autojoin'),
|
|
'jid': model.get('jid'),
|
|
}).c('nick').t(model.get('nick')).up().up();
|
|
});
|
|
stanza.up().up().up();
|
|
stanza.c('publish-options')
|
|
.c('x', {'xmlns': Strophe.NS.XFORM, 'type':'submit'})
|
|
.c('field', {'var':'FORM_TYPE', 'type':'hidden'})
|
|
.c('value').t('http://jabber.org/protocol/pubsub#publish-options').up().up()
|
|
.c('field', {'var':'pubsub#persist_items'})
|
|
.c('value').t('true').up().up()
|
|
.c('field', {'var':'pubsub#access_model'})
|
|
.c('value').t('whitelist');
|
|
return _converse.api.sendIQ(stanza);
|
|
},
|
|
|
|
onBookmarkError (iq, options) {
|
|
_converse.log("Error while trying to add bookmark", Strophe.LogLevel.ERROR);
|
|
_converse.log(iq);
|
|
_converse.api.alert.show(
|
|
Strophe.LogLevel.ERROR,
|
|
__('Error'), [__("Sorry, something went wrong while trying to save your bookmark.")]
|
|
)
|
|
this.findWhere({'jid': options.jid}).destroy();
|
|
},
|
|
|
|
fetchBookmarksFromServer (deferred) {
|
|
const stanza = $iq({
|
|
'from': _converse.connection.jid,
|
|
'type': 'get',
|
|
}).c('pubsub', {'xmlns': Strophe.NS.PUBSUB})
|
|
.c('items', {'node': 'storage:bookmarks'});
|
|
_converse.api.sendIQ(stanza)
|
|
.then((iq) => this.onBookmarksReceived(deferred, iq))
|
|
.catch((iq) => this.onBookmarksReceivedError(deferred, iq)
|
|
);
|
|
},
|
|
|
|
markRoomAsBookmarked (bookmark) {
|
|
const groupchat = _converse.chatboxes.get(bookmark.get('jid'));
|
|
if (!_.isUndefined(groupchat)) {
|
|
groupchat.save('bookmarked', true);
|
|
}
|
|
},
|
|
|
|
markRoomAsUnbookmarked (bookmark) {
|
|
const groupchat = _converse.chatboxes.get(bookmark.get('jid'));
|
|
if (!_.isUndefined(groupchat)) {
|
|
groupchat.save('bookmarked', false);
|
|
}
|
|
},
|
|
|
|
createBookmarksFromStanza (stanza) {
|
|
const bookmarks = sizzle(
|
|
`items[node="storage:bookmarks"] item storage[xmlns="storage:bookmarks"] conference`,
|
|
stanza
|
|
);
|
|
_.forEach(bookmarks, (bookmark) => {
|
|
const jid = bookmark.getAttribute('jid');
|
|
this.create({
|
|
'jid': jid,
|
|
'name': bookmark.getAttribute('name') || jid,
|
|
'autojoin': bookmark.getAttribute('autojoin') === 'true',
|
|
'nick': _.get(bookmark.querySelector('nick'), 'textContent')
|
|
});
|
|
});
|
|
},
|
|
|
|
onBookmarksReceived (deferred, iq) {
|
|
this.createBookmarksFromStanza(iq);
|
|
if (!_.isUndefined(deferred)) {
|
|
return deferred.resolve();
|
|
}
|
|
},
|
|
|
|
onBookmarksReceivedError (deferred, iq) {
|
|
window.sessionStorage.setItem(this.fetched_flag, true);
|
|
_converse.log('Error while fetching bookmarks', Strophe.LogLevel.WARN);
|
|
_converse.log(iq.outerHTML, Strophe.LogLevel.DEBUG);
|
|
if (!_.isNil(deferred)) {
|
|
if (iq.querySelector('error[type="cancel"] item-not-found')) {
|
|
// Not an exception, the user simply doesn't have
|
|
// any bookmarks.
|
|
return deferred.resolve();
|
|
} else {
|
|
return deferred.reject(new Error("Could not fetch bookmarks"));
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
_converse.BookmarksList = Backbone.Model.extend({
|
|
defaults: {
|
|
"toggle-state": _converse.OPENED
|
|
}
|
|
});
|
|
|
|
_converse.BookmarkView = Backbone.VDOMView.extend({
|
|
toHTML () {
|
|
return tpl_bookmark({
|
|
'hidden': _converse.hide_open_bookmarks &&
|
|
_converse.chatboxes.where({'jid': this.model.get('jid')}).length,
|
|
'bookmarked': true,
|
|
'info_leave_room': __('Leave this groupchat'),
|
|
'info_remove': __('Remove this bookmark'),
|
|
'info_remove_bookmark': __('Unbookmark this groupchat'),
|
|
'info_title': __('Show more information on this groupchat'),
|
|
'jid': this.model.get('jid'),
|
|
'name': Strophe.xmlunescape(this.model.get('name')),
|
|
'open_title': __('Click to open this groupchat')
|
|
});
|
|
}
|
|
});
|
|
|
|
_converse.BookmarksView = Backbone.OrderedListView.extend({
|
|
tagName: 'div',
|
|
className: 'bookmarks-list list-container rooms-list-container',
|
|
events: {
|
|
'click .add-bookmark': 'addBookmark',
|
|
'click .bookmarks-toggle': 'toggleBookmarksList',
|
|
'click .remove-bookmark': 'removeBookmark',
|
|
'click .open-room': 'openRoom',
|
|
},
|
|
listSelector: '.rooms-list',
|
|
ItemView: _converse.BookmarkView,
|
|
subviewIndex: 'jid',
|
|
|
|
initialize () {
|
|
Backbone.OrderedListView.prototype.initialize.apply(this, arguments);
|
|
|
|
this.model.on('add', this.showOrHide, this);
|
|
this.model.on('remove', this.showOrHide, this);
|
|
|
|
_converse.chatboxes.on('add', this.renderBookmarkListElement, this);
|
|
_converse.chatboxes.on('remove', this.renderBookmarkListElement, this);
|
|
|
|
const storage = _converse.config.get('storage'),
|
|
id = `converse.room-bookmarks${_converse.bare_jid}-list-model`;
|
|
this.list_model = new _converse.BookmarksList({'id': id});
|
|
this.list_model.browserStorage = new Backbone.BrowserStorage[storage](id);
|
|
this.list_model.fetch();
|
|
this.render();
|
|
this.sortAndPositionAllItems();
|
|
},
|
|
|
|
render () {
|
|
this.el.innerHTML = tpl_bookmarks_list({
|
|
'toggle_state': this.list_model.get('toggle-state'),
|
|
'desc_bookmarks': __('Click to toggle the bookmarks list'),
|
|
'label_bookmarks': __('Bookmarks'),
|
|
'_converse': _converse
|
|
});
|
|
this.showOrHide();
|
|
this.insertIntoControlBox();
|
|
return this;
|
|
},
|
|
|
|
insertIntoControlBox () {
|
|
const controlboxview = _converse.chatboxviews.get('controlbox');
|
|
if (!_.isUndefined(controlboxview) && !u.rootContains(_converse.root, this.el)) {
|
|
const el = controlboxview.el.querySelector('.bookmarks-list');
|
|
if (!_.isNull(el)) {
|
|
el.parentNode.replaceChild(this.el, el);
|
|
}
|
|
}
|
|
},
|
|
|
|
openRoom (ev) {
|
|
ev.preventDefault();
|
|
const name = ev.target.textContent;
|
|
const jid = ev.target.getAttribute('data-room-jid');
|
|
const data = {
|
|
'name': name || Strophe.unescapeNode(Strophe.getNodeFromJid(jid)) || jid
|
|
}
|
|
_converse.api.rooms.open(jid, data);
|
|
},
|
|
|
|
removeBookmark: _converse.removeBookmarkViaEvent,
|
|
addBookmark: _converse.addBookmarkViaEvent,
|
|
|
|
renderBookmarkListElement (chatbox) {
|
|
const bookmarkview = this.get(chatbox.get('jid'));
|
|
if (_.isNil(bookmarkview)) {
|
|
// A chat box has been closed, but we don't have a
|
|
// bookmark for it, so nothing further to do here.
|
|
return;
|
|
}
|
|
bookmarkview.render();
|
|
this.showOrHide();
|
|
},
|
|
|
|
showOrHide (item) {
|
|
if (_converse.hide_open_bookmarks) {
|
|
const bookmarks = this.model.filter((bookmark) =>
|
|
!_converse.chatboxes.get(bookmark.get('jid')));
|
|
if (!bookmarks.length) {
|
|
u.hideElement(this.el);
|
|
return;
|
|
}
|
|
}
|
|
if (this.model.models.length) {
|
|
u.showElement(this.el);
|
|
}
|
|
},
|
|
|
|
toggleBookmarksList (ev) {
|
|
if (ev && ev.preventDefault) { ev.preventDefault(); }
|
|
const icon_el = ev.target.matches('.fa') ? ev.target : ev.target.querySelector('.fa');
|
|
if (u.hasClass('fa-caret-down', icon_el)) {
|
|
u.slideIn(this.el.querySelector('.bookmarks'));
|
|
this.list_model.save({'toggle-state': _converse.CLOSED});
|
|
icon_el.classList.remove("fa-caret-down");
|
|
icon_el.classList.add("fa-caret-right");
|
|
} else {
|
|
icon_el.classList.remove("fa-caret-right");
|
|
icon_el.classList.add("fa-caret-down");
|
|
u.slideOut(this.el.querySelector('.bookmarks'));
|
|
this.list_model.save({'toggle-state': _converse.OPENED});
|
|
}
|
|
}
|
|
});
|
|
|
|
_converse.checkBookmarksSupport = async function () {
|
|
const identity = await _converse.api.disco.getIdentity('pubsub', 'pep', _converse.bare_jid);
|
|
if (_converse.allow_public_bookmarks) {
|
|
return !!identity;
|
|
} else {
|
|
const supported = await _converse.api.disco.supports(Strophe.NS.PUBSUB+'#publish-options', _converse.bare_jid);
|
|
return !!supported.length;
|
|
}
|
|
}
|
|
|
|
const initBookmarks = async function () {
|
|
if (!_converse.allow_bookmarks) {
|
|
return;
|
|
}
|
|
const supported = await _converse.checkBookmarksSupport();
|
|
if (supported) {
|
|
_converse.bookmarks = new _converse.Bookmarks();
|
|
_converse.bookmarksview = new _converse.BookmarksView({'model': _converse.bookmarks});
|
|
await _converse.bookmarks.fetchBookmarks();
|
|
}
|
|
_converse.emit('bookmarksInitialized');
|
|
}
|
|
|
|
_converse.on('clearSession', () => {
|
|
if (!_.isUndefined(_converse.bookmarks)) {
|
|
_converse.bookmarks.browserStorage._clear();
|
|
window.sessionStorage.removeItem(_converse.bookmarks.fetched_flag);
|
|
}
|
|
});
|
|
|
|
_converse.on('reconnected', initBookmarks);
|
|
|
|
_converse.on('connected', async () => {
|
|
// Add a handler for bookmarks pushed from other connected clients
|
|
// (from the same user obviously)
|
|
_converse.connection.addHandler(message => {
|
|
if (sizzle('event[xmlns="'+Strophe.NS.PUBSUB+'#event"] items[node="storage:bookmarks"]', message).length) {
|
|
_converse.api.waitUntil('bookmarksInitialized')
|
|
.then(() => _converse.bookmarks.createBookmarksFromStanza(message))
|
|
.catch(_.partial(_converse.log, _, Strophe.LogLevel.FATAL));
|
|
}
|
|
}, null, 'message', 'headline', null, _converse.bare_jid);
|
|
|
|
await Promise.all([
|
|
_converse.api.waitUntil('chatBoxesFetched'),
|
|
_converse.api.waitUntil('roomsPanelRendered')
|
|
]);
|
|
initBookmarks();
|
|
});
|
|
|
|
}
|
|
});
|