mirror of
https://github.com/the-djmaze/snappymail.git
synced 2025-01-06 06:52:20 +08:00
896 lines
22 KiB
JavaScript
896 lines
22 KiB
JavaScript
|
|
import window from 'window';
|
|
import _ from '_';
|
|
import ko from 'ko';
|
|
import $ from '$';
|
|
|
|
import {
|
|
Magics, Layout, Focused,
|
|
MessageSetAction,
|
|
StorageResultType,
|
|
Notification
|
|
} from 'Common/Enums';
|
|
|
|
import {
|
|
trim, isNormal, isArray, inArray,
|
|
pInt, pString, plainToHtml,
|
|
windowResize, findEmailAndLinks,
|
|
getRealHeight
|
|
} from 'Common/Utils';
|
|
|
|
import {
|
|
getFolderInboxName,
|
|
addNewMessageCache,
|
|
setFolderUidNext,
|
|
getFolderFromCacheList,
|
|
setFolderHash,
|
|
initMessageFlagsFromCache,
|
|
addRequestedMessage,
|
|
clearMessageFlagsFromCacheByFolder,
|
|
hasNewMessageAndRemoveFromCache,
|
|
storeMessageFlagsToCache,
|
|
clearNewMessageCache
|
|
} from 'Common/Cache';
|
|
|
|
import {MESSAGE_BODY_CACHE_LIMIT} from 'Common/Consts';
|
|
import {data as GlobalsData, $div} from 'Common/Globals';
|
|
import {mailBox, notificationMailIcon} from 'Common/Links';
|
|
import {i18n, getNotification} from 'Common/Translator';
|
|
import {momentNowUnix} from 'Common/Momentor';
|
|
|
|
import * as MessageHelper from 'Helper/Message';
|
|
import {MessageModel} from 'Model/Message';
|
|
|
|
import {setHash} from 'Knoin/Knoin';
|
|
|
|
import AppStore from 'Stores/User/App';
|
|
import AccountStore from 'Stores/User/Account';
|
|
import FolderStore from 'Stores/User/Folder';
|
|
import PgpStore from 'Stores/User/Pgp';
|
|
import SettingsStore from 'Stores/User/Settings';
|
|
import NotificationStore from 'Stores/User/Notification';
|
|
|
|
import {getApp} from 'Helper/Apps/User';
|
|
|
|
import Remote from 'Remote/User/Ajax';
|
|
|
|
class MessageUserStore
|
|
{
|
|
constructor()
|
|
{
|
|
this.staticMessage = new MessageModel();
|
|
|
|
this.messageList = ko.observableArray([]).extend({rateLimit: 0});
|
|
|
|
this.messageListCount = ko.observable(0);
|
|
this.messageListSearch = ko.observable('');
|
|
this.messageListThreadUid = ko.observable('');
|
|
this.messageListPage = ko.observable(1);
|
|
this.messageListPageBeforeThread = ko.observable(1);
|
|
this.messageListError = ko.observable('');
|
|
|
|
this.messageListEndFolder = ko.observable('');
|
|
this.messageListEndSearch = ko.observable('');
|
|
this.messageListEndThreadUid = ko.observable('');
|
|
this.messageListEndPage = ko.observable(1);
|
|
|
|
this.messageListLoading = ko.observable(false);
|
|
this.messageListIsNotCompleted = ko.observable(false);
|
|
this.messageListCompleteLoadingThrottle = ko.observable(false).extend({throttle: 200});
|
|
this.messageListCompleteLoadingThrottleForAnimation = ko.observable(false).extend({specialThrottle: 700});
|
|
|
|
this.messageListDisableAutoSelect = ko.observable(false).extend({falseTimeout: 500});
|
|
|
|
this.selectorMessageSelected = ko.observable(null);
|
|
this.selectorMessageFocused = ko.observable(null);
|
|
|
|
// message viewer
|
|
this.message = ko.observable(null);
|
|
|
|
this.message.viewTrigger = ko.observable(false);
|
|
|
|
this.messageError = ko.observable('');
|
|
|
|
this.messageCurrentLoading = ko.observable(false);
|
|
|
|
this.messageLoadingThrottle = ko.observable(false).extend({throttle: Magics.Time50ms});
|
|
|
|
this.messageFullScreenMode = ko.observable(false);
|
|
|
|
this.messagesBodiesDom = ko.observable(null);
|
|
this.messageActiveDom = ko.observable(null);
|
|
|
|
this.computers();
|
|
this.subscribers();
|
|
|
|
this.onMessageResponse = _.bind(this.onMessageResponse, this);
|
|
|
|
this.purgeMessageBodyCacheThrottle = _.throttle(this.purgeMessageBodyCache, Magics.Time30s);
|
|
}
|
|
|
|
computers() {
|
|
|
|
this.messageLoading = ko.computed(() => this.messageCurrentLoading());
|
|
|
|
this.messageListEndHash = ko.computed(
|
|
() => this.messageListEndFolder() + '|' + this.messageListEndSearch() +
|
|
'|' + this.messageListEndThreadUid() + '|' + this.messageListEndPage()
|
|
);
|
|
|
|
this.messageListPageCount = ko.computed(() => {
|
|
const page = window.Math.ceil(this.messageListCount() / SettingsStore.messagesPerPage());
|
|
return 0 >= page ? 1 : page;
|
|
});
|
|
|
|
this.mainMessageListSearch = ko.computed({
|
|
read: this.messageListSearch,
|
|
write: (value) => {
|
|
setHash(
|
|
mailBox(FolderStore.currentFolderFullNameHash(), 1, trim(value.toString()), this.messageListThreadUid())
|
|
);
|
|
}
|
|
});
|
|
|
|
this.messageListCompleteLoading = ko.computed(() => {
|
|
const
|
|
one = this.messageListLoading(),
|
|
two = this.messageListIsNotCompleted();
|
|
return one || two;
|
|
});
|
|
|
|
this.isMessageSelected = ko.computed(() => null !== this.message());
|
|
|
|
this.messageListChecked = ko.computed(
|
|
() => _.filter(this.messageList(), (item) => item.checked())
|
|
).extend({rateLimit: 0});
|
|
|
|
this.hasCheckedMessages = ko.computed(() => 0 < this.messageListChecked().length).extend({rateLimit: 0});
|
|
|
|
this.messageListCheckedOrSelected = ko.computed(() => {
|
|
const
|
|
checked = this.messageListChecked(),
|
|
selectedMessage = this.selectorMessageSelected(),
|
|
focusedMessage = this.selectorMessageFocused();
|
|
|
|
if (checked.length) {
|
|
return _.union(checked, selectedMessage ? [selectedMessage] : []);
|
|
} else if (selectedMessage) {
|
|
return [selectedMessage];
|
|
}
|
|
|
|
return focusedMessage ? [focusedMessage] : [];
|
|
});
|
|
|
|
this.messageListCheckedOrSelectedUidsWithSubMails = ko.computed(() => {
|
|
let result = [];
|
|
_.each(this.messageListCheckedOrSelected(), (message) => {
|
|
if (message)
|
|
{
|
|
result.push(message.uid);
|
|
if (1 < message.threadsLen())
|
|
{
|
|
result = _.union(result, message.threads());
|
|
}
|
|
}
|
|
});
|
|
return result;
|
|
});
|
|
}
|
|
|
|
subscribers() {
|
|
|
|
this.messageListCompleteLoading.subscribe((value) => {
|
|
value = !!value;
|
|
this.messageListCompleteLoadingThrottle(value);
|
|
this.messageListCompleteLoadingThrottleForAnimation(value);
|
|
});
|
|
|
|
this.messageList.subscribe(_.debounce((list) => {
|
|
_.each(list, (item) => {
|
|
if (item && item.newForAnimation())
|
|
{
|
|
item.newForAnimation(false);
|
|
}
|
|
});
|
|
}, Magics.Time500ms));
|
|
|
|
this.message.subscribe((message) => {
|
|
|
|
if (message)
|
|
{
|
|
if (Layout.NoPreview === SettingsStore.layout())
|
|
{
|
|
AppStore.focusedState(Focused.MessageView);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
AppStore.focusedState(Focused.MessageList);
|
|
|
|
this.messageFullScreenMode(false);
|
|
this.hideMessageBodies();
|
|
}
|
|
|
|
});
|
|
|
|
this.messageLoading.subscribe((value) => {
|
|
this.messageLoadingThrottle(value);
|
|
});
|
|
|
|
this.messagesBodiesDom.subscribe((dom) => {
|
|
if (dom && !(dom instanceof $))
|
|
{
|
|
this.messagesBodiesDom($(dom));
|
|
}
|
|
});
|
|
|
|
this.messageListEndFolder.subscribe((folder) => {
|
|
const message = this.message();
|
|
if (message && folder && folder !== message.folderFullNameRaw)
|
|
{
|
|
this.message(null);
|
|
}
|
|
});
|
|
}
|
|
|
|
purgeMessageBodyCache() {
|
|
|
|
let count = 0;
|
|
const end = GlobalsData.iMessageBodyCacheCount - MESSAGE_BODY_CACHE_LIMIT;
|
|
|
|
if (0 < end)
|
|
{
|
|
const messagesDom = this.messagesBodiesDom();
|
|
if (messagesDom)
|
|
{
|
|
messagesDom.find('.rl-cache-class').each(function() {
|
|
const item = $(this); // eslint-disable-line no-invalid-this
|
|
if (end > item.data('rl-cache-count'))
|
|
{
|
|
item.addClass('rl-cache-purge');
|
|
count += 1;
|
|
}
|
|
});
|
|
|
|
if (0 < count)
|
|
{
|
|
_.delay(() => messagesDom.find('.rl-cache-purge').remove(), Magics.Time350ms);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
initUidNextAndNewMessages(folder, uidNext, newMessages) {
|
|
if (getFolderInboxName() === folder && isNormal(uidNext) && '' !== uidNext)
|
|
{
|
|
if (isArray(newMessages) && 0 < newMessages.length)
|
|
{
|
|
_.each(newMessages, (item) => {
|
|
addNewMessageCache(folder, item.Uid);
|
|
});
|
|
|
|
NotificationStore.playSoundNotification();
|
|
|
|
const len = newMessages.length;
|
|
if (3 < len)
|
|
{
|
|
NotificationStore.displayDesktopNotification(
|
|
notificationMailIcon(),
|
|
AccountStore.email(),
|
|
i18n('MESSAGE_LIST/NEW_MESSAGE_NOTIFICATION', {
|
|
'COUNT': len
|
|
}),
|
|
{'Folder': '', 'Uid': ''}
|
|
);
|
|
}
|
|
else
|
|
{
|
|
_.each(newMessages, (item) => {
|
|
NotificationStore.displayDesktopNotification(
|
|
notificationMailIcon(),
|
|
MessageHelper.emailArrayToString(MessageHelper.emailArrayFromJson(item.From), false),
|
|
item.Subject,
|
|
{'Folder': item.Folder, 'Uid': item.Uid}
|
|
);
|
|
});
|
|
}
|
|
}
|
|
|
|
setFolderUidNext(folder, uidNext);
|
|
}
|
|
}
|
|
|
|
hideMessageBodies() {
|
|
const messagesDom = this.messagesBodiesDom();
|
|
if (messagesDom)
|
|
{
|
|
messagesDom.find('.b-text-part').hide();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} fromFolderFullNameRaw
|
|
* @param {Array} uidForRemove
|
|
* @param {string=} toFolderFullNameRaw = ''
|
|
* @param {boolean=} copy = false
|
|
*/
|
|
removeMessagesFromList(fromFolderFullNameRaw, uidForRemove, toFolderFullNameRaw = '', copy = false) {
|
|
|
|
uidForRemove = _.map(uidForRemove, (mValue) => pInt(mValue));
|
|
|
|
let
|
|
unseenCount = 0,
|
|
messageList = this.messageList(),
|
|
currentMessage = this.message();
|
|
|
|
const
|
|
trashFolder = FolderStore.trashFolder(),
|
|
spamFolder = FolderStore.spamFolder(),
|
|
fromFolder = getFolderFromCacheList(fromFolderFullNameRaw),
|
|
toFolder = '' === toFolderFullNameRaw ? null : getFolderFromCacheList(toFolderFullNameRaw || ''),
|
|
currentFolderFullNameRaw = FolderStore.currentFolderFullNameRaw(),
|
|
messages = currentFolderFullNameRaw === fromFolderFullNameRaw ?
|
|
_.filter(messageList, (item) => (item && -1 < inArray(pInt(item.uid), uidForRemove))) : [];
|
|
|
|
_.each(messages, (item) => {
|
|
if (item && item.unseen())
|
|
{
|
|
unseenCount += 1;
|
|
}
|
|
});
|
|
|
|
if (fromFolder && !copy)
|
|
{
|
|
fromFolder.messageCountAll(0 <= fromFolder.messageCountAll() - uidForRemove.length ?
|
|
fromFolder.messageCountAll() - uidForRemove.length : 0);
|
|
|
|
if (0 < unseenCount)
|
|
{
|
|
fromFolder.messageCountUnread(0 <= fromFolder.messageCountUnread() - unseenCount ?
|
|
fromFolder.messageCountUnread() - unseenCount : 0);
|
|
}
|
|
}
|
|
|
|
if (toFolder)
|
|
{
|
|
if (trashFolder === toFolder.fullNameRaw || spamFolder === toFolder.fullNameRaw)
|
|
{
|
|
unseenCount = 0;
|
|
}
|
|
|
|
toFolder.messageCountAll(toFolder.messageCountAll() + uidForRemove.length);
|
|
if (0 < unseenCount)
|
|
{
|
|
toFolder.messageCountUnread(toFolder.messageCountUnread() + unseenCount);
|
|
}
|
|
|
|
toFolder.actionBlink(true);
|
|
}
|
|
|
|
if (0 < messages.length)
|
|
{
|
|
if (copy)
|
|
{
|
|
_.each(messages, (item) => {
|
|
item.checked(false);
|
|
});
|
|
}
|
|
else
|
|
{
|
|
this.messageListIsNotCompleted(true);
|
|
|
|
_.each(messages, (item) => {
|
|
if (currentMessage && currentMessage.hash === item.hash)
|
|
{
|
|
currentMessage = null;
|
|
this.message(null);
|
|
}
|
|
|
|
item.deleted(true);
|
|
});
|
|
|
|
_.delay(() => {
|
|
_.each(messages, (item) => {
|
|
this.messageList.remove(item);
|
|
});
|
|
}, Magics.Time350ms);
|
|
}
|
|
}
|
|
|
|
if ('' !== fromFolderFullNameRaw)
|
|
{
|
|
setFolderHash(fromFolderFullNameRaw, '');
|
|
}
|
|
|
|
if ('' !== toFolderFullNameRaw)
|
|
{
|
|
setFolderHash(toFolderFullNameRaw, '');
|
|
}
|
|
|
|
if ('' !== this.messageListThreadUid())
|
|
{
|
|
messageList = this.messageList();
|
|
|
|
if (messageList && 0 < messageList.length &&
|
|
!!_.find(messageList, (item) => !!(item && item.deleted() && item.uid === this.messageListThreadUid())))
|
|
{
|
|
const message = _.find(messageList, (item) => item && !item.deleted());
|
|
if (message && this.messageListThreadUid() !== pString(message.uid))
|
|
{
|
|
this.messageListThreadUid(pString(message.uid));
|
|
|
|
setHash(mailBox(
|
|
FolderStore.currentFolderFullNameHash(),
|
|
this.messageListPage(),
|
|
this.messageListSearch(),
|
|
this.messageListThreadUid()
|
|
), true, true);
|
|
}
|
|
else if (!message)
|
|
{
|
|
if (1 < this.messageListPage())
|
|
{
|
|
this.messageListPage(this.messageListPage() - 1);
|
|
|
|
setHash(mailBox(
|
|
FolderStore.currentFolderFullNameHash(),
|
|
this.messageListPage(),
|
|
this.messageListSearch(),
|
|
this.messageListThreadUid()
|
|
), true, true);
|
|
}
|
|
else
|
|
{
|
|
this.messageListThreadUid('');
|
|
|
|
setHash(mailBox(
|
|
FolderStore.currentFolderFullNameHash(),
|
|
this.messageListPageBeforeThread(),
|
|
this.messageListSearch()
|
|
), true, true);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Object} messageTextBody
|
|
*/
|
|
initBlockquoteSwitcher(messageTextBody) {
|
|
if (messageTextBody)
|
|
{
|
|
const $oList = $('blockquote:not(.rl-bq-switcher)', messageTextBody).filter(function() {
|
|
return 0 === $(this).parent().closest('blockquote', messageTextBody).length; // eslint-disable-line no-invalid-this
|
|
});
|
|
|
|
if ($oList && 0 < $oList.length)
|
|
{
|
|
$oList.each(function() {
|
|
const $this = $(this); // eslint-disable-line no-invalid-this
|
|
|
|
let h = $this.height();
|
|
if (0 === h)
|
|
{
|
|
h = getRealHeight($this);
|
|
}
|
|
|
|
if ('' !== trim($this.text()) && (0 === h || 100 < h))
|
|
{
|
|
$this.addClass('rl-bq-switcher hidden-bq');
|
|
$('<span class="rlBlockquoteSwitcher"><i class="icon-ellipsis" /></span>')
|
|
.insertBefore($this)
|
|
.on('click.rlBlockquoteSwitcher', () => {
|
|
$this.toggleClass('hidden-bq');
|
|
windowResize();
|
|
})
|
|
.after('<br />')
|
|
.before('<br />');
|
|
}
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Object} messageTextBody
|
|
* @param {Object} message
|
|
*/
|
|
initOpenPgpControls(messageTextBody, message) {
|
|
if (messageTextBody && messageTextBody.find)
|
|
{
|
|
messageTextBody.find('.b-plain-openpgp:not(.inited)').each(function() {
|
|
PgpStore.initMessageBodyControls($(this), message); // eslint-disable-line no-invalid-this
|
|
});
|
|
}
|
|
}
|
|
|
|
setMessage(data, cached) {
|
|
|
|
let
|
|
isNew = false,
|
|
body = null,
|
|
id = '',
|
|
plain = '',
|
|
resultHtml = '',
|
|
pgpSigned = false,
|
|
messagesDom = this.messagesBodiesDom(),
|
|
selectedMessage = this.selectorMessageSelected(),
|
|
message = this.message();
|
|
|
|
if (data && message && data.Result && 'Object/Message' === data.Result['@Object'] &&
|
|
message.folderFullNameRaw === data.Result.Folder)
|
|
{
|
|
const threads = message.threads();
|
|
if (message.uid !== data.Result.Uid && 1 < threads.length && -1 < inArray(data.Result.Uid, threads))
|
|
{
|
|
message = MessageModel.newInstanceFromJson(data.Result);
|
|
if (message)
|
|
{
|
|
message.threads(threads);
|
|
initMessageFlagsFromCache(message);
|
|
|
|
this.message(this.staticMessage.populateByMessageListItem(message));
|
|
message = this.message();
|
|
|
|
isNew = true;
|
|
}
|
|
}
|
|
|
|
if (message && message.uid === data.Result.Uid)
|
|
{
|
|
this.messageError('');
|
|
|
|
message.initUpdateByMessageJson(data.Result);
|
|
addRequestedMessage(message.folderFullNameRaw, message.uid);
|
|
|
|
if (!cached)
|
|
{
|
|
message.initFlagsByJson(data.Result);
|
|
}
|
|
|
|
messagesDom = messagesDom && messagesDom[0] ? messagesDom : null;
|
|
if (messagesDom)
|
|
{
|
|
id = 'rl-mgs-' + message.hash.replace(/[^a-zA-Z0-9]/g, '');
|
|
|
|
const textBody = messagesDom.find('#' + id);
|
|
if (!textBody || !textBody[0])
|
|
{
|
|
let isHtml = false;
|
|
if (isNormal(data.Result.Html) && '' !== data.Result.Html)
|
|
{
|
|
isHtml = true;
|
|
resultHtml = data.Result.Html.toString();
|
|
}
|
|
else if (isNormal(data.Result.Plain) && '' !== data.Result.Plain)
|
|
{
|
|
isHtml = false;
|
|
resultHtml = plainToHtml(data.Result.Plain.toString(), false);
|
|
|
|
if ((message.isPgpSigned() || message.isPgpEncrypted()) && PgpStore.capaOpenPGP())
|
|
{
|
|
plain = pString(data.Result.Plain);
|
|
|
|
const isPgpEncrypted = (/---BEGIN PGP MESSAGE---/).test(plain);
|
|
if (!isPgpEncrypted)
|
|
{
|
|
pgpSigned = (/-----BEGIN PGP SIGNED MESSAGE-----/).test(plain) &&
|
|
(/-----BEGIN PGP SIGNATURE-----/).test(plain);
|
|
}
|
|
|
|
$div.empty();
|
|
if (pgpSigned && message.isPgpSigned())
|
|
{
|
|
resultHtml = $div.append(
|
|
$('<pre class="b-plain-openpgp signed"></pre>').text(plain)
|
|
).html();
|
|
}
|
|
else if (isPgpEncrypted && message.isPgpEncrypted())
|
|
{
|
|
resultHtml = $div.append(
|
|
$('<pre class="b-plain-openpgp encrypted"></pre>').text(plain)
|
|
).html();
|
|
}
|
|
else
|
|
{
|
|
resultHtml = '<pre>' + resultHtml + '</pre>';
|
|
}
|
|
|
|
$div.empty();
|
|
|
|
message.isPgpSigned(pgpSigned);
|
|
message.isPgpEncrypted(isPgpEncrypted);
|
|
}
|
|
else
|
|
{
|
|
resultHtml = '<pre>' + resultHtml + '</pre>';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
isHtml = false;
|
|
resultHtml = '<pre>' + resultHtml + '</pre>';
|
|
}
|
|
|
|
GlobalsData.iMessageBodyCacheCount += 1;
|
|
|
|
body = $('<div id="' + id + '" ></div>').hide().addClass('rl-cache-class');
|
|
body.data('rl-cache-count', GlobalsData.iMessageBodyCacheCount);
|
|
|
|
body
|
|
.html(findEmailAndLinks(resultHtml))
|
|
.addClass('b-text-part ' + (isHtml ? 'html' : 'plain'));
|
|
|
|
message.isHtml(!!isHtml);
|
|
message.hasImages(!!data.Result.HasExternals);
|
|
|
|
message.body = body;
|
|
if (message.body)
|
|
{
|
|
messagesDom.append(message.body);
|
|
}
|
|
|
|
message.storeDataInDom();
|
|
|
|
if (data.Result.HasInternals)
|
|
{
|
|
message.showInternalImages(true);
|
|
}
|
|
|
|
if (message.hasImages() && SettingsStore.showImages())
|
|
{
|
|
message.showExternalImages(true);
|
|
}
|
|
|
|
this.purgeMessageBodyCacheThrottle();
|
|
}
|
|
else
|
|
{
|
|
message.body = textBody;
|
|
if (message.body)
|
|
{
|
|
GlobalsData.iMessageBodyCacheCount += 1;
|
|
message.body.data('rl-cache-count', GlobalsData.iMessageBodyCacheCount);
|
|
message.fetchDataFromDom();
|
|
}
|
|
}
|
|
|
|
this.messageActiveDom(message.body);
|
|
|
|
this.hideMessageBodies();
|
|
|
|
if (body)
|
|
{
|
|
this.initOpenPgpControls(body, message);
|
|
|
|
this.initBlockquoteSwitcher(body);
|
|
}
|
|
|
|
message.body.show();
|
|
}
|
|
|
|
initMessageFlagsFromCache(message);
|
|
if (message.unseen() || message.hasUnseenSubMessage())
|
|
{
|
|
getApp().messageListAction(
|
|
message.folderFullNameRaw, MessageSetAction.SetSeen, [message]);
|
|
}
|
|
|
|
if (isNew)
|
|
{
|
|
message = this.message();
|
|
|
|
if (selectedMessage && message && (
|
|
message.folderFullNameRaw !== selectedMessage.folderFullNameRaw ||
|
|
message.uid !== selectedMessage.uid
|
|
))
|
|
{
|
|
this.selectorMessageSelected(null);
|
|
if (1 === this.messageList().length)
|
|
{
|
|
this.selectorMessageFocused(null);
|
|
}
|
|
}
|
|
else if (!selectedMessage && message)
|
|
{
|
|
selectedMessage = _.find(this.messageList(),
|
|
(subMessage) => subMessage &&
|
|
subMessage.folderFullNameRaw === message.folderFullNameRaw &&
|
|
subMessage.uid === message.uid
|
|
);
|
|
|
|
if (selectedMessage)
|
|
{
|
|
this.selectorMessageSelected(selectedMessage);
|
|
this.selectorMessageFocused(selectedMessage);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
windowResize();
|
|
}
|
|
}
|
|
}
|
|
|
|
selectMessage(oMessage) {
|
|
if (oMessage)
|
|
{
|
|
this.message(this.staticMessage.populateByMessageListItem(oMessage));
|
|
this.populateMessageBody(this.message());
|
|
}
|
|
else
|
|
{
|
|
this.message(null);
|
|
}
|
|
}
|
|
|
|
selectMessageByFolderAndUid(sFolder, sUid) {
|
|
if (sFolder && sUid)
|
|
{
|
|
this.message(this.staticMessage.populateByMessageListItem(null));
|
|
this.message().folderFullNameRaw = sFolder;
|
|
this.message().uid = sUid;
|
|
|
|
this.populateMessageBody(this.message());
|
|
}
|
|
else
|
|
{
|
|
this.message(null);
|
|
}
|
|
}
|
|
|
|
populateMessageBody(oMessage) {
|
|
if (oMessage)
|
|
{
|
|
if (Remote.message(this.onMessageResponse, oMessage.folderFullNameRaw, oMessage.uid))
|
|
{
|
|
this.messageCurrentLoading(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {string} sResult
|
|
* @param {AjaxJsonDefaultResponse} oData
|
|
* @param {boolean} bCached
|
|
*/
|
|
onMessageResponse(sResult, oData, bCached) {
|
|
|
|
this.hideMessageBodies();
|
|
|
|
this.messageCurrentLoading(false);
|
|
|
|
if (StorageResultType.Success === sResult && oData && oData.Result)
|
|
{
|
|
this.setMessage(oData, bCached);
|
|
}
|
|
else if (StorageResultType.Unload === sResult)
|
|
{
|
|
this.message(null);
|
|
this.messageError('');
|
|
}
|
|
else if (StorageResultType.Abort !== sResult)
|
|
{
|
|
this.message(null);
|
|
this.messageError((oData && oData.ErrorCode ?
|
|
getNotification(oData.ErrorCode) : getNotification(Notification.UnknownError)));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @param {Array} list
|
|
* @returns {string}
|
|
*/
|
|
calculateMessageListHash(list) {
|
|
return _.map(list, (message) => '' + message.hash + '_' + message.threadsLen() + '_' + message.flagHash()).join('|');
|
|
}
|
|
|
|
setMessageList(data, cached) {
|
|
if (data && data.Result && 'Collection/MessageCollection' === data.Result['@Object'] &&
|
|
data.Result['@Collection'] && isArray(data.Result['@Collection']))
|
|
{
|
|
let
|
|
newCount = 0,
|
|
unreadCountChange = false;
|
|
|
|
const
|
|
list = [],
|
|
utc = momentNowUnix(),
|
|
iCount = pInt(data.Result.MessageResultCount),
|
|
iOffset = pInt(data.Result.Offset);
|
|
|
|
const folder = getFolderFromCacheList(isNormal(data.Result.Folder) ? data.Result.Folder : '');
|
|
|
|
if (folder && !cached)
|
|
{
|
|
folder.interval = utc;
|
|
|
|
setFolderHash(data.Result.Folder, data.Result.FolderHash);
|
|
|
|
if (isNormal(data.Result.MessageCount))
|
|
{
|
|
folder.messageCountAll(data.Result.MessageCount);
|
|
}
|
|
|
|
if (isNormal(data.Result.MessageUnseenCount))
|
|
{
|
|
if (pInt(folder.messageCountUnread()) !== pInt(data.Result.MessageUnseenCount))
|
|
{
|
|
unreadCountChange = true;
|
|
}
|
|
|
|
folder.messageCountUnread(data.Result.MessageUnseenCount);
|
|
}
|
|
|
|
this.initUidNextAndNewMessages(folder.fullNameRaw, data.Result.UidNext, data.Result.NewMessages);
|
|
}
|
|
|
|
if (unreadCountChange && folder)
|
|
{
|
|
clearMessageFlagsFromCacheByFolder(folder.fullNameRaw);
|
|
}
|
|
|
|
_.each(data.Result['@Collection'], (jsonMessage) => {
|
|
if (jsonMessage && 'Object/Message' === jsonMessage['@Object'])
|
|
{
|
|
const message = MessageModel.newInstanceFromJson(jsonMessage);
|
|
if (message)
|
|
{
|
|
if (hasNewMessageAndRemoveFromCache(message.folderFullNameRaw, message.uid) && 5 >= newCount)
|
|
{
|
|
newCount += 1;
|
|
message.newForAnimation(true);
|
|
}
|
|
|
|
message.deleted(false);
|
|
|
|
if (cached)
|
|
{
|
|
initMessageFlagsFromCache(message);
|
|
}
|
|
else
|
|
{
|
|
storeMessageFlagsToCache(message);
|
|
}
|
|
|
|
list.push(message);
|
|
}
|
|
}
|
|
});
|
|
|
|
this.messageListCount(iCount);
|
|
this.messageListSearch(isNormal(data.Result.Search) ? data.Result.Search : '');
|
|
this.messageListPage(window.Math.ceil((iOffset / SettingsStore.messagesPerPage()) + 1));
|
|
this.messageListThreadUid(isNormal(data.Result.ThreadUid) ? pString(data.Result.ThreadUid) : '');
|
|
|
|
this.messageListEndFolder(isNormal(data.Result.Folder) ? data.Result.Folder : '');
|
|
this.messageListEndSearch(this.messageListSearch());
|
|
this.messageListEndThreadUid(this.messageListThreadUid());
|
|
this.messageListEndPage(this.messageListPage());
|
|
|
|
this.messageListDisableAutoSelect(true);
|
|
|
|
this.messageList(list);
|
|
this.messageListIsNotCompleted(false);
|
|
|
|
clearNewMessageCache();
|
|
|
|
if (folder && (cached || unreadCountChange || SettingsStore.useThreads()))
|
|
{
|
|
getApp().folderInformation(folder.fullNameRaw, list);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.messageListCount(0);
|
|
this.messageList([]);
|
|
this.messageListError(getNotification(
|
|
data && data.ErrorCode ? data.ErrorCode : Notification.CantGetMessageList
|
|
));
|
|
}
|
|
}
|
|
}
|
|
|
|
export default new MessageUserStore();
|