the-djmaze/snappymail
1
1
Fork 0
mirror of https://github.com/the-djmaze/snappymail.git synced 2024-09-20 07:35:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

Bugfix: revamp MessageModel broke flags cache

Browse source 
And took the liberty to put all MessageFlagsCache functions into a class
This commit is contained in:
djmaze 2020-10-25 13:50:26 +01:00
parent d7a4639d6b
commit 22f606ea75
9 changed files with 157 additions and 161 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

45
dev/App/User.js
View file

@ -17,14 +17,11 @@ import { $htmlCL, leftPanelDisabled } from 'Common/Globals';
import { UNUSED_OPTION_VALUE } from 'Common/Consts';
import {
initMessageFlagsFromCache,
MessageFlagsCache,
setFolderHash,
getFolderHash,
getFolderInboxName,
getFolderFromCacheList,
clearMessageFlagsFromCacheByFolder,
storeMessageFlagsToCacheBySetAction,
storeMessageFlagsToCacheByFolderAndUid
getFolderFromCacheList
} from 'Common/Cache';
import {
@ -125,10 +122,10 @@ class AppUser extends AbstractApp {
}
reloadFlagsCurrentMessageListAndMessageFromCache() {
MessageStore.messageList().forEach(message => {
initMessageFlagsFromCache(message);
});
initMessageFlagsFromCache(MessageStore.message());
MessageStore.messageList().forEach(message =>
MessageFlagsCache.initMessage(message)
);
MessageFlagsCache.initMessage(MessageStore.message());
}
/**
@ -587,7 +584,7 @@ class AppUser extends AbstractApp {
}
if (unreadCountChange) {
clearMessageFlagsFromCacheByFolder(folderFromCache.fullNameRaw);
MessageFlagsCache.clearFolder(folderFromCache.fullNameRaw);
}
if (data.Result.Flags) {
@ -595,7 +592,7 @@ class AppUser extends AbstractApp {
if (Object.prototype.hasOwnProperty.call(data.Result.Flags, uid)) {
check = true;
const flags = data.Result.Flags[uid];
storeMessageFlagsToCacheByFolderAndUid(folderFromCache.fullNameRaw, uid.toString(), [
MessageFlagsCache.storeByFolderAndUid(folderFromCache.fullNameRaw, uid.toString(), [
!!flags.IsUnseen,
!!flags.IsFlagged,
!!flags.IsAnswered,
@ -669,7 +666,7 @@ class AppUser extends AbstractApp {
}
if (unreadCountChange) {
clearMessageFlagsFromCacheByFolder(folder.fullNameRaw);
MessageFlagsCache.clearFolder(folder.fullNameRaw);
}
if (!hash || item.Hash !== hash) {
@ -716,9 +713,9 @@ class AppUser extends AbstractApp {
if (sFolderFullNameRaw && rootUids.length) {
switch (iSetAction) {
case MessageSetAction.SetSeen:
rootUids.forEach(sSubUid => {
alreadyUnread += storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
});
rootUids.forEach(sSubUid =>
alreadyUnread += MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
);
folder = getFolderFromCacheList(sFolderFullNameRaw);
if (folder) {
@ -729,9 +726,9 @@ class AppUser extends AbstractApp {
break;
case MessageSetAction.UnsetSeen:
rootUids.forEach(sSubUid => {
alreadyUnread += storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
});
rootUids.forEach(sSubUid =>
alreadyUnread += MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
);
folder = getFolderFromCacheList(sFolderFullNameRaw);
if (folder) {
@ -742,17 +739,17 @@ class AppUser extends AbstractApp {
break;
case MessageSetAction.SetFlag:
rootUids.forEach(sSubUid => {
storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
});
rootUids.forEach(sSubUid =>
MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
);
Remote.messageSetFlagged(()=>{}, sFolderFullNameRaw, rootUids, true);
break;
case MessageSetAction.UnsetFlag:
rootUids.forEach(sSubUid => {
storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
});
rootUids.forEach(sSubUid =>
MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
);
Remote.messageSetFlagged(()=>{}, sFolderFullNameRaw, rootUids, false);
break;

229
dev/Common/Cache.js
View file

@ -158,139 +158,142 @@ export function removeFolderFromCacheList(folderFullNameRaw) {
delete FOLDERS_CACHE[folderFullNameRaw];
}
/**
* @param {string} folderFullName
* @param {string} uid
* @returns {?Array}
*/
export function getMessageFlagsFromCache(folderFullName, uid) {
return MESSAGE_FLAGS_CACHE[folderFullName] && MESSAGE_FLAGS_CACHE[folderFullName][uid]
? MESSAGE_FLAGS_CACHE[folderFullName][uid]
: null;
}
export class MessageFlagsCache
{
/**
* @param {string} folderFullName
* @param {string} uid
* @returns {?Array}
*/
static getFor(folderFullName, uid) {
return MESSAGE_FLAGS_CACHE[folderFullName] && MESSAGE_FLAGS_CACHE[folderFullName][uid]
? MESSAGE_FLAGS_CACHE[folderFullName][uid]
: null;
}
/**
* @param {string} folderFullName
* @param {string} uid
* @param {Array} flagsCache
*/
export function setMessageFlagsToCache(folderFullName, uid, flagsCache) {
if (!MESSAGE_FLAGS_CACHE[folderFullName]) {
/**
* @param {string} folderFullName
* @param {string} uid
* @param {Array} flagsCache
*/
static setFor(folderFullName, uid, flagsCache) {
if (!MESSAGE_FLAGS_CACHE[folderFullName]) {
MESSAGE_FLAGS_CACHE[folderFullName] = {};
}
MESSAGE_FLAGS_CACHE[folderFullName][uid] = flagsCache;
}
/**
* @param {string} folderFullName
*/
static clearFolder(folderFullName) {
MESSAGE_FLAGS_CACHE[folderFullName] = {};
}
MESSAGE_FLAGS_CACHE[folderFullName][uid] = flagsCache;
}
/**
* @param {(MessageModel|null)} message
*/
static initMessage(message) {
if (message) {
const uid = message.uid,
flags = this.getFor(message.folder, uid);
/**
* @param {string} folderFullName
*/
export function clearMessageFlagsFromCacheByFolder(folderFullName) {
MESSAGE_FLAGS_CACHE[folderFullName] = {};
}
if (flags && flags.length) {
message.isFlagged(!!flags[1]);
/**
* @param {(MessageModel|null)} message
*/
export function initMessageFlagsFromCache(message) {
if (message) {
const uid = message.uid,
flags = getMessageFlagsFromCache(message.folderFullNameRaw, uid);
if (!message.isSimpleMessage) {
message.isUnseen(!!flags[0]);
message.isAnswered(!!flags[2]);
message.isForwarded(!!flags[3]);
message.isReadReceipt(!!flags[4]);
message.isDeleted(!!flags[5]);
}
}
if (flags && flags.length) {
message.isFlagged(!!flags[1]);
if (message.threads().length) {
const unseenSubUid = message.threads().find(sSubUid => {
if (uid !== sSubUid) {
const subFlags = this.getFor(message.folder, sSubUid);
return subFlags && subFlags.length && !!subFlags[0];
}
return false;
});
if (!message.isSimpleMessage) {
message.isUnseen(!!flags[0]);
message.isAnswered(!!flags[2]);
message.isForwarded(!!flags[3]);
message.isReadReceipt(!!flags[4]);
message.isDeleted(!!flags[5]);
const flaggedSubUid = message.threads().find(sSubUid => {
if (uid !== sSubUid) {
const subFlags = this.getFor(message.folder, sSubUid);
return subFlags && subFlags.length && !!subFlags[1];
}
return false;
});
message.hasUnseenSubMessage(unseenSubUid && 0 < pInt(unseenSubUid));
message.hasFlaggedSubMessage(flaggedSubUid && 0 < pInt(flaggedSubUid));
}
}
}
if (message.threads().length) {
const unseenSubUid = message.threads().find(sSubUid => {
if (uid !== sSubUid) {
const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
return subFlags && subFlags.length && !!subFlags[0];
}
return false;
});
const flaggedSubUid = message.threads().find(sSubUid => {
if (uid !== sSubUid) {
const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
return subFlags && subFlags.length && !!subFlags[1];
}
return false;
});
message.hasUnseenSubMessage(unseenSubUid && 0 < pInt(unseenSubUid));
message.hasFlaggedSubMessage(flaggedSubUid && 0 < pInt(flaggedSubUid));
/**
* @param {(MessageModel|null)} message
*/
static store(message) {
if (message) {
this.setFor(message.folder, message.uid, [
message.isUnseen(),
message.isFlagged(),
message.isAnswered(),
message.isForwarded(),
message.isReadReceipt(),
message.isDeleted()
]);
}
}
}
/**
* @param {(MessageModel|null)} message
*/
export function storeMessageFlagsToCache(message) {
if (message) {
setMessageFlagsToCache(message.folderFullNameRaw, message.uid, [
message.isUnseen(),
message.isFlagged(),
message.isAnswered(),
message.isForwarded(),
message.isReadReceipt(),
message.isDeleted()
]);
/**
* @param {string} folder
* @param {string} uid
* @param {Array} flags
*/
static storeByFolderAndUid(folder, uid, flags) {
if (Array.isNotEmpty(flags)) {
this.setFor(folder, uid, flags);
}
}
}
/**
* @param {string} folder
* @param {string} uid
* @param {Array} flags
*/
export function storeMessageFlagsToCacheByFolderAndUid(folder, uid, flags) {
if (Array.isNotEmpty(flags)) {
setMessageFlagsToCache(folder, uid, flags);
}
}
/**
* @param {string} folder
* @param {string} uid
* @param {number} setAction
*/
static storeBySetAction(folder, uid, setAction) {
let unread = 0;
const flags = this.getFor(folder, uid);
/**
* @param {string} folder
* @param {string} uid
* @param {number} setAction
*/
export function storeMessageFlagsToCacheBySetAction(folder, uid, setAction) {
let unread = 0;
const flags = getMessageFlagsFromCache(folder, uid);
if (Array.isNotEmpty(flags)) {
if (flags[0]) {
unread = 1;
}
if (Array.isNotEmpty(flags)) {
if (flags[0]) {
unread = 1;
switch (setAction) {
case MessageSetAction.SetSeen:
flags[0] = false;
break;
case MessageSetAction.UnsetSeen:
flags[0] = true;
break;
case MessageSetAction.SetFlag:
flags[1] = true;
break;
case MessageSetAction.UnsetFlag:
flags[1] = false;
break;
// no default
}
this.setFor(folder, uid, flags);
}
switch (setAction) {
case MessageSetAction.SetSeen:
flags[0] = false;
break;
case MessageSetAction.UnsetSeen:
flags[0] = true;
break;
case MessageSetAction.SetFlag:
flags[1] = true;
break;
case MessageSetAction.UnsetFlag:
flags[1] = false;
break;
// no default
}
setMessageFlagsToCache(folder, uid, flags);
return unread;
}
return unread;
}

8
dev/Model/Message.js
View file

@ -415,12 +415,7 @@ class MessageModel extends AbstractModel {
this.hash = message.hash;
this.requestHash = message.requestHash;
this.subject(message.subject());
}
this.subjectPrefix(this.subjectPrefix());
this.subjectSuffix(this.subjectSuffix());
if (message) {
this.size(message.size());
this.dateTimeStampInUTC(message.dateTimeStampInUTC());
this.priority(message.priority());
@ -450,6 +445,9 @@ class MessageModel extends AbstractModel {
this.checked(message.checked());
this.hasAttachments(message.hasAttachments());
this.attachmentsSpecData(message.attachmentsSpecData());
this.subjectPrefix(this.subjectPrefix());
this.subjectSuffix(this.subjectSuffix());
}
this.body = null;

5
dev/Model/MessageCollection.js
View file

@ -2,8 +2,7 @@ import { AbstractCollectionModel } from 'Model/AbstractCollection';
import { MessageModel } from 'Model/Message';
import {
initMessageFlagsFromCache,
storeMessageFlagsToCache,
MessageFlagsCache,
hasNewMessageAndRemoveFromCache
} from 'Common/Cache';
@ -45,7 +44,7 @@ export class MessageCollectionModel extends AbstractCollectionModel
message.deleted(false);
cached ? initMessageFlagsFromCache(message) : storeMessageFlagsToCache(message);
cached ? MessageFlagsCache.initMessage(message) : MessageFlagsCache.store(message);
return message;
}
});

6
dev/Remote/User/Fetch.js
View file

@ -5,7 +5,7 @@ import {
getFolderInboxName,
getFolderUidNext,
getFolderFromCacheList,
getMessageFlagsFromCache
MessageFlagsCache
} from 'Common/Cache';
import { subQueryPrefix } from 'Common/Links';
@ -432,13 +432,13 @@ class RemoteUserFetch extends AbstractFetchRemote {
if (Array.isNotEmpty(list)) {
request = false;
list.forEach(messageListItem => {
if (!getMessageFlagsFromCache(messageListItem.folder, messageListItem.uid)) {
if (!MessageFlagsCache.getFor(messageListItem.folder, messageListItem.uid)) {
uids.push(messageListItem.uid);
}
if (messageListItem.threads().length) {
messageListItem.threads().forEach(uid => {
if (!getMessageFlagsFromCache(messageListItem.folder, uid)) {
if (!MessageFlagsCache.getFor(messageListItem.folder, uid)) {
uids.push(uid);
}
});

9
dev/Stores/User/Message.js
View file

@ -11,9 +11,8 @@ import {
setFolderUidNext,
getFolderFromCacheList,
setFolderHash,
initMessageFlagsFromCache,
MessageFlagsCache,
addRequestedMessage,
clearMessageFlagsFromCacheByFolder,
clearNewMessageCache
} from 'Common/Cache';
@ -462,7 +461,7 @@ class MessageUserStore {
message = MessageModel.reviveFromJson(json);
if (message) {
message.threads(threads);
initMessageFlagsFromCache(message);
MessageFlagsCache.initMessage(message);
this.message(this.staticMessage.populateByMessageListItem(message));
message = this.message();
@ -580,7 +579,7 @@ class MessageUserStore {
message.body.hidden = false;
}
initMessageFlagsFromCache(message);
MessageFlagsCache.initMessage(message);
if (message.isUnseen() || message.hasUnseenSubMessage()) {
rl.app.messageListAction(message.folder, MessageSetAction.SetSeen, [message]);
}
@ -696,7 +695,7 @@ class MessageUserStore {
if (null != collection.MessageUnseenCount) {
if (pInt(folder.messageCountUnread()) !== pInt(collection.MessageUnseenCount)) {
unreadCountChange = true;
clearMessageFlagsFromCacheByFolder(folder.fullNameRaw);
MessageFlagsCache.clearFolder(folder.fullNameRaw);
}
folder.messageCountUnread(collection.MessageUnseenCount);

6
dev/View/Popup/Compose.js
View file

@ -18,7 +18,7 @@ import { UNUSED_OPTION_VALUE } from 'Common/Consts';
import { upload } from 'Common/Links';
import { i18n, getNotification, getUploadErrorDescByCode } from 'Common/Translator';
import { format as momentorFormat } from 'Common/Momentor';
import { getMessageFlagsFromCache, setMessageFlagsToCache, setFolderHash } from 'Common/Cache';
import { MessageFlagsCache, setFolderHash } from 'Common/Cache';
import { HtmlEditor } from 'Common/HtmlEditor';
@ -402,7 +402,7 @@ class ComposePopupView extends AbstractViewNext {
this.sending(true);
if (Array.isArray(this.aDraftInfo) && 3 === this.aDraftInfo.length) {
const flagsCache = getMessageFlagsFromCache(this.aDraftInfo[2], this.aDraftInfo[1]);
const flagsCache = MessageFlagsCache.getFlags(this.aDraftInfo[2], this.aDraftInfo[1]);
if (flagsCache) {
if ('forward' === this.aDraftInfo[0]) {
flagsCache[3] = true;
@ -410,7 +410,7 @@ class ComposePopupView extends AbstractViewNext {
flagsCache[2] = true;
}
setMessageFlagsToCache(this.aDraftInfo[2], this.aDraftInfo[1], flagsCache);
MessageFlagsCache.setFor(this.aDraftInfo[2], this.aDraftInfo[1], flagsCache);
rl.app.reloadFlagsCurrentMessageListAndMessageFromCache();
setFolderHash(this.aDraftInfo[2], '');
}

6
dev/View/User/MailBox/MessageList.js
View file

@ -25,7 +25,7 @@ import { i18n, initOnStartOrLangChange } from 'Common/Translator';
import {
getFolderFromCacheList,
clearMessageFlagsFromCacheByFolder,
MessageFlagsCache,
hasRequestedMessage,
addRequestedMessage
} from 'Common/Cache';
@ -520,7 +520,7 @@ class MessageListMailBoxUserView extends AbstractViewNext {
folder.messageCountUnread(0);
}
clearMessageFlagsFromCacheByFolder(sFolderFullNameRaw);
MessageFlagsCache.clearFolder(sFolderFullNameRaw);
}
Remote.messageSetSeenToAll(()=>{}, sFolderFullNameRaw, true, sThreadUid ? uids : null);
@ -546,7 +546,7 @@ class MessageListMailBoxUserView extends AbstractViewNext {
folder.messageCountUnread(folder.messageCountAll());
}
clearMessageFlagsFromCacheByFolder(sFolderFullNameRaw);
MessageFlagsCache.clearFolder(sFolderFullNameRaw);
}
Remote.messageSetSeenToAll(()=>{}, sFolderFullNameRaw, false, sThreadUid ? uids : null);

4
dev/View/User/MailBox/MessageView.js
View file

@ -23,7 +23,7 @@ import Audio from 'Common/Audio';
import { i18n } from 'Common/Translator';
import { attachmentDownload } from 'Common/Links';
import { storeMessageFlagsToCache } from 'Common/Cache';
import { MessageFlagsCache } from 'Common/Cache';
import AppStore from 'Stores/User/App';
import SettingsStore from 'Stores/User/Settings';
@ -771,7 +771,7 @@ class MessageViewMailBoxUserView extends AbstractViewNext {
oMessage.isReadReceipt(true);
storeMessageFlagsToCache(oMessage);
MessageFlagsCache.store(oMessage);
rl.app.reloadFlagsCurrentMessageListAndMessageFromCache();
}