@rentman/rm-core 1.0.0

package/.editorconfig

@@ -0,0 +1,23 @@
+# EditorConfig helps developers define and maintain consistent coding styles between different editors and IDEs
+# editorconfig.org
+
+root = true
+
+[*]
+charset=utf-8
+end_of_line=lf
+indent_style = tab
+indent_size = 4
+
+# We recommend you to keep these unchanged
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.json]
+indent_style = space
+indent_size = 2

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@rentman/rm-core",
+  "version": "1.0.0",
+  "description": "Rentman core functionalities",
+  "main": "./dist/rm-core.js",
+  "typings": "./dist/definitions/index.d.ts",
+  "dependencies": {
+    "q": "^1.5.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rentmanpublic/frontend-core"
+  },
+  "devDependencies": {
+    "@types/moment": "^2.13.0",
+    "@types/q": "^1.5.0",
+    "clean-webpack-plugin": "^0.1.19",
+    "ts-loader": "^4.4.1",
+    "tslint": "^5.10.0",
+    "typescript": "^2.9.2",
+    "uglifyjs-webpack-plugin": "^1.2.5",
+    "webpack": "^4.12.0",
+    "webpack-cli": "^3.0.6",
+    "webpack-merge": "^4.1.3"
+  },
+  "scripts": {
+    "bundle-dev": "webpack --config webpack.dev.js",
+    "bundle": "webpack --config webpack.prod.js",
+    "type-check": "tsc --noEmit"
+  },
+  "author": "Martijn Welker <martijn@rentman.nl>",
+  "license": "UNLICENSED"
+}

package/src/classes/ApiFormatter.ts

