mirror of
https://github.com/the-djmaze/snappymail.git
synced 2025-01-06 06:52:20 +08:00
767 lines
21 KiB
JavaScript
767 lines
21 KiB
JavaScript
import ko from 'ko';
|
|
|
|
import { Layout, Focused, MessageSetAction, StorageResultType, Notification } from 'Common/Enums';
|
|
|
|
import {
|
|
pInt,
|
|
pString,
|
|
plainToHtml,
|
|
findEmailAndLinks
|
|
} 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 { mailBox, notificationMailIcon } from 'Common/Links';
|
|
import { i18n, getNotification } from 'Common/Translator';
|
|
|
|
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';
|
|
|
|
const
|
|
hcont = Element.fromHTML('<div area="hidden" style="position:absolute;left:-5000px"></div>'),
|
|
getRealHeight = el => {
|
|
hcont.innerHTML = el.outerHTML;
|
|
const result = hcont.clientHeight;
|
|
hcont.innerHTML = '';
|
|
return result;
|
|
};
|
|
|
|
let iMessageBodyCacheCount = 0;
|
|
|
|
document.body.append(hcont);
|
|
|
|
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: 50 });
|
|
|
|
this.messageFullScreenMode = ko.observable(false);
|
|
|
|
this.messagesBodiesDom = ko.observable(null);
|
|
this.messageActiveDom = ko.observable(null);
|
|
|
|
this.computers();
|
|
this.subscribers();
|
|
|
|
this.onMessageResponse = this.onMessageResponse.bind(this);
|
|
|
|
this.purgeMessageBodyCacheThrottle = this.purgeMessageBodyCache.throttle(30000);
|
|
}
|
|
|
|
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 = 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, value.toString().trim(), 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(() => this.messageList().filter(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 selectedMessage
|
|
? checked.concat([selectedMessage]).filter((value, index, self) => self.indexOf(value) == index)
|
|
: checked;
|
|
} else if (selectedMessage) {
|
|
return [selectedMessage];
|
|
}
|
|
|
|
return focusedMessage ? [focusedMessage] : [];
|
|
});
|
|
|
|
this.messageListCheckedOrSelectedUidsWithSubMails = ko.computed(() => {
|
|
let result = [];
|
|
this.messageListCheckedOrSelected().forEach(message => {
|
|
if (message) {
|
|
result.push(message.uid);
|
|
if (1 < message.threadsLen()) {
|
|
result = result.concat(message.threads()).filter((value, index, self) => self.indexOf(value) == index);
|
|
}
|
|
}
|
|
});
|
|
return result;
|
|
});
|
|
}
|
|
|
|
subscribers() {
|
|
this.messageListCompleteLoading.subscribe((value) => {
|
|
value = !!value;
|
|
this.messageListCompleteLoadingThrottle(value);
|
|
this.messageListCompleteLoadingThrottleForAnimation(value);
|
|
});
|
|
|
|
this.messageList.subscribe(
|
|
(list=> {
|
|
list.forEach(item =>
|
|
item && item.newForAnimation() && item.newForAnimation(false)
|
|
)
|
|
}).debounce(500)
|
|
);
|
|
|
|
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.messageListEndFolder.subscribe(folder => {
|
|
const message = this.message();
|
|
if (message && folder && folder !== message.folderFullNameRaw) {
|
|
this.message(null);
|
|
}
|
|
});
|
|
}
|
|
|
|
purgeMessageBodyCache() {
|
|
const end = iMessageBodyCacheCount - MESSAGE_BODY_CACHE_LIMIT;
|
|
if (0 < end) {
|
|
let count = 0;
|
|
const messagesDom = this.messagesBodiesDom();
|
|
if (messagesDom) {
|
|
messagesDom.querySelectorAll('.rl-cache-class').forEach(node => {
|
|
if (end > node.rlCacheCount) {
|
|
node.classList.add('rl-cache-purge');
|
|
++count;
|
|
}
|
|
});
|
|
|
|
if (0 < count) {
|
|
setTimeout(() => messagesDom.querySelectorAll('.rl-cache-purge').forEach(node => node.remove()), 350);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
initUidNextAndNewMessages(folder, uidNext, newMessages) {
|
|
if (getFolderInboxName() === folder && uidNext) {
|
|
if (Array.isArray(newMessages) && newMessages.length) {
|
|
newMessages.forEach(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 {
|
|
newMessages.forEach(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();
|
|
messagesDom && messagesDom.querySelectorAll('.b-text-part').forEach(el => el.hidden = true);
|
|
}
|
|
|
|
/**
|
|
* @param {string} fromFolderFullNameRaw
|
|
* @param {Array} uidForRemove
|
|
* @param {string=} toFolderFullNameRaw = ''
|
|
* @param {boolean=} copy = false
|
|
*/
|
|
removeMessagesFromList(fromFolderFullNameRaw, uidForRemove, toFolderFullNameRaw = '', copy = false) {
|
|
uidForRemove = uidForRemove.map(mValue => pInt(mValue));
|
|
|
|
let unseenCount = 0,
|
|
messageList = this.messageList(),
|
|
currentMessage = this.message();
|
|
|
|
const trashFolder = FolderStore.trashFolder(),
|
|
spamFolder = FolderStore.spamFolder(),
|
|
fromFolder = getFolderFromCacheList(fromFolderFullNameRaw),
|
|
toFolder = toFolderFullNameRaw ? getFolderFromCacheList(toFolderFullNameRaw) : null,
|
|
currentFolderFullNameRaw = FolderStore.currentFolderFullNameRaw(),
|
|
messages =
|
|
currentFolderFullNameRaw === fromFolderFullNameRaw
|
|
? messageList.filter(item => item && uidForRemove.includes(pInt(item.uid)))
|
|
: [];
|
|
|
|
messages.forEach(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 (messages.length) {
|
|
if (copy) {
|
|
messages.forEach(item => {
|
|
item.checked(false);
|
|
});
|
|
} else {
|
|
this.messageListIsNotCompleted(true);
|
|
|
|
messages.forEach(item => {
|
|
if (currentMessage && currentMessage.hash === item.hash) {
|
|
currentMessage = null;
|
|
this.message(null);
|
|
}
|
|
|
|
item.deleted(true);
|
|
});
|
|
|
|
setTimeout(() => {
|
|
messages.forEach(item => {
|
|
this.messageList.remove(item);
|
|
});
|
|
}, 350);
|
|
}
|
|
}
|
|
|
|
if (fromFolderFullNameRaw) {
|
|
setFolderHash(fromFolderFullNameRaw, '');
|
|
}
|
|
|
|
if (toFolderFullNameRaw) {
|
|
setFolderHash(toFolderFullNameRaw, '');
|
|
}
|
|
|
|
if (this.messageListThreadUid()) {
|
|
messageList = this.messageList();
|
|
|
|
if (
|
|
messageList &&
|
|
messageList.length &&
|
|
!!messageList.find(item => !!(item && item.deleted() && item.uid === this.messageListThreadUid()))
|
|
) {
|
|
const message = messageList.find(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) {
|
|
messageTextBody && messageTextBody.querySelectorAll('blockquote:not(.rl-bq-switcher)').forEach(node => {
|
|
if (node.textContent.trim() && !node.parentNode.closest('blockquote')) {
|
|
let h = node.clientHeight || getRealHeight(node);
|
|
if (0 === h || 100 < h) {
|
|
const el = Element.fromHTML('<span class="rlBlockquoteSwitcher">•••</span>');
|
|
node.classList.add('rl-bq-switcher','hidden-bq');
|
|
node.before(el);
|
|
el.addEventListener('click', () => node.classList.toggle('hidden-bq'));
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* @param {Object} messageTextBody
|
|
* @param {Object} message
|
|
*/
|
|
initOpenPgpControls(messageTextBody, message) {
|
|
messageTextBody && messageTextBody.querySelectorAll('.b-plain-openpgp:not(.inited)').forEach(node =>
|
|
PgpStore.initMessageBodyControls(node, message)
|
|
);
|
|
}
|
|
|
|
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 && threads.includes(data.Result.Uid)) {
|
|
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);
|
|
}
|
|
|
|
if (messagesDom) {
|
|
id = 'rl-mgs-' + message.hash.replace(/[^a-zA-Z0-9]/g, '');
|
|
|
|
const textBody = document.getElementById(id);
|
|
if (textBody) {
|
|
iMessageBodyCacheCount += 1;
|
|
textBody.rlCacheCount = iMessageBodyCacheCount;
|
|
message.fetchDataFromDom();
|
|
} else {
|
|
let isHtml = false;
|
|
if (data.Result.Html) {
|
|
isHtml = true;
|
|
resultHtml = data.Result.Html.toString();
|
|
} else if (data.Result.Plain) {
|
|
isHtml = false;
|
|
resultHtml = plainToHtml(data.Result.Plain.toString());
|
|
|
|
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);
|
|
}
|
|
|
|
const pre = document.createElement('pre');
|
|
if (pgpSigned && message.isPgpSigned()) {
|
|
pre.className = 'b-plain-openpgp signed';
|
|
pre.textContent = plain;
|
|
} else if (isPgpEncrypted && message.isPgpEncrypted()) {
|
|
pre.className = 'b-plain-openpgp encrypted';
|
|
pre.textContent = plain;
|
|
} else {
|
|
pre.innerHTML = resultHtml;
|
|
}
|
|
resultHtml = pre.outerHTML;
|
|
|
|
message.isPgpSigned(pgpSigned);
|
|
message.isPgpEncrypted(isPgpEncrypted);
|
|
} else {
|
|
resultHtml = '<pre>' + resultHtml + '</pre>';
|
|
}
|
|
} else {
|
|
isHtml = false;
|
|
resultHtml = '<pre>' + resultHtml + '</pre>';
|
|
}
|
|
|
|
iMessageBodyCacheCount += 1;
|
|
|
|
body = Element.fromHTML('<div id="' + id + '" hidden="" class="rl-cache-class b-text-part '
|
|
+ (isHtml ? 'html' : 'plain') + '">'
|
|
+ findEmailAndLinks(resultHtml)
|
|
+ '</div>');
|
|
body.rlCacheCount = iMessageBodyCacheCount;
|
|
|
|
message.isHtml(!!isHtml);
|
|
message.hasImages(!!data.Result.HasExternals);
|
|
|
|
messagesDom.append(body);
|
|
|
|
message.storeDataInDom();
|
|
|
|
if (data.Result.HasInternals) {
|
|
message.showInternalImages();
|
|
}
|
|
|
|
if (message.hasImages() && SettingsStore.showImages()) {
|
|
message.showExternalImages();
|
|
}
|
|
|
|
this.purgeMessageBodyCacheThrottle();
|
|
}
|
|
|
|
message.body = body || textBody;
|
|
this.messageActiveDom(message.body);
|
|
|
|
this.hideMessageBodies();
|
|
|
|
if (body) {
|
|
this.initOpenPgpControls(body, message);
|
|
|
|
this.initBlockquoteSwitcher(body);
|
|
}
|
|
|
|
message.body.hidden = false;
|
|
}
|
|
|
|
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 = this.messageList().find(
|
|
subMessage =>
|
|
subMessage &&
|
|
subMessage.folderFullNameRaw === message.folderFullNameRaw &&
|
|
subMessage.uid === message.uid
|
|
);
|
|
|
|
if (selectedMessage) {
|
|
this.selectorMessageSelected(selectedMessage);
|
|
this.selectorMessageFocused(selectedMessage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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 list.map(message => '' + message.hash + '_' + message.threadsLen() + '_' + message.flagHash()).join(
|
|
'|'
|
|
);
|
|
}
|
|
|
|
setMessageList(data, cached) {
|
|
if (
|
|
data &&
|
|
data.Result &&
|
|
'Collection/MessageCollection' === data.Result['@Object'] &&
|
|
data.Result['@Collection'] &&
|
|
Array.isArray(data.Result['@Collection'])
|
|
) {
|
|
let newCount = 0,
|
|
unreadCountChange = false;
|
|
|
|
const list = [],
|
|
iCount = pInt(data.Result.MessageResultCount),
|
|
iOffset = pInt(data.Result.Offset);
|
|
|
|
const folder = getFolderFromCacheList(data.Result.Folder);
|
|
|
|
if (folder && !cached) {
|
|
folder.interval = Date.now() / 1000;
|
|
|
|
setFolderHash(data.Result.Folder, data.Result.FolderHash);
|
|
|
|
if (null != data.Result.MessageCount) {
|
|
folder.messageCountAll(data.Result.MessageCount);
|
|
}
|
|
|
|
if (null != 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);
|
|
}
|
|
|
|
data.Result['@Collection'].forEach(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(null != data.Result.Search ? data.Result.Search : '');
|
|
this.messageListPage(Math.ceil(iOffset / SettingsStore.messagesPerPage() + 1));
|
|
this.messageListThreadUid(null != data.Result.ThreadUid ? pString(data.Result.ThreadUid) : '');
|
|
|
|
this.messageListEndFolder(null != 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();
|