@resolveio/server-lib 12.5.52 → 12.5.54

package/src/util/common.ts

@@ -0,0 +1,519 @@
+let rusDiff = require('rus-diff');
+let deepDiff = require('deep-diff').diff;
+import { LookupTables } from '../models/report-builder.model';
+let clone = require('clone');
+
+export function buildRbSchema(rbSchema: any) {
+	Object.keys(rbSchema).forEach(key => {
+		if (rbSchema[key].type === Object) {
+			rbSchema[key].type = 'Object';
+			rbSchema[key].rbType = 'Object';
+		}
+		else if (rbSchema[key].type === Array) {
+			rbSchema[key].type = 'Array';
+			rbSchema[key].rbType = 'Array';
+		}
+		else if (rbSchema[key].type === String) {
+			rbSchema[key].type = 'String';
+			rbSchema[key].rbType = 'String';
+		}
+		else if (rbSchema[key].type === Date) {
+			rbSchema[key].type = 'Date';
+			rbSchema[key].rbType = 'Date';
+		}
+		else if (rbSchema[key].type === Number) {
+			rbSchema[key].type = 'Number';
+			rbSchema[key].rbType = 'Number';
+		}
+		else if (rbSchema[key].type === Boolean) {
+			rbSchema[key].rbType = 'Boolean';
+			rbSchema[key].type = 'Boolean';
+		}
+	});
+
+	Object.keys(rbSchema).forEach(key => {
+		delete rbSchema[key].type;
+	});
+
+	return rbSchema;
+}
+
+export function buildRbLookups(rbLookups: LookupTables[], defaultSchema: object, default_checked_array: string[] = []) {
+	// Remember: lkp.local_key will be removed later on, because it has 'id_'
+	
+	rbLookups.forEach(lkp => {
+		let errString = '';
+		let localKey, newPropertyName;
+		let localKeyDir = '';
+		let localKeyDirDot = '';
+		let collectionAlias = toTitleCase(lkp.lookup.replace(/\_/g, ' ')) + ' (' + toTitleCase(lkp.local_key.replace('id_', '').replace(/\_/g, ' ').replace(/\.\$\./g, ' -> ').replace(/\./g, ' -> ')) + ') (Lookup)';
+
+		if (lkp.local_key.match(/\./)) {
+			localKey = lkp.local_key.replace(/\.\$/g, '');
+			localKeyDirDot = lkp.local_key.replace(/^(.+\.).*$/, '$1');
+			localKeyDir = localKeyDirDot.replace(/\.$/, '');
+		}
+		else {
+			// local_key is a root leaf node.
+			localKey = lkp.local_key;
+		}
+		newPropertyName = localKeyDirDot + collectionAlias;
+		
+		if (!defaultSchema[lkp.local_key]) {
+			errString += '--local_key: \'' + lkp.local_key + '\' MUST be a valid schema path! ';
+		}
+		else if (defaultSchema[lkp.local_key].type !== String) {
+			errString += '--local_key: \'' + lkp.local_key + '\' MUST be a String! ';
+		}
+		let lookupNode = {
+			lookup_collection: lkp.lookup,
+			lookup_collection_alias: collectionAlias,
+			local_key: localKey,
+			field_path: localKeyDir,
+			lookup_as: newPropertyName,
+			lookup_key: '_id',
+			type: 'Object',
+		};
+
+		defaultSchema[newPropertyName] = lookupNode;
+
+		if (errString) {
+			throwErr(errString, lkp, lookupNode, newPropertyName);
+		}
+	});
+
+	for (let ii = 0; ii < default_checked_array.length; ii++) {
+		defaultSchema[default_checked_array[ii]] = {};
+		defaultSchema[default_checked_array[ii]]['default_checked'] = true;
+		Object.assign(defaultSchema[default_checked_array[ii]], defaultSchema['tree'][default_checked_array[ii]]);
+	}
+
+	return defaultSchema;
+}
+
+export function throwErr(err: any, lkp, lookupNode, newPropertyName = '') {
+	// err could be from a try/throw/catch
+	console.log('------- ERROR thrown by rbLookups: ');
+	console.log(err);
+	console.log('---item: ');
+	console.log(lkp);
+	console.log('---Attempted to create rbSchema[\'' + newPropertyName + '\']: ');
+	console.log(lookupNode);
+	process.exit(1);
+}
+
+export function roundPrecision(value: number, precision = 0) {
+	let stringValue = value.toString();
+	
+	if (stringValue.includes('.')) {
+		if (stringValue[0] === '0') {
+			precision += 1;
+		}
+		
+		precision -= stringValue.indexOf('.');
+	}
+
+	const exponent = Math.pow(10, precision);
+	return Math.round(parseFloat(stringValue) * exponent) / exponent;
+}
+
+export function deepCopy(value) {
+	return clone(value);
+}
+
+export function dateReviver(key, value) {
+	if (typeof value === 'string') {
+		let a = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2}(?:\.\d*)?)Z$/.exec(value);
+		if (a) {
+			return new Date(Date.UTC(+a[1], +a[2] - 1, +a[3], +a[4], +a[5], +a[6].split('.')[0], +a[6].split('.')[1]));
+		}
+	}
+	return value;
+}
+
+export function getMongoUpdates(currDoc, modifiedDoc, incVersion) {
+	if (currDoc.createdAt) {
+		modifiedDoc.createdAt = currDoc.createdAt;
+	}
+
+	if (currDoc.updatedAt) {
+		modifiedDoc.updatedAt = currDoc.updatedAt;
+	}
+
+	let updates = rusDiff.diff(currDoc, modifiedDoc);
+
+	if (updates) {
+		if (updates.$set && !Object.keys(updates.$set).length) {
+			delete updates.$set;
+		}
+
+		if (incVersion) {
+			updates.$inc = {__v: 1};
+		}
+	}
+	else {
+		if (incVersion) {
+			updates = {
+				$inc: {__v: 1}
+			};
+		}
+	}
+
+	return updates;
+}
+
+export function getMongoMergeUpdatedDoc(f_doc, currentDoc, oldDoc) {
+	let upDoc = deepCopy(oldDoc);
+	upDoc.__v = currentDoc.__v;
+	let diff_1 = getDeepDiff(oldDoc, currentDoc);
+	let diff_2 = getDeepDiff(oldDoc, f_doc);
+	let updates = mergeUpdates(diff_2, diff_1);
+	applyMongoUpdate(upDoc, updates);
+	return upDoc;
+}
+
+export function mergeUpdates(...updatesToMerge) {
+	let merged = {
+		$set: {},
+		$unset: {},
+		$inc: {},
+		$push: {},
+		$pull: {}
+	};
+
+	updatesToMerge.filter(a => a).forEach(anUpdate => {
+		anUpdate.forEach(change => {
+			let path = change.path[0];
+
+			for (let i = 1; i < change.path.length; i++) {
+				path += '.' + change.path[i];
+			}
+
+			if (change.kind === 'E') {
+				if (typeof(change.rhs) === 'number' && path.endsWith('quantity')) {
+					if (merged.$inc[path]) {
+						merged.$inc[path] += change.rhs - change.lhs;
+					}
+					else {
+						merged.$inc[path] = change.rhs - change.lhs;
+					}
+				}
+				else {
+					merged.$set[path] = change.rhs;
+				}
+			}
+			else if (change.kind === 'A') {
+				if (change.item.kind === 'N') {
+					
+					if (!merged.$push[path] || JSON.stringify(merged.$push[path]) !== JSON.stringify(change.item.rhs)) {
+						if (!merged.$push[path]) {
+							merged.$push[path] = [];
+						}
+
+						if (!merged.$push[path].filter(a => JSON.stringify(a) === JSON.stringify(change.item.rhs)).length) {
+							merged.$push[path].push(change.item.rhs);
+						}
+					}
+				}
+				else if (change.item.kind === 'D') {
+					if (!merged.$pull[path] || JSON.stringify(merged.$pull[path]) !== JSON.stringify(change.item.lhs)) {
+						if (!merged.$pull[path]) {
+							merged.$pull[path] = [];
+						}
+
+						if (!merged.$pull[path].filter(a => JSON.stringify(a) === JSON.stringify(change.item.lhs)).length) {
+							merged.$pull[path].push(change.item.lhs);
+						}
+					}
+				}
+				else if (change.item.kind === 'E') {
+					console.log('Condition E not satisfied.');
+					// if (!merged.$pull[path] || JSON.stringify(merged.$pull[path]) !== JSON.stringify(change.item.lhs)) {
+					// 	merged.$pull[path] = change.item.lhs;
+					// }
+				}
+			}
+		});
+	});
+
+	return merged;
+}
+
+export function getDeepDiff(doc1, doc2) {
+	delete doc1._id;
+	delete doc1.__v;
+
+	if (doc1.updatedAt) {
+		delete doc1.updatedAt;
+	}
+
+	if (doc1.createdAt) {
+		delete doc1.createdAt;
+	}
+
+	delete doc2._id;
+	delete doc2.__v;
+
+	if (doc2.updatedAt) {
+		delete doc2.updatedAt;
+	}
+
+	if (doc2.createdAt) {
+		delete doc2.createdAt;
+	}
+
+	return deepDiff(doc1, doc2);
+}
+
+export function applyMongoUpdate(uDoc, delta) {
+	let orig, k, pathk, vk, n, n1, n2, name, o, o1, o2, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, ref9a, ref9b, ref10, ref11, ref12a, ref12b, ref13, v;
+
+	orig = deepCopy(uDoc);
+
+	if (delta != null) {
+		if (delta.$rename != null) {
+			ref = delta.$rename;
+			// tslint:disable-next-line:forin
+			for (k in ref) {
+				v = ref[k];
+				ref1 = resolve(uDoc, k), o1 = ref1[0], n1 = ref1[1];
+				ref2 = resolve(uDoc, v), o2 = ref2[0], n2 = ref2[1];
+				if ((o1 != null) && n1.length === 1) {
+					if ((o2 != null) && n2.length === 1) {
+						o2[n2[0]] = o1[n1[0]];
+						delete o1[n1[0]];
+					}
+					else {
+						// throw new Error(o2 + '/' + n2 + ' - couldn\'t resolve first for ' + uDoc + ' ' + v);
+						console.log('Error', o2 + '/' + n2 + ' - couldn\'t resolve first for ' + uDoc + ' ' + v);
+					}
+				} 
+				else {
+					// throw new Error(o1 + '/' + n1 + ' - couldn\'t resolve second for ' + uDoc + ' ' + k);
+					console.log('Error', o1 + '/' + n1 + ' - couldn\'t resolve second for ' + uDoc + ' ' + k);
+				}
+			}
+		}
+		if (delta.$set != null) {
+			ref3 = delta.$set;
+			// tslint:disable-next-line:forin
+			for (k in ref3) {
+				v = ref3[k];
+				ref4 = resolve(uDoc, k, {
+					force: true
+				}), o = ref4[0], n = ref4[1];
+				if ((o != null) && n.length === 1) {
+					o[n[0]] = v;
+				} 
+				else {
+					// throw new Error(o + '/' + n + ' - couldn\'t set for ' + uDoc + ' ' + k);
+					console.log('Error', o + '/' + n + ' - couldn\'t set for ' + uDoc + ' ' + k);
+				}
+			}
+		}
+		if (delta.$inc != null) {
+			ref5 = delta.$inc;
+			// tslint:disable-next-line:forin
+			for (k in ref5) {
+				v = ref5[k];
+				ref6 = resolve(uDoc, k, {
+				force: true
+				}), o = ref6[0], n = ref6[1];
+				if ((o != null) && n.length === 1) {
+					if (o[name = n[0]] == null) {
+						o[name] = 0;
+					}
+					o[n[0]] += v;
+				} 
+				else {
+					// throw new Error(o + '/' + n + ' - couldn\'t set for ' + uDoc + ' ' + k);
+					console.log('Error', o + '/' + n + ' - couldn\'t set for ' + uDoc + ' ' + k);
+				}
+			}
+		}
+		if (delta.$unset != null) {
+			ref7 = delta.$unset;
+			// tslint:disable-next-line:forin
+			for (k in ref7) {
+				v = ref7[k];
+				ref8 = resolve(uDoc, k), o = ref8[0], n = ref8[1];
+				if ((o != null) && n.length === 1) {
+					delete o[n[0]];
+				} 
+				else {
+					// throw new Error(o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + k);
+					console.log('Error', o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + k);
+				}
+			}
+		}
+		if (delta.$pull != null) {
+			ref9a = delta.$pull;
+			// tslint:disable-next-line:forin
+			for (pathk in ref9a) { // should only loop 1 time
+				ref9b = ref9a[pathk];
+				for (let kk = (ref9b.length - 1); kk >= 0; kk--) {
+					vk = ref9b[kk];
+					
+					ref10 = resolve(uDoc, pathk), o = ref10[0], n = ref10[1];
+					ref11 = resolve(orig, pathk), o2 = ref11[0], n2 = ref11[1];
+					if ((o != null) && n.length === 1) {
+						o[n[0]].splice((<Array<any>>o2[n2[0]]).findIndex(z => JSON.stringify(z) === JSON.stringify(vk)), 1);
+					} 
+					else {
+						// throw new Error(o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + pathk);
+						console.log('Error', o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + pathk);
+					}
+				}
+			}
+		}
+		if (delta.$push != null) {
+			ref12a = delta.$push;
+			// tslint:disable-next-line:forin
+			for (pathk in ref12a) { // should only loop 1 time
+				ref12b = ref12a[pathk];
+				// for (let kk = 0; kk < ref12b.length; kk++) {
+				for (let kk = (ref12b.length - 1); kk >= 0; kk--) {
+						vk = ref12b[kk];
+
+					ref13 = resolve(uDoc, pathk), o = ref13[0], n = ref13[1];
+					if ((o != null) && n.length === 1) {
+						o[n[0]].push(vk);
+					} 
+					else {
+						// throw new Error(o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + pathk);
+						console.log('Error', o + '/' + n + ' - couldn\'t unset for ' + uDoc + ' ' + pathk);
+					}
+				}
+			}
+		}
+	}
+	return uDoc;
+}
+
+function resolve(a, path, options?) {
+	let e, k, last, stack;
+	if (options == null) {
+		options = {};
+	}
+	stack = arrize(path);
+	last = [];
+	if (stack.length > 0) {
+		last.unshift(stack.pop());
+	}
+	e = a;
+	if (e !== null) {
+		while ((k = stack.shift()) !== void 0) {
+			if (e[k] !== void 0) {
+			e = e[k];
+			} else {
+			stack.unshift(k);
+			break;
+			}
+		}
+	}
+	if (options.force) {
+		while ((k = stack.shift()) !== void 0) {
+			if ((typeof stack[0] === 'number') || ((stack.length === 0) && (typeof last[0] === 'number'))) {
+			e[k] = [];
+			} else {
+			e[k] = {};
+			}
+			e = e[k];
+		}
+	} 
+	else {
+		while ((k = stack.pop()) !== void 0) {
+			last.unshift(k);
+		}
+	}
+	return [e, last];
+}
+
+function arrize(path, glue?) {
+	if (glue == null) {
+		glue = '.';
+	}
+	return ((function() {
+		if (Array.isArray(path)) {
+			return path.slice(0);
+		} 
+		else {
+			switch (path) {
+			case void 0:
+			case null:
+			case false:
+			case '':
+				return [];
+			default:
+				return path.toString().split(glue);
+			}
+		}
+	})()).map(function(e) {
+		switch (e) {
+			case void 0:
+			case null:
+			case false:
+			case '':
+			return null;
+			default:
+			return e.toString();
+		}
+	}).filter(function(e) {
+		return e != null;
+	});
+}
+
+
+export function getBinarySize(string) {
+	if (string) {
+		return Buffer.byteLength(string, 'utf8');
+	}
+	else {
+		return 0;
+	}
+}
+
+export function pad(num, size) {
+	let s = num + '';
+	while (s.length < size) { s = '0' + s; }
+	return s;
+}
+
+export function randomString(length, chars) {
+	let result = '';
+	for (let i = length; i > 0; --i) { result += chars[Math.floor(Math.random() * chars.length)]; }
+	return result;
+}
+
+export function toTitleCase(str) {
+	return str.replace(/\w\S*/g, function(txt){
+		return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+	});
+}
+
+export function isObject(item) {
+	return (item && typeof item === 'object' && !Array.isArray(item));
+}
+
+export function mergeDeep(target, ...sources) {
+	if (!sources.length) {
+		return target;
+	}
+	const source = sources.shift();
+
+	if (isObject(target) && isObject(source)) {
+		for (const key in source) {
+			if (isObject(source[key])) {
+				if (!target[key]) {
+					Object.assign(target, { [key]: {} });
+				}
+				mergeDeep(target[key], source[key]);
+			} 
+			else {
+				Object.assign(target, { [key]: source[key] });
+			}
+		}
+	}
+
+	return mergeDeep(target, ...sources);
+}