Cache.js ➔ storeMessageFlagsToCacheBySetAction - Code Metrics - Inspection of "Add Persian language" - RainLoop/rainloop-webmail - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 4ee171...2f8415 )

by Rain

created 2016-09-06 21:46 UTC

Cache.js ➔ storeMessageFlagsToCacheBySetAction C

↳ Parent: dev/Common/Cache.js

Complexity

Conditions	8
Paths	11

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	8
c	1
b	0
f	0
nc	11
nop	3
dl	0
loc	35
rs	5.3846


import _ from '_';
import {Capa, MessageSetAction} from 'Common/Enums';
import {trim, pInt, isArray} from 'Common/Utils';
import * as Links from 'Common/Links';
import * as Settings from 'Storage/Settings';

let FOLDERS_CACHE = {},
	FOLDERS_NAME_CACHE = {},
	FOLDERS_HASH_CACHE = {},
	FOLDERS_UID_NEXT_CACHE = {},
	MESSAGE_FLAGS_CACHE = {},
	NEW_MESSAGE_CACHE = {},
	inboxFolderName = '';

const REQUESTED_MESSAGE_CACHE = {},
	capaGravatar = Settings.capa(Capa.Gravatar);

/**
 * @returns {void}
 */
export function clear()
{
	FOLDERS_CACHE = {};
	FOLDERS_NAME_CACHE = {};
	FOLDERS_HASH_CACHE = {};
	FOLDERS_UID_NEXT_CACHE = {};
	MESSAGE_FLAGS_CACHE = {};
}

/**
 * @param {string} email
 * @param {Function} callback
 * @returns {string}
 */
export function getUserPic(email, callback)
{
	email = trim(email);
	callback(capaGravatar && '' !== email ? Links.avatarLink(email) : '', email);
}

/**
 * @param {string} folderFullNameRaw
 * @param {string} uid
 * @returns {string}
 */
export function getMessageKey(folderFullNameRaw, uid)
{
	return `${folderFullNameRaw}#${uid}`;
}

/**
 * @param {string} folder
 * @param {string} uid
 */
export function addRequestedMessage(folder, uid)
{
	REQUESTED_MESSAGE_CACHE[getMessageKey(folder, uid)] = true;
}

/**
 * @param {string} folder
 * @param {string} uid
 * @returns {boolean}
 */
export function hasRequestedMessage(folder, uid)
{
	return true === REQUESTED_MESSAGE_CACHE[getMessageKey(folder, uid)];
}

/**
 * @param {string} folderFullNameRaw
 * @param {string} uid
 */
export function addNewMessageCache(folderFullNameRaw, uid)
{
	NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)] = true;
}

/**
 * @param {string} folderFullNameRaw
 * @param {string} uid
 */
export function hasNewMessageAndRemoveFromCache(folderFullNameRaw, uid)
{
	if (NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)])
	{
		NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)] = null;
		return true;
	}
	return false;
}

/**
 * @returns {void}
 */
export function clearNewMessageCache()
{
	NEW_MESSAGE_CACHE = {};
}

/**
 * @returns {string}
 */
export function getFolderInboxName()
{
	return '' === inboxFolderName ? 'INBOX' : inboxFolderName;
}

/**
 * @param {string} folderHash
 * @returns {string}
 */
export function getFolderFullNameRaw(folderHash)
{
	return '' !== folderHash && FOLDERS_NAME_CACHE[folderHash] ? FOLDERS_NAME_CACHE[folderHash] : '';
}

/**
 * @param {string} folderHash
 * @param {string} folderFullNameRaw
 */
export function setFolderFullNameRaw(folderHash, folderFullNameRaw)
{
	FOLDERS_NAME_CACHE[folderHash] = folderFullNameRaw;
	if ('INBOX' === folderFullNameRaw || '' === inboxFolderName)
	{
		inboxFolderName = folderFullNameRaw;
	}
}