@@ -0,0 +1,338 @@
+import * as moment from 'moment';
+import { copy, equals } from './Util';
+
+export default class ApiFormatter {
+	MOMENT_INVALID = 'Invalid date';
+	SERVER_DATETIME_FORMAT = 'YYYY-MM-DD[T]HH:mm:ssZ';
+	SERVER_TIME_FORMAT = 'HH:mm:ss';
+	SERVER_DATE_FORMAT = 'YYYY-MM-DD';
+
+	constructor () {
+
+	}
+
+	formatResponse (fields, columns) {
+		for (const column of columns) {
+			fields[column.path] = this.formatResponseValue(column.apiColumn.type, fields[column.path]);
+		}
+	}
+
+	expandResponse (current, expanded, columns) {
+		for (const column of columns) {
+			current[column.path] = this.formatResponseValue(column.apiColumn.type, expanded[column.path]);
+		}
+	}
+
+	formatRequest (initial, modified, columns) {
+		const result = {};
+
+		for (const column of columns) {
+			const columnId = column.id;
+			const apiColumn = column.apiColumn;
+
+			if (apiColumn.readOnly)
+				continue;
+
+			if (!this.compareFields(apiColumn.type, initial[columnId], modified[columnId]))
+				result[columnId] = this.formatRequestValue(column.apiColumn.type, modified[columnId]);
+		}
+
+		return result;
+	}
+
+	hasChanges (initial, modified, columns) {
+		for (const column of columns) {
+			const columnId = column.id;
+			const apiColumn = column.apiColumn;
+
+			if (apiColumn.readOnly)
+				continue;
+
+			if (!this.compareFields(apiColumn.type, initial[columnId], modified[columnId]))
+				return true;
+		}
+
+		return false;
+	}
+
+	getChanges (initial, modified, columns) {
+		const result = [];
+
+		for (const column of columns) {
+			const columnId = column.id;
+			const apiColumn = column.apiColumn;
+
+			if (apiColumn.readOnly)
+				continue;
+
+			if (!this.compareFields(apiColumn.type, initial[columnId], modified[columnId])) {
+				result.push(
+					{
+						oldValue: initial[columnId],
+						newValue: modified[columnId],
+						column: column.apiColumn
+					}
+				);
+			}
+		}
+
+		return result;
+	}
+
+	copyFields (source, destination, columns) {
+		for (const column of columns) {
+			const columnPath = column.path;
+
+			destination[columnPath] = this.clone(column.apiColumn.type, source[columnPath]);
+		}
+
+		return destination;
+	}
+
+	shallowCopyFields (shallowSource, deepSource, destination, columns) {
+		for (const column of columns) {
+			const columnPath = column.path;
+
+			destination[columnPath] = shallowSource[columnPath] !== undefined ?
+				shallowSource[columnPath] :
+				this.clone(column.apiColumn.type, deepSource[columnPath]);
+		}
+
+		return destination;
+	}
+
+	setDefaultValues (destination, columns) {
+		for (const column of columns) {
+			destination[column.id] = this.getDefaultValue(column.apiColumn.type);
+		}
+
+		return destination;
+	}
+
+	compareFields (columnType, first, second) {
+		if (first === undefined)
+			return second === undefined;
+
+		if (second === undefined)
+			return false;
+
+		switch (columnType) {
+			case 'date':
+			case 'time':
+			case 'datetime':
+				return this.compareMomentObjects(first, second);
+			case 'duration':
+				return this.compareDurations(first, second);
+			case 'id': // id types
+			case 'item':
+			case 'link':
+			case 'child':
+			case 'sibling':
+				return first == second; // use non-strict comparison
+			case 'current':
+			case 'dimension':
+			case 'distance':
+			case 'double': // floating point types
+			case 'filesize':
+			case 'number':
+			case 'power':
+			case 'quantity':
+			case 'volume':
+			case 'weight':
+			case 'coordinate':
+			case 'price':
+			case 'percentage':
+				return this.compareFloats(first, second);
+			case 'int': // integer types
+			case 'bool': // boolean types
+			case 'enum':
+			case 'email': // string types
+			case 'phone':
+			case 'url':
+			case 'text':
+			case 'longtext':
+			case 'color':
+				return first === second;
+			default:
+				return equals(first, second);
+		}
+	}
+
+	compareFloats (a, b) {
+		const absA = Math.abs(a);
+		const absB = Math.abs(b);
+		const diff = Math.abs(a - b);
+
+		const EPSILON = 1.19e-07;
+
+		// shortcut, handles infinities
+		if (a === b) {
+			return true;
+		} else if (a === 0 || b === 0 || diff < Number.MIN_VALUE) {
+			// a or b is zero or both are extremely close to it
+			// relative error is less meaningful here
+			return diff < (EPSILON * Number.MIN_VALUE);
+		} else {
+			// use relative error
+			return diff / Math.min((absA + absB), Number.MAX_VALUE) < EPSILON;
+		}
+	}
+
+	compareMomentObjects (first, second) {
+		if (!first.isValid())
+			return !second.isValid();
+
+		if (!second.isValid())
+			return false; // first IS valid
+
+		return first.isSame(second);
+	}
+
+	compareDurations (first, second) {
+		return first.asMilliseconds() === second.asMilliseconds();
+	}
+
+	formatResponseValue (columnType, value) {
+		switch (columnType) {
+			case 'datetime':
+			case 'date':
+				return this.formatResponseDate(value);
+			case 'color':
+				return this.formatResponseColor(value);
+			case 'duration':
+				return this.formatResponseDuration(value);
+			case 'json':
+				return typeof value === 'string' ? JSON.parse(value) : value;
+			case 'number':
+				return value === 0 ? null : value;
+			case 'filesize':
+				return value / 1000000;
+			default:
+				return value;
+		}
+	}
+
+	formatRequestValue (columnType, value) {
+		switch (columnType) {
+			case 'datetime':
+				return this.formatRequestDateTime(value);
+			case 'date':
+				return this.formatRequestDate(value);
+			case 'color':
+				return this.formatRequestColor(value);
+			case 'duration':
+				return this.formatRequestDuration(value);
+			case 'number':
+				return value === 0 ? null : value;
+			default:
+				return value;
+		}
+	}
+
+	formatResponseDate (value) {
+		return value === null ? moment.invalid() : moment(value);
+	}
+
+	formatResponseDuration (value) {
+		return moment.duration(value === null ? 0 : value, 'seconds');
+	}
+
+	formatResponseColor (value) {
+		return value.charAt(0) === '#' ? value : '#' + value;
+	}
+
+	formatRequestDateTime (value) {
+		return value.isValid() ? value.format(this.SERVER_DATETIME_FORMAT) : null;
+	}
+
+	formatRequestDate (value) {
+		return value.isValid() ? value.format(this.SERVER_DATE_FORMAT) : null;
+	}
+
+	formatRequestDuration (value) {
+		return value.asSeconds();
+	}
+
+	formatRequestColor (value) {
+		return value.charAt(0) === '#' ? value.substring(1) : value;
+	}
+
+	getDefaultValue (columnType) {
+		switch (columnType) {
+			case 'int':
+			case 'double':
+			case 'percentage':
+			case 'price':
+				return 0;
+			case 'item':
+			case 'link':
+			case 'child':
+			case 'sibling':
+				return null;
+			case 'bool':
+				return false;
+			case 'enum':
+				return '0';
+			case 'date':
+			case 'datetime':
+			case 'time':
+				return moment.invalid();
+			case 'duration':
+				return moment.duration();
+			case 'text':
+			case 'longtext':
+				return '';
+			case 'color':
+				return '#000000';
+			default:
+				return '';
+			// 					email
+			// 					url
+			// 					html
+			// 					json
+			// 					data
+		}
+	}
+
+	isDefaultValue (columnType, value) {
+		return this.compareFields(columnType, value, this.getDefaultValue(columnType));
+	}
+
+	clone (columnType, value) {
+		switch (columnType) {
+			case 'duration':
+				return this.cloneDuration(value);
+			case 'date':
+			case 'datetime':
+				return moment(value);
+			case 'json':
+				return copy(value);
+			default:
+				return value;
+		}
+	}
+
+	getCloneFunction (columnType) {
+		switch (columnType) {
+			case 'duration':
+				return this.cloneDuration;
+			case 'date':
+			case 'datetime':
+				return this.cloneDate;
+			default:
+				return this.identity;
+		}
+	}
+
+	cloneDuration (duration) {
+		return moment.duration(duration);
+	}
+
+	cloneDate (date) {
+		return date.clone();
+	}
+
+	identity (input) {
+		return input;
+	}
+}

