You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
678 lines
19 KiB
678 lines
19 KiB
import { Meteor } from 'meteor/meteor';
|
|
import { ReactiveVar } from 'meteor/reactive-var';
|
|
import { Random } from 'meteor/random';
|
|
import { Tracker } from 'meteor/tracker';
|
|
import { FlowRouter } from 'meteor/kadira:flow-router';
|
|
import { Session } from 'meteor/session';
|
|
import { TAPi18n } from 'meteor/tap:i18n';
|
|
import { t, getUserPreference, slashCommands, handleError } from '../../../utils';
|
|
import { MessageAction, messageProperties, MessageTypes, readMessage, modal, call } from '../../../ui-utils';
|
|
import { settings } from '../../../settings';
|
|
import { callbacks } from '../../../callbacks';
|
|
import { promises } from '../../../promises';
|
|
import { hasAtLeastOnePermission } from '../../../authorization';
|
|
import { Messages, Rooms, ChatMessage, ChatSubscription } from '../../../models';
|
|
import { emoji } from '../../../emoji';
|
|
import { KonchatNotification } from './notification';
|
|
import { MsgTyping } from './msgTyping';
|
|
import _ from 'underscore';
|
|
import s from 'underscore.string';
|
|
import moment from 'moment';
|
|
import toastr from 'toastr';
|
|
import { fileUpload } from './fileUpload';
|
|
|
|
let sendOnEnter = '';
|
|
|
|
Meteor.startup(() => {
|
|
Tracker.autorun(function() {
|
|
const user = Meteor.userId();
|
|
sendOnEnter = getUserPreference(user, 'sendOnEnter');
|
|
});
|
|
});
|
|
|
|
export const getPermaLinks = async(replies) => {
|
|
const promises = replies.map(async(reply) =>
|
|
MessageAction.getPermaLink(reply._id)
|
|
);
|
|
|
|
return Promise.all(promises);
|
|
};
|
|
|
|
export const mountReply = async(msg, input) => {
|
|
const replies = $(input).data('reply');
|
|
const mentionUser = $(input).data('mention-user') || false;
|
|
|
|
if (replies && replies.length) {
|
|
const permalinks = await getPermaLinks(replies);
|
|
|
|
replies.forEach(async(reply, replyIndex) => {
|
|
if (reply !== undefined) {
|
|
msg += `[ ](${ permalinks[replyIndex] }) `;
|
|
|
|
const roomInfo = Rooms.findOne(reply.rid, { fields: { t: 1 } });
|
|
if (roomInfo.t !== 'd' && reply.u.username !== Meteor.user().username && mentionUser) {
|
|
msg += `@${ reply.u.username } `;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
return msg;
|
|
};
|
|
|
|
export const ChatMessages = class ChatMessages {
|
|
constructor() {
|
|
|
|
this.saveTextMessageBox = _.debounce((rid, value) => {
|
|
const key = `messagebox_${ rid }`;
|
|
return value.length ? localStorage.setItem(key, value) : localStorage.removeItem(key);
|
|
}, 1000);
|
|
}
|
|
|
|
init(node) {
|
|
this.editing = {};
|
|
this.records = {};
|
|
this.messageMaxSize = settings.get('Message_MaxAllowedSize');
|
|
this.wrapper = $(node).find('.wrapper');
|
|
this.input = this.input || $(node).find('.js-input-message').get(0);
|
|
this.$input = $(this.input);
|
|
this.hasValue = new ReactiveVar(false);
|
|
this.bindEvents();
|
|
}
|
|
|
|
getEditingIndex(element) {
|
|
const msgs = this.wrapper.get(0).querySelectorAll('.own:not(.system)');
|
|
let index = 0;
|
|
for (const msg of Array.from(msgs)) {
|
|
if (msg === element) {
|
|
return index;
|
|
}
|
|
index++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
recordInputAsDraft() {
|
|
const { id } = this.editing;
|
|
|
|
const message = this.getMessageById(id);
|
|
const record = this.records[id] || {};
|
|
const draft = this.input.value;
|
|
|
|
if (draft === message.msg) {
|
|
return this.clearCurrentDraft();
|
|
} else {
|
|
record.draft = draft;
|
|
return this.records[id] = record;
|
|
}
|
|
}
|
|
|
|
getMessageDraft(id) {
|
|
return this.records[id];
|
|
}
|
|
|
|
clearMessageDraft(id) {
|
|
return delete this.records[id];
|
|
}
|
|
|
|
clearCurrentDraft() {
|
|
return this.clearMessageDraft(this.editing.id);
|
|
}
|
|
|
|
resetToDraft(id) {
|
|
const message = this.getMessageById(id);
|
|
|
|
const old_value = this.input.value;
|
|
this.input.value = message.msg;
|
|
|
|
return old_value !== message.msg;
|
|
}
|
|
|
|
getMessageById(id) {
|
|
return ChatMessage.findOne(id);
|
|
}
|
|
|
|
toPrevMessage() {
|
|
const { index } = this.editing;
|
|
return this.editByIndex((index != null) ? index - 1 : undefined);
|
|
}
|
|
|
|
toNextMessage() {
|
|
const { index } = this.editing;
|
|
if (!this.editByIndex(index + 1)) { return this.clearEditing(); }
|
|
}
|
|
|
|
editByIndex(index) {
|
|
if (!this.editing.element && index) { return false; }
|
|
|
|
const msgs = this.wrapper.get(0).querySelectorAll('.own:not(.system)');
|
|
if (index == null) { index = msgs.length - 1; }
|
|
|
|
if (!msgs[index]) { return false; }
|
|
|
|
const element = msgs[index];
|
|
this.edit(element, index);
|
|
return true;
|
|
}
|
|
|
|
edit(element, index) {
|
|
index = index != null ? index : this.getEditingIndex(element);
|
|
|
|
const message = this.getMessageById(element.getAttribute('id'));
|
|
|
|
const hasPermission = hasAtLeastOnePermission('edit-message', message.rid);
|
|
const editAllowed = settings.get('Message_AllowEditing');
|
|
const editOwn = message && message.u && message.u._id === Meteor.userId();
|
|
|
|
if (!hasPermission && (!editAllowed || !editOwn)) { return; }
|
|
if (element.classList.contains('system')) { return; }
|
|
|
|
const blockEditInMinutes = settings.get('Message_AllowEditing_BlockEditInMinutes');
|
|
if (blockEditInMinutes && blockEditInMinutes !== 0) {
|
|
let currentTsDiff;
|
|
let msgTs;
|
|
if (message.ts != null) { msgTs = moment(message.ts); }
|
|
if (msgTs != null) { currentTsDiff = moment().diff(msgTs, 'minutes'); }
|
|
if (currentTsDiff > blockEditInMinutes) {
|
|
return;
|
|
}
|
|
}
|
|
|
|
const draft = this.getMessageDraft(message._id);
|
|
let msg = draft && draft.draft;
|
|
msg = msg || message.msg;
|
|
|
|
const editingNext = this.editing.index < index;
|
|
|
|
// const old_input = this.input.value;
|
|
|
|
this.clearEditing();
|
|
|
|
this.hasValue.set(true);
|
|
this.editing.element = element;
|
|
this.editing.index = index;
|
|
this.editing.id = message._id;
|
|
// TODO: stop set two elements
|
|
this.input.parentElement.classList.add('editing');
|
|
this.input.classList.add('editing');
|
|
|
|
element.classList.add('editing');
|
|
|
|
if (message.attachments && message.attachments[0].description) {
|
|
this.input.value = message.attachments[0].description;
|
|
} else {
|
|
this.input.value = msg;
|
|
}
|
|
$(this.input).trigger('change').trigger('input');
|
|
|
|
const cursor_pos = editingNext ? 0 : -1;
|
|
this.$input.setCursorPosition(cursor_pos);
|
|
this.input.focus();
|
|
return this.input;
|
|
}
|
|
|
|
clearEditing() {
|
|
if (this.editing.element) {
|
|
this.recordInputAsDraft();
|
|
// TODO: stop set two elements
|
|
this.input.classList.remove('editing');
|
|
this.input.parentElement.classList.remove('editing');
|
|
|
|
this.editing.element.classList.remove('editing');
|
|
delete this.editing.id;
|
|
delete this.editing.element;
|
|
delete this.editing.index;
|
|
|
|
this.input.value = this.editing.saved || '';
|
|
$(this.input).trigger('change').trigger('input');
|
|
const cursor_pos = this.editing.savedCursor != null ? this.editing.savedCursor : -1;
|
|
this.$input.setCursorPosition(cursor_pos);
|
|
|
|
return this.hasValue.set(this.input.value !== '');
|
|
}
|
|
this.editing.saved = this.input.value;
|
|
return this.editing.savedCursor = this.input.selectionEnd;
|
|
}
|
|
/**
|
|
* * @param {string} rim room ID
|
|
* * @param {Element} input DOM element
|
|
* * @param {function?} done callback
|
|
*/
|
|
async send(rid, input, done = function() {}) {
|
|
|
|
if (!ChatSubscription.findOne({ rid })) {
|
|
await call('joinRoom', rid);
|
|
}
|
|
|
|
if (s.trim(input.value) !== '') {
|
|
readMessage.enable();
|
|
readMessage.readNow();
|
|
$('.message.first-unread').removeClass('first-unread');
|
|
|
|
let msg = '';
|
|
|
|
msg += await mountReply(msg, input);
|
|
|
|
msg += input.value;
|
|
$(input)
|
|
.removeData('reply')
|
|
.trigger('dataChange');
|
|
|
|
|
|
if (msg.slice(0, 2) === '+:') {
|
|
const reaction = msg.slice(1).trim();
|
|
if (emoji.list[reaction]) {
|
|
const lastMessage = ChatMessage.findOne({ rid }, { fields: { ts: 1 }, sort: { ts: -1 } });
|
|
Meteor.call('setReaction', reaction, lastMessage._id);
|
|
input.value = '';
|
|
$(input).trigger('change').trigger('input');
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Run to allow local encryption, and maybe other client specific actions to be run before send
|
|
const msgObject = await promises.run('onClientBeforeSendMessage', { _id: Random.id(), rid, msg });
|
|
|
|
// checks for the final msgObject.msg size before actually sending the message
|
|
if (this.isMessageTooLong(msgObject.msg)) {
|
|
if (!settings.get('FileUpload_Enabled') || !settings.get('Message_AllowConvertLongMessagesToAttachment') || this.editing.id) {
|
|
return toastr.error(t('Message_too_long'));
|
|
}
|
|
return modal.open({
|
|
text: t('Message_too_long_as_an_attachment_question'),
|
|
title: '',
|
|
type: 'warning',
|
|
showCancelButton: true,
|
|
confirmButtonText: t('Yes'),
|
|
cancelButtonText: t('No'),
|
|
closeOnConfirm: true,
|
|
}, () => {
|
|
const contentType = 'text/plain';
|
|
const messageBlob = new Blob([msgObject.msg], { type: contentType });
|
|
const fileName = `${ Meteor.user().username } - ${ new Date() }.txt`;
|
|
const file = new File([messageBlob], fileName, { type: contentType, lastModified: Date.now() });
|
|
fileUpload([{ file, name: fileName }]);
|
|
this.clearCurrentDraft();
|
|
input.value = '';
|
|
$(input).trigger('change').trigger('input');
|
|
this.hasValue.set(false);
|
|
this.stopTyping(rid);
|
|
this.saveTextMessageBox(rid, '');
|
|
return done();
|
|
}, done);
|
|
}
|
|
|
|
this.clearCurrentDraft();
|
|
|
|
if (this.editing.id) {
|
|
this.update(this.editing.id, rid, msgObject.msg);
|
|
return;
|
|
}
|
|
|
|
KonchatNotification.removeRoomNotification(rid);
|
|
input.value = '';
|
|
$(input).trigger('change').trigger('input');
|
|
|
|
if (typeof input.updateAutogrow === 'function') {
|
|
input.updateAutogrow();
|
|
}
|
|
this.hasValue.set(false);
|
|
this.stopTyping(rid);
|
|
|
|
if (this.processSlashCommand(msgObject)) {
|
|
return;
|
|
}
|
|
|
|
Meteor.call('sendMessage', msgObject);
|
|
|
|
this.saveTextMessageBox(rid, '');
|
|
|
|
return done();
|
|
|
|
|
|
// If edited message was emptied we ask for deletion
|
|
}
|
|
if (this.editing.element) {
|
|
const message = this.getMessageById(this.editing.id);
|
|
if (message.attachments && message.attachments[0] && message.attachments[0].description) {
|
|
return this.update(this.editing.id, rid, '', true);
|
|
}
|
|
// Restore original message in textbox in case delete is canceled
|
|
this.resetToDraft(this.editing.id);
|
|
|
|
return this.confirmDeleteMsg(message, done);
|
|
}
|
|
}
|
|
|
|
processSlashCommand(msgObject) {
|
|
// Check if message starts with /command
|
|
if (msgObject.msg[0] === '/') {
|
|
const match = msgObject.msg.match(/^\/([^\s]+)(?:\s+(.*))?$/m);
|
|
if (match) {
|
|
let command;
|
|
if (slashCommands.commands[match[1]]) {
|
|
const commandOptions = slashCommands.commands[match[1]];
|
|
command = match[1];
|
|
const param = match[2] || '';
|
|
|
|
if (!commandOptions.permission || hasAtLeastOnePermission(commandOptions.permission, Session.get('openedRoom'))) {
|
|
if (commandOptions.clientOnly) {
|
|
commandOptions.callback(command, param, msgObject);
|
|
} else {
|
|
Meteor.call('slashCommand', { cmd: command, params: param, msg: msgObject }, (err, result) => typeof commandOptions.result === 'function' && commandOptions.result(err, result, { cmd: command, params: param, msg: msgObject }));
|
|
}
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (!settings.get('Message_AllowUnrecognizedSlashCommand')) {
|
|
const invalidCommandMsg = {
|
|
_id: Random.id(),
|
|
rid: msgObject.rid,
|
|
ts: new Date,
|
|
msg: TAPi18n.__('No_such_command', { command: match[1] }),
|
|
u: {
|
|
username: settings.get('InternalHubot_Username'),
|
|
},
|
|
private: true,
|
|
};
|
|
|
|
ChatMessage.upsert({ _id: invalidCommandMsg._id }, invalidCommandMsg);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
confirmDeleteMsg(message, done = function() {}) {
|
|
if (MessageTypes.isSystemMessage(message)) { return; }
|
|
|
|
const room = message.drid && Rooms.findOne({
|
|
_id: message.drid,
|
|
prid: { $exists: true },
|
|
});
|
|
modal.open({
|
|
title: t('Are_you_sure'),
|
|
text: room ? t('The_message_is_a_discussion_you_will_not_be_able_to_recover') : t('You_will_not_be_able_to_recover'),
|
|
type: 'warning',
|
|
showCancelButton: true,
|
|
confirmButtonColor: '#DD6B55',
|
|
confirmButtonText: t('Yes_delete_it'),
|
|
cancelButtonText: t('Cancel'),
|
|
html: false,
|
|
}, () => {
|
|
modal.open({
|
|
title: t('Deleted'),
|
|
text: t('Your_entry_has_been_deleted'),
|
|
type: 'success',
|
|
timer: 1000,
|
|
showConfirmButton: false,
|
|
});
|
|
|
|
if (this.editing.id === message._id) {
|
|
this.clearEditing(message);
|
|
}
|
|
this.deleteMsg(message);
|
|
|
|
this.$input.focus();
|
|
return done();
|
|
});
|
|
}
|
|
|
|
deleteMsg(message) {
|
|
const forceDelete = hasAtLeastOnePermission('force-delete-message', message.rid);
|
|
const blockDeleteInMinutes = settings.get('Message_AllowDeleting_BlockDeleteInMinutes');
|
|
if (blockDeleteInMinutes && forceDelete === false) {
|
|
let msgTs;
|
|
if (message.ts != null) { msgTs = moment(message.ts); }
|
|
let currentTsDiff;
|
|
if (msgTs != null) { currentTsDiff = moment().diff(msgTs, 'minutes'); }
|
|
if (currentTsDiff > blockDeleteInMinutes) {
|
|
toastr.error(t('Message_deleting_blocked'));
|
|
return;
|
|
}
|
|
}
|
|
|
|
return Meteor.call('deleteMessage', { _id: message._id }, function(error) {
|
|
if (error) {
|
|
return handleError(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
pinMsg(message) {
|
|
message.pinned = true;
|
|
return Meteor.call('pinMessage', message, function(error) {
|
|
if (error) {
|
|
return handleError(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
unpinMsg(message) {
|
|
message.pinned = false;
|
|
return Meteor.call('unpinMessage', message, function(error) {
|
|
if (error) {
|
|
return handleError(error);
|
|
}
|
|
});
|
|
}
|
|
|
|
update(id, rid, msg, isDescription) {
|
|
if ((s.trim(msg) !== '') || (isDescription === true)) {
|
|
Meteor.call('updateMessage', { _id: id, msg, rid });
|
|
this.clearEditing();
|
|
return this.stopTyping(rid);
|
|
}
|
|
}
|
|
|
|
startTyping(rid, input) {
|
|
if (s.trim(input.value) === '') {
|
|
return this.stopTyping(rid);
|
|
}
|
|
return MsgTyping.start(rid);
|
|
}
|
|
|
|
stopTyping(rid) {
|
|
return MsgTyping.stop(rid);
|
|
}
|
|
|
|
bindEvents() {
|
|
if (this.wrapper && this.wrapper.length) {
|
|
$('.input-message').autogrow();
|
|
}
|
|
}
|
|
|
|
tryCompletion(input) {
|
|
const [value] = input.value.match(/[^\s]+$/) || [];
|
|
if (!value) { return; }
|
|
const re = new RegExp(value, 'i');
|
|
const user = Meteor.users.findOne({ username: re });
|
|
if (user) {
|
|
return input.value = input.value.replace(value, `@${ user.username } `);
|
|
}
|
|
}
|
|
|
|
insertNewLine(input) {
|
|
if (document.selection) {
|
|
input.focus();
|
|
const sel = document.selection.createRange();
|
|
sel.text = '\n';
|
|
} else if (input.selectionStart || input.selectionStart === 0) {
|
|
const newPosition = input.selectionStart + 1;
|
|
const before = input.value.substring(0, input.selectionStart);
|
|
const after = input.value.substring(input.selectionEnd, input.value.length);
|
|
input.value = `${ before }\n${ after }`;
|
|
input.selectionStart = input.selectionEnd = newPosition;
|
|
} else {
|
|
input.value += '\n';
|
|
}
|
|
input.blur();
|
|
input.focus();
|
|
typeof input.updateAutogrow === 'function' && input.updateAutogrow();
|
|
}
|
|
|
|
restoreText(rid) {
|
|
const text = localStorage.getItem(`messagebox_${ rid }`);
|
|
if (typeof text === 'string' && this.input) {
|
|
this.input.value = text;
|
|
this.$input.trigger('input');
|
|
}
|
|
const msgId = FlowRouter.getQueryParam('reply');
|
|
if (!msgId) {
|
|
return;
|
|
}
|
|
const message = Messages.findOne(msgId);
|
|
if (message) {
|
|
return this.$input.data('reply', message).trigger('dataChange');
|
|
}
|
|
Meteor.call('getSingleMessage', msgId, (err, msg) => !err && this.$input.data('reply', msg).trigger('dataChange'));
|
|
}
|
|
|
|
keyup(rid, event) {
|
|
let i;
|
|
const input = event.currentTarget;
|
|
const k = event.which;
|
|
const keyCodes = [
|
|
13, // Enter
|
|
20, // Caps lock
|
|
16, // Shift
|
|
9, // Tab
|
|
27, // Escape Key
|
|
17, // Control Key
|
|
91, // Windows Command Key
|
|
19, // Pause Break
|
|
18, // Alt Key
|
|
93, // Right Click Point Key
|
|
45, // Insert Key
|
|
34, // Page Down
|
|
35, // Page Up
|
|
144, // Num Lock
|
|
145, // Scroll Lock
|
|
];
|
|
for (i = 35; i <= 40; i++) { keyCodes.push(i); } // Home, End, Arrow Keys
|
|
for (i = 112; i <= 123; i++) { keyCodes.push(i); } // F1 - F12
|
|
|
|
if (!Array.from(keyCodes).includes(k)) {
|
|
this.startTyping(rid, input);
|
|
}
|
|
|
|
this.saveTextMessageBox(rid, input.value);
|
|
|
|
return this.hasValue.set(input.value !== '');
|
|
}
|
|
|
|
keydown(rid, event) {
|
|
const { currentTarget: input, which: k } = event;
|
|
|
|
if (k === 13 || k === 10) { // New line or carriage return
|
|
const sendOnEnterActive = sendOnEnter == null || sendOnEnter === 'normal' ||
|
|
(sendOnEnter === 'desktop' && Meteor.Device.isDesktop());
|
|
const withModifier = event.shiftKey || event.ctrlKey || event.altKey || event.metaKey;
|
|
const isSending = (sendOnEnterActive && !withModifier) || (!sendOnEnterActive && withModifier);
|
|
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
if (isSending) {
|
|
this.send(rid, input);
|
|
} else {
|
|
this.insertNewLine(input);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (k === 9) { // Tab
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
this.tryCompletion(input);
|
|
}
|
|
|
|
if (k === 27) { // Escape
|
|
if (this.editing.index != null) {
|
|
// const record = this.getMessageDraft(this.editing.id);
|
|
|
|
// If resetting did nothing then edited message is same as original
|
|
if (!this.resetToDraft(this.editing.id)) {
|
|
this.clearCurrentDraft();
|
|
this.clearEditing();
|
|
}
|
|
|
|
event.preventDefault();
|
|
event.stopPropagation();
|
|
return;
|
|
}
|
|
} else if (k === 38 || k === 40) { // Arrow Up or down
|
|
if (event.shiftKey) { return true; }
|
|
|
|
const cursor_pos = input.selectionEnd;
|
|
|
|
if (k === 38) { // Arrow Up
|
|
if (cursor_pos === 0) {
|
|
this.toPrevMessage();
|
|
} else if (!event.altKey) {
|
|
return true;
|
|
}
|
|
|
|
if (event.altKey) { this.$input.setCursorPosition(0); }
|
|
|
|
} else { // Arrow Down
|
|
if (cursor_pos === input.value.length) {
|
|
this.toNextMessage();
|
|
} else if (!event.altKey) {
|
|
return true;
|
|
}
|
|
|
|
if (event.altKey) { this.$input.setCursorPosition(-1); }
|
|
}
|
|
|
|
return false;
|
|
|
|
// ctrl (command) + shift + k -> clear room messages
|
|
}
|
|
// TODO
|
|
// else if (k === 75 && navigator && navigator.platform && event.shiftKey && (navigator.platform.indexOf('Mac') !== -1 ? event.metaKey : event.ctrlKey)) {
|
|
// return RoomHistoryManager.clear(rid);
|
|
// }
|
|
}
|
|
|
|
valueChanged(/* rid, event*/) {
|
|
if (this.input.value.length === 1) {
|
|
return this.determineInputDirection();
|
|
}
|
|
}
|
|
|
|
determineInputDirection() {
|
|
return this.input.dir = this.isMessageRtl(this.input.value) ? 'rtl' : 'ltr';
|
|
}
|
|
|
|
// http://stackoverflow.com/a/14824756
|
|
isMessageRtl(message) {
|
|
const ltrChars = 'A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02B8\u0300-\u0590\u0800-\u1FFF\u2C00-\uFB1C\uFDFE-\uFE6F\uFEFD-\uFFFF';
|
|
const rtlChars = '\u0591-\u07FF\uFB1D-\uFDFD\uFE70-\uFEFC';
|
|
const rtlDirCheck = new RegExp(`^[^${ ltrChars }]*[${ rtlChars }]`);
|
|
|
|
return rtlDirCheck.test(message);
|
|
}
|
|
|
|
isMessageTooLong(message) {
|
|
const adjustedMessage = messageProperties.messageWithoutEmojiShortnames(message);
|
|
return messageProperties.length(adjustedMessage) > this.messageMaxSize && message;
|
|
}
|
|
|
|
isEmpty() {
|
|
return !this.hasValue.get();
|
|
}
|
|
};
|
|
|
|
|
|
callbacks.add('afterLogoutCleanUp', () => {
|
|
Object.keys(localStorage).forEach((item) => {
|
|
if (item.indexOf('messagebox_') === 0) {
|
|
localStorage.removeItem(item);
|
|
}
|
|
});
|
|
}, callbacks.priority.MEDIUM, 'chatMessages-after-logout-cleanup');
|
|
|