/**
 * @param {string} folderFullNameRaw
 * @returns {string}
 */
export function getFolderHash(folderFullNameRaw)
{
	return '' !== folderFullNameRaw && FOLDERS_HASH_CACHE[folderFullNameRaw] ? FOLDERS_HASH_CACHE[folderFullNameRaw] : '';
}

/**
 * @param {string} folderFullNameRaw
 * @param {string} folderHash
 */
export function setFolderHash(folderFullNameRaw, folderHash)
{
	if ('' !== folderFullNameRaw)
	{
		FOLDERS_HASH_CACHE[folderFullNameRaw] = folderHash;
	}
}

/**
 * @param {string} folderFullNameRaw
 * @returns {string}
 */
export function getFolderUidNext(folderFullNameRaw)
{
	return '' !== folderFullNameRaw && FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] ? FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] : '';
}

/**
 * @param {string} folderFullNameRaw
 * @param {string} uidNext
 */
export function setFolderUidNext(folderFullNameRaw, uidNext)
{
	FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] = uidNext;
}

/**
 * @param {string} folderFullNameRaw
 * @returns {?FolderModel}
 */
export function getFolderFromCacheList(folderFullNameRaw)
{
	return '' !== folderFullNameRaw && FOLDERS_CACHE[folderFullNameRaw] ? FOLDERS_CACHE[folderFullNameRaw] : null;
}

/**
 * @param {string} folderFullNameRaw
 * @param {?FolderModel} folder
 */
export function setFolderToCacheList(folderFullNameRaw, folder)
{
	FOLDERS_CACHE[folderFullNameRaw] = folder;
}

/**
 * @param {string} folderFullNameRaw
 */
export function removeFolderFromCacheList(folderFullNameRaw)
{
	setFolderToCacheList(folderFullNameRaw, null);
}

/**
 * @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;
}

/**
 * @param {string} folderFullName
 * @param {string} uid
 * @param {Array} flagsCache
 */
export function setMessageFlagsToCache(folderFullName, uid, flagsCache)
{
	if (!MESSAGE_FLAGS_CACHE[folderFullName])
	{
		MESSAGE_FLAGS_CACHE[folderFullName] = {};
	}

	MESSAGE_FLAGS_CACHE[folderFullName][uid] = flagsCache;
}

/**
 * @param {string} folderFullName
 */
export function clearMessageFlagsFromCacheByFolder(folderFullName)
{
	MESSAGE_FLAGS_CACHE[folderFullName] = {};
}

/**
 * @param {(MessageModel|null)} message
 */
export function initMessageFlagsFromCache(message)
{

	if (message)
	{
		const
			uid = message.uid,
			flags = getMessageFlagsFromCache(message.folderFullNameRaw, uid);

		if (flags && 0 < flags.length)
		{
			message.flagged(!!flags[1]);

			if (!message.isSimpleMessage)
			{
				message.unseen(!!flags[0]);
				message.answered(!!flags[2]);
				message.forwarded(!!flags[3]);
				message.isReadReceipt(!!flags[4]);
				message.deletedMark(!!flags[5]);
			}
		}

		if (0 < message.threads().length)
		{
			const unseenSubUid = _.find(message.threads(), (sSubUid) => {
				if (uid !== sSubUid) {
					const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
					return subFlags && 0 < subFlags.length && !!subFlags[0];
				}
				return false;
			});

			const flaggedSubUid = _.find(message.threads(), (sSubUid) => {
				if (uid !== sSubUid) {
					const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
					return subFlags && 0 < subFlags.length && !!subFlags[1];
				}
				return false;
			});

			message.hasUnseenSubMessage(unseenSubUid && 0 < pInt(unseenSubUid));
			message.hasFlaggedSubMessage(flaggedSubUid && 0 < pInt(flaggedSubUid));
		}
	}
}

/**
 * @param {(MessageModel|null)} message
 */