package/src/classes/BatchStatus.ts

@@ -0,0 +1,86 @@
+import { ENTRY_STATUS } from "../constants";
+import ItemEntry from "../models/ItemEntry";
+import PromiseService from "./PromiseService";
+
+export default class BatchStatus {
+	entries = {};
+
+	constructor (
+		private promiseService: PromiseService,
+		public getItemId: (itemEntry: ItemEntry) => number,
+		public getPromise: (itemEntry: ItemEntry) => Promise<any> // todo: promise return type
+	) {
+		for (const status in ENTRY_STATUS)
+			this.entries[ENTRY_STATUS[status]] = [];
+	}
+
+	add (entryStatus) {
+		const status = entryStatus.status;
+
+		if (this.entries[status] === undefined)
+			this.entries[status] = [];
+
+		this.entries[status].push(entryStatus.entry);
+	}
+
+	hasEntries (statusArray) {
+		for (const status of statusArray) {
+			if (this.entries[status].length > 0)
+				return true;
+		}
+
+		return false;
+	}
+
+	hasRequests () {
+		return this.hasEntries([ENTRY_STATUS.RESOLVE, ENTRY_STATUS.EXPAND, ENTRY_STATUS.PROMISED_EXPAND]);
+	}
+
+	forEachEntry (statusArray: any[], callback) {
+		for (const status of statusArray) {
+			const statusEntries = this.entries[status];
+
+			for (const statusEntry of statusEntries)
+				callback(statusEntry);
+		}
+	}
+
+	getPromises () {
+		const promises = [];
+
+		this.forEachEntry(
+			[ENTRY_STATUS.PROMISED, ENTRY_STATUS.PROMISED_EXPAND],
+			entry => {
+				promises.push(this.getPromise(entry));
+			}
+		);
+
+		return this.promiseService.all(promises);
+	}
+
+	getRequestIds (): number[] {
+		const result = [];
+
+		this.forEachEntry(
+			[ENTRY_STATUS.RESOLVE, ENTRY_STATUS.EXPAND, ENTRY_STATUS.PROMISED_EXPAND],
+			entry => {
+				result.push(this.getItemId(entry));
+			}
+		);
+
+		return result;
+	}
+
+	getArray () {
+		const result = [];
+
+		for (const status in this.entries) {
+			const statusEntries = this.entries[status];
+
+			for (const statusEntry of statusEntries)
+				result.push(statusEntry);
+		}
+
+		return result;
+	}
+}

package/src/classes/ChangesCompiler.ts

@@ -0,0 +1,161 @@
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+import ItemEntryService from "./ItemEntryService";
+import { createPath } from "./Util";
+
+export default class ChangesCompiler {
+	compilation = {
+		create: {},
+		delete: {},
+		update: {},
+		move: {}
+	};
+
+	private moveArray: ItemEntry[] = [];
+	private deleteMap = {};
+
+	constructor (
+		private itemEntryService: ItemEntryService,
+		public singleItems: ItemEntry[],
+		public collections: CollectionEntry[],
+		private collectionOptions
+	) {
+		this.processSingleItems();
+		this.processCollections();
+		this.postProcess();
+	}
+
+	getParent (itemEntry: ItemEntry) {
+		return itemEntry.parent !== undefined ?
+			itemEntry.parent :
+			{itemType: 'Void', itemId: 0};
+	}
+
+	addMoveEntry (itemEntry) {
+		this.moveArray.push(itemEntry);
+	}
+
+	addDeleteEntry (itemEntry, parentId, parentType) {
+		createPath(
+			this.deleteMap,
+			[itemEntry.itemType, itemEntry.itemId],
+			[{}, {parentId: parentId, item: itemEntry, parentType: parentType}]
+		);
+	}
+
+	addUpdateEntry (itemEntry) {
+		createPath(
+			this.compilation.update,
+			[itemEntry.itemType, itemEntry.itemId],
+			[{}, itemEntry]
+		);
+	}
+
+	addCreateEntry (itemEntry) {
+		const parent = this.getParent(itemEntry);
+
+		createPath(
+			this.compilation.create,
+			[parent.itemType, parent.itemId, itemEntry.itemType, itemEntry.itemId],
+			[{}, {}, {}, itemEntry]
+		);
+	}
+
+	postProcess () {
+		for (const itemEntry of this.moveArray) {
+			const itemId = itemEntry.itemId;
+			const deleteEntry = this.deleteMap[itemEntry.itemType];
+
+			if (deleteEntry === undefined || deleteEntry[itemId] === undefined)
+				continue;
+
+			// assume the itemEntry has a parent (or something went seriously wrong)
+			const parent = itemEntry.parent;
+			const destination = createPath(
+				this.compilation.move,
+				[parent.itemType, parent.itemId],
+				[{}, []]
+			);
+
+			destination.push(deleteEntry[itemId]);
+
+			delete deleteEntry[itemId];
+		}
+
+		for (const itemType in this.deleteMap) {
+			for (const itemId in this.deleteMap[itemType]) {
+				const itemEntry: ItemEntry = this.deleteMap[itemType][itemId].item;
+				const destination = this.compilation.delete;
+
+				if (destination[itemType] === undefined)
+					destination[itemType] = [];
+
+				destination[itemType].push(itemEntry);
+			}
+		}
+	}
+
+	private processSingleItems () {
+		for (const itemEntry of this.singleItems) {
+			if (this.itemEntryService.isLocal(itemEntry))
+				this.addCreateEntry(itemEntry);
+			else if (this.itemEntryService.hasChanges(itemEntry))
+				this.addUpdateEntry(itemEntry);
+		}
+	}
+
+	private isEditableCollection (collectionEntry) {
+		if (this.collectionOptions === undefined)
+			return true;
+
+		return this.collectionOptions[collectionEntry.id].edit;
+	}
+
+	private hasEditableItems (collectionEntry) {
+		if (this.collectionOptions === undefined)
+			return true;
+
+		return this.collectionOptions[collectionEntry.id].editItems;
+	}
+
+	private processCollections () {
+		for (const collectionEntry of this.collections) {
+			if (collectionEntry.isDeferred())
+				continue;
+
+			// add the collection parent id to the delete entry (in case the item has been moved)
+			const parent = collectionEntry.parent;
+			const parentId = parent !== null ? parent.itemId : 0;
+
+			if (this.isEditableCollection(collectionEntry)) {
+				let addedItems;
+				let removedItems;
+
+				if (collectionEntry.isLocal()) {
+					addedItems = collectionEntry.items;
+					removedItems = [];
+				} else {
+					addedItems = collectionEntry.getAddedItems();
+					removedItems = collectionEntry.getRemovedItems();
+				}
+
+				for (const addedItem of addedItems) {
+					if (this.itemEntryService.isLocal(addedItem))
+						this.addCreateEntry(addedItem);
+					else
+						this.addMoveEntry(addedItem);
+				}
+
+				for (const removedItem of removedItems)
+					this.addDeleteEntry(removedItem, parentId, parent.itemType);
+			}
+
+			if (this.hasEditableItems(collectionEntry)) {
+				const updatedItems = collectionEntry.getUpdatedItems();
+
+				for (const updatedItem of updatedItems)
+					this.addUpdateEntry(updatedItem);
+			}
+		}
+	}
+}