Bugfix: revamp MessageModel broke flags cache

And took the liberty to put all MessageFlagsCache functions into a class

dev/App/User.js

@@ -17,14 +17,11 @@ import { $htmlCL, leftPanelDisabled } from 'Common/Globals';
 import { UNUSED_OPTION_VALUE } from 'Common/Consts';
 
 import {
-	initMessageFlagsFromCache,
+	MessageFlagsCache,
 	setFolderHash,
 	getFolderHash,
 	getFolderInboxName,
-	getFolderFromCacheList,
+	getFolderFromCacheList
-	clearMessageFlagsFromCacheByFolder,
-	storeMessageFlagsToCacheBySetAction,
-	storeMessageFlagsToCacheByFolderAndUid
 } from 'Common/Cache';
 
 import {
@@ -125,10 +122,10 @@ class AppUser extends AbstractApp {
 	}
 
 	reloadFlagsCurrentMessageListAndMessageFromCache() {
-		MessageStore.messageList().forEach(message => {
+		MessageStore.messageList().forEach(message =>
-			initMessageFlagsFromCache(message);
+			MessageFlagsCache.initMessage(message)
-		});
+		);
-		initMessageFlagsFromCache(MessageStore.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 => {
+					rootUids.forEach(sSubUid =>
-						alreadyUnread += storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
+						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 => {
+					rootUids.forEach(sSubUid =>
-						alreadyUnread += storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
+						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 => {
+					rootUids.forEach(sSubUid =>
-						storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
+						MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
-					});
+					);
 
 					Remote.messageSetFlagged(()=>{}, sFolderFullNameRaw, rootUids, true);
 					break;
 
 				case MessageSetAction.UnsetFlag:
-					rootUids.forEach(sSubUid => {
+					rootUids.forEach(sSubUid =>
-						storeMessageFlagsToCacheBySetAction(sFolderFullNameRaw, sSubUid, iSetAction);
+						MessageFlagsCache.storeBySetAction(sFolderFullNameRaw, sSubUid, iSetAction)
-					});
+					);
 
 					Remote.messageSetFlagged(()=>{}, sFolderFullNameRaw, rootUids, false);
 					break;

dev/Common/Cache.js

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

dev/Model/Message.js

@@ -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;

dev/Model/MessageCollection.js

@@ -2,8 +2,7 @@ import { AbstractCollectionModel } from 'Model/AbstractCollection';
 import { MessageModel } from 'Model/Message';
 
 import {
-	initMessageFlagsFromCache,
+	MessageFlagsCache,
-	storeMessageFlagsToCache,
 	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;
 			}
 		});

dev/Remote/User/Fetch.js

@@ -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);
 						}
 					});

dev/Stores/User/Message.js

@@ -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);

dev/View/Popup/Compose.js

@@ -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], '');
 					}

dev/View/User/MailBox/MessageList.js

@@ -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);

dev/View/User/MailBox/MessageView.js

@@ -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();
 		}