export function storeMessageFlagsToCache(message)
{
	if (message)
	{
		setMessageFlagsToCache(
			message.folderFullNameRaw, message.uid,
			[message.unseen(), message.flagged(), message.answered(), message.forwarded(),
				message.isReadReceipt(), message.deletedMark()]
		);
	}
}

/**
 * @param {string} folder
 * @param {string} uid
 * @param {Array} flags
 */
export function storeMessageFlagsToCacheByFolderAndUid(folder, uid, flags)
{
	if (isArray(flags) && 0 < flags.length)
	{
		setMessageFlagsToCache(folder, uid, flags);
	}
}

/**
 * @param {string} folder
 * @param {string} uid
 * @param {number} setAction
 */
export function storeMessageFlagsToCacheBySetAction(folder, uid, setAction)
{

	let unread = 0;
	const flags = getMessageFlagsFromCache(folder, uid);

	if (isArray(flags) && 0 < flags.length)
	{
		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
		}

		setMessageFlagsToCache(folder, uid, flags);
	}

	return unread;
}


1
2			import _ from '_';
3			import {Capa, MessageSetAction} from 'Common/Enums';
4			import {trim, pInt, isArray} from 'Common/Utils';
5			import * as Links from 'Common/Links';
6			import * as Settings from 'Storage/Settings';
7
8			let FOLDERS_CACHE = {},
9			FOLDERS_NAME_CACHE = {},
10			FOLDERS_HASH_CACHE = {},
11			FOLDERS_UID_NEXT_CACHE = {},
12			MESSAGE_FLAGS_CACHE = {},
13			NEW_MESSAGE_CACHE = {},
14			inboxFolderName = '';
15
16			const REQUESTED_MESSAGE_CACHE = {},
17			capaGravatar = Settings.capa(Capa.Gravatar);
18
19			/**
20			* @returns {void}
21			*/
22			export function clear()
23			{
24			FOLDERS_CACHE = {};
25			FOLDERS_NAME_CACHE = {};
26			FOLDERS_HASH_CACHE = {};
27			FOLDERS_UID_NEXT_CACHE = {};
28			MESSAGE_FLAGS_CACHE = {};
29			}
30
31			/**
32			* @param {string} email
33			* @param {Function} callback
34			* @returns {string}
35			*/
36			export function getUserPic(email, callback)
37			{
38			email = trim(email);
39			callback(capaGravatar && '' !== email ? Links.avatarLink(email) : '', email);
40			}
41
42			/**
43			* @param {string} folderFullNameRaw
44			* @param {string} uid
45			* @returns {string}
46			*/
47			export function getMessageKey(folderFullNameRaw, uid)
48			{
49			return `${folderFullNameRaw}#${uid}`;
50			}
51
52			/**
53			* @param {string} folder
54			* @param {string} uid
55			*/
56			export function addRequestedMessage(folder, uid)
57			{
58			REQUESTED_MESSAGE_CACHE[getMessageKey(folder, uid)] = true;
59			}
60
61			/**
62			* @param {string} folder
63			* @param {string} uid
64			* @returns {boolean}
65			*/
66			export function hasRequestedMessage(folder, uid)
67			{
68			return true === REQUESTED_MESSAGE_CACHE[getMessageKey(folder, uid)];
69			}
70
71			/**
72			* @param {string} folderFullNameRaw
73			* @param {string} uid
74			*/
75			export function addNewMessageCache(folderFullNameRaw, uid)
76			{
77			NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)] = true;
78			}
79
80			/**
81			* @param {string} folderFullNameRaw
82			* @param {string} uid
83			*/
84			export function hasNewMessageAndRemoveFromCache(folderFullNameRaw, uid)
85			{
86			if (NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)])
87			{
88			NEW_MESSAGE_CACHE[getMessageKey(folderFullNameRaw, uid)] = null;
89			return true;
90			}
91			return false;
92			}
93
94			/**
95			* @returns {void}
96			*/
97			export function clearNewMessageCache()
98			{
99			NEW_MESSAGE_CACHE = {};
100			}
101
102			/**
103			* @returns {string}
104			*/
105			export function getFolderInboxName()
106			{
107			return '' === inboxFolderName ? 'INBOX' : inboxFolderName;
108			}
109
110			/**
111			* @param {string} folderHash
112			* @returns {string}
113			*/
114			export function getFolderFullNameRaw(folderHash)
115			{
116			return '' !== folderHash && FOLDERS_NAME_CACHE[folderHash] ? FOLDERS_NAME_CACHE[folderHash] : '';
117			}
118
119			/**
120			* @param {string} folderHash
121			* @param {string} folderFullNameRaw
122			*/
123			export function setFolderFullNameRaw(folderHash, folderFullNameRaw)
124			{
125			FOLDERS_NAME_CACHE[folderHash] = folderFullNameRaw;
126			if ('INBOX' === folderFullNameRaw \|\| '' === inboxFolderName)
127			{
128			inboxFolderName = folderFullNameRaw;
129			}
130			}
131
132			/**
133			* @param {string} folderFullNameRaw
134			* @returns {string}
135			*/
136			export function getFolderHash(folderFullNameRaw)
137			{
138			return '' !== folderFullNameRaw && FOLDERS_HASH_CACHE[folderFullNameRaw] ? FOLDERS_HASH_CACHE[folderFullNameRaw] : '';
139			}
140
141			/**
142			* @param {string} folderFullNameRaw
143			* @param {string} folderHash
144			*/
145			export function setFolderHash(folderFullNameRaw, folderHash)
146			{
147			if ('' !== folderFullNameRaw)
148			{
149			FOLDERS_HASH_CACHE[folderFullNameRaw] = folderHash;
150			}
151			}
152
153			/**
154			* @param {string} folderFullNameRaw
155			* @returns {string}
156			*/
157			export function getFolderUidNext(folderFullNameRaw)
158			{
159			return '' !== folderFullNameRaw && FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] ? FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] : '';
160			}
161
162			/**
163			* @param {string} folderFullNameRaw
164			* @param {string} uidNext
165			*/
166			export function setFolderUidNext(folderFullNameRaw, uidNext)
167			{
168			FOLDERS_UID_NEXT_CACHE[folderFullNameRaw] = uidNext;
169			}
170
171			/**
172			* @param {string} folderFullNameRaw
173			* @returns {?FolderModel}
174			*/
175			export function getFolderFromCacheList(folderFullNameRaw)
176			{
177			return '' !== folderFullNameRaw && FOLDERS_CACHE[folderFullNameRaw] ? FOLDERS_CACHE[folderFullNameRaw] : null;
178			}
179
180			/**
181			* @param {string} folderFullNameRaw
182			* @param {?FolderModel} folder
183			*/
184			export function setFolderToCacheList(folderFullNameRaw, folder)
185			{
186			FOLDERS_CACHE[folderFullNameRaw] = folder;
187			}
188
189			/**
190			* @param {string} folderFullNameRaw
191			*/
192			export function removeFolderFromCacheList(folderFullNameRaw)
193			{
194			setFolderToCacheList(folderFullNameRaw, null);
195			}
196
197			/**
198			* @param {string} folderFullName
199			* @param {string} uid
200			* @returns {?Array}
201			*/
202			export function getMessageFlagsFromCache(folderFullName, uid)
203			{
204			return MESSAGE_FLAGS_CACHE[folderFullName] && MESSAGE_FLAGS_CACHE[folderFullName][uid] ?
205			MESSAGE_FLAGS_CACHE[folderFullName][uid] : null;
206			}
207
208			/**
209			* @param {string} folderFullName
210			* @param {string} uid
211			* @param {Array} flagsCache
212			*/
213			export function setMessageFlagsToCache(folderFullName, uid, flagsCache)
214			{
215			if (!MESSAGE_FLAGS_CACHE[folderFullName])
216			{
217			MESSAGE_FLAGS_CACHE[folderFullName] = {};
218			}
219
220			MESSAGE_FLAGS_CACHE[folderFullName][uid] = flagsCache;
221			}
222
223			/**
224			* @param {string} folderFullName
225			*/
226			export function clearMessageFlagsFromCacheByFolder(folderFullName)
227			{
228			MESSAGE_FLAGS_CACHE[folderFullName] = {};
229			}
230
231			/**
232			* @param {(MessageModel\|null)} message
233			*/
234			export function initMessageFlagsFromCache(message)
235			{
236
237			if (message)
238			{
239			const
240			uid = message.uid,
241			flags = getMessageFlagsFromCache(message.folderFullNameRaw, uid);
242
243			if (flags && 0 < flags.length)
244			{
245			message.flagged(!!flags[1]);
246
247			if (!message.isSimpleMessage)
248			{
249			message.unseen(!!flags[0]);
250			message.answered(!!flags[2]);
251			message.forwarded(!!flags[3]);
252			message.isReadReceipt(!!flags[4]);
253			message.deletedMark(!!flags[5]);
254			}
255			}
256
257			if (0 < message.threads().length)
258			{
259			const unseenSubUid = _.find(message.threads(), (sSubUid) => {
260			if (uid !== sSubUid) {
261			const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
262			return subFlags && 0 < subFlags.length && !!subFlags[0];
263			}
264			return false;
265			});
266
267			const flaggedSubUid = _.find(message.threads(), (sSubUid) => {
268			if (uid !== sSubUid) {
269			const subFlags = getMessageFlagsFromCache(message.folderFullNameRaw, sSubUid);
270			return subFlags && 0 < subFlags.length && !!subFlags[1];
271			}
272			return false;
273			});
274
275			message.hasUnseenSubMessage(unseenSubUid && 0 < pInt(unseenSubUid));
276			message.hasFlaggedSubMessage(flaggedSubUid && 0 < pInt(flaggedSubUid));
277			}
278			}
279			}
280
281			/**
282			* @param {(MessageModel\|null)} message
283			*/
284			export function storeMessageFlagsToCache(message)
285			{
286			if (message)
287			{
288			setMessageFlagsToCache(
289			message.folderFullNameRaw, message.uid,
290			[message.unseen(), message.flagged(), message.answered(), message.forwarded(),
291			message.isReadReceipt(), message.deletedMark()]
292			);
293			}
294			}
295
296			/**
297			* @param {string} folder
298			* @param {string} uid
299			* @param {Array} flags
300			*/
301			export function storeMessageFlagsToCacheByFolderAndUid(folder, uid, flags)
302			{
303			if (isArray(flags) && 0 < flags.length)
304			{
305			setMessageFlagsToCache(folder, uid, flags);
306			}
307			}
308
309			/**
310			* @param {string} folder
311			* @param {string} uid
312			* @param {number} setAction
313			*/
314			export function storeMessageFlagsToCacheBySetAction(folder, uid, setAction)
315			{
316
317			let unread = 0;
318			const flags = getMessageFlagsFromCache(folder, uid);
319
320			if (isArray(flags) && 0 < flags.length)
321			{
322			if (flags[0])
323			{
324			unread = 1;
325			}
326
327			switch (setAction)
328			{
329			case MessageSetAction.SetSeen:
330			flags[0] = false;
331			break;
332			case MessageSetAction.UnsetSeen:
333			flags[0] = true;
334			break;
335			case MessageSetAction.SetFlag:
336			flags[1] = true;
337			break;
338			case MessageSetAction.UnsetFlag:
339			flags[1] = false;
340			break;
341			// no default
342			}
343
344			setMessageFlagsToCache(folder, uid, flags);
345			}
346
347			return unread;
348			}
349

RainLoop / rainloop-webmail

Push — master ( 4ee171...2f8415 )

Cache.js ➔ storeMessageFlagsToCacheBySetAction C

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like