@rentman/rm-core 1.0.0

package/src/classes/ChangesProcessor.ts

@@ -0,0 +1,475 @@
+import ChangesCompilerFactory from "../factories/ChangesCompilerFactory";
+import ColumnExpansionFactory from "../factories/ColumnExpansionFactory";
+import CreateRequestFactory from "../factories/CreateRequestFactory";
+import RequestColumnExpansionFactory from "../factories/RequestColumnExpansionFactory";
+import ApiRequestServiceInterface from '../interfaces/ApiRequestServiceInterface';
+import ErrorHandlerInterface from '../interfaces/ErrorHandlerInterface';
+import CollectionEntry from "../models/CollectionEntry";
+import ItemEntry from "../models/ItemEntry";
+import ApiFormatter from "./ApiFormatter";
+import ChangesCompiler from "./ChangesCompiler";
+import CollectionEntryService from "./CollectionEntryService";
+import CollectionHandler from "./CollectionHandler";
+import ColumnHandler from "./ColumnHandler";
+import ItemEntryService from "./ItemEntryService";
+import ItemHandler from "./ItemHandler";
+import PromiseService from "./PromiseService";
+import { createPath, getPath, hasProperties, inArray, isFunction } from "./Util";
+
+export default class ChangesProcessor {
+	constructor (
+		private apiRequestService: ApiRequestServiceInterface,
+		private itemHandler: ItemHandler,
+		private errorHandler: ErrorHandlerInterface,
+		private collectionHandler: CollectionHandler,
+		private columnHandler: ColumnHandler,
+		private changesCompilerFactory: ChangesCompilerFactory,
+		private createRequestFactory: CreateRequestFactory,
+		private columnExpansionFactory: ColumnExpansionFactory,
+		private requestColumnExpansionFactory: RequestColumnExpansionFactory,
+		private collectionEntryService: CollectionEntryService,
+		private itemEntryService: ItemEntryService,
+		private apiFormatter: ApiFormatter,
+		private promiseService: PromiseService
+	) {
+	}
+
+	// TODO: we can remove this once the document creation has been updated
+	getItemTypeUpdatePriority (itemType) {
+		switch (itemType) {
+			case 'Factuurregelbedrag':
+				return 0;
+			case 'Factuurregel':
+			case 'Minfactuur':
+				return 1;
+			default:
+				return 2;
+		}
+	}
+
+	buildMoveRequest (compilationEntries) {
+		const result = {};
+
+		for (const compilationEntry of compilationEntries) {
+			const itemEntry = compilationEntry.item;
+			const itemType = itemEntry.itemType;
+
+			if (result[itemType] === undefined)
+				result[itemType] = [];
+
+			result[itemType].push(itemEntry.itemId);
+		}
+
+		return result;
+	}
+
+	getMapValue (itemType, itemId, map) {
+		if (map === undefined)
+			return undefined;
+
+		if (map[itemType] === undefined)
+			return undefined;
+
+		return map[itemType][itemId];
+	}
+
+	execute (singleItems, collections, breakupByParent = false, parameters?, collectionOptions?, onAfterCreateCallback?) {
+		return this.executeRequests(
+			this.changesCompilerFactory.construct(singleItems, collections, collectionOptions),
+			parameters,
+			breakupByParent,
+			onAfterCreateCallback
+		);
+	}
+
+	private executeCreateRequests (compilation, parameters, conversionMap, breakupByParent, onAfterCreateCallback) {
+		const requests = this.createRequestFactory.construct(compilation, parameters, breakupByParent).run();
+		const responses = [];
+
+		for (const request of requests)
+			responses.push(this.executeCreateRequest(request, conversionMap).then(notify));
+
+		return this.promiseService.all(responses).then(
+			() => {
+				return conversionMap;
+			},
+			this.errorHandler.reject
+		);
+
+		function notify (result) {
+			if (isFunction(onAfterCreateCallback))
+				onAfterCreateCallback(conversionMap);
+
+			return result;
+		}
+	}
+
+	private executeCreateRequest (requestResource, conversionMap) {
+		return this.apiRequestService.requestSkeleton(requestResource.request).then(
+			response => {
+				const responseMap = response.map;
+				const responseColumns = response.fetchColumnsObject();
+				const itemEntries = requestResource.items;
+
+				for (const itemType in itemEntries) {
+					const columnExpansion = this.columnExpansionFactory.construct(
+						itemType,
+						requestResource.request.columns[itemType],
+						responseColumns
+					).run;
+
+					for (const itemId in itemEntries[itemType]) {
+						const itemEntry = itemEntries[itemType][itemId];
+						const newItemId = this.getMapValue(itemType, itemId, responseMap);
+
+						if (newItemId === undefined) {
+							console.warn('Create failed!', itemEntry);
+							continue;
+						}
+
+						this.itemHandler.updateItemId(itemEntry, newItemId);
+
+						const fields = response.fetchObject(itemType, newItemId);
+						const expandResource = columnExpansion(itemEntry.columns, true);
+
+						this.itemEntryService.updateFields(itemEntry, fields);
+
+						if (expandResource === null)
+							continue;
+
+						this.itemEntryService.expand(
+							itemEntry,
+							fields,
+							response.fetchDerivedObject(itemType, newItemId, expandResource.difference.root),
+							expandResource
+						);
+					}
+				}
+
+				this.collectionHandler.addToCollections(requestResource.collections, true);
+
+				// extend conversion map
+				for (const itemType in responseMap) {
+					if (conversionMap[itemType] === undefined)
+						conversionMap[itemType] = {};
+
+					for (const itemId in responseMap[itemType])
+						conversionMap[itemType][itemId] = responseMap[itemType][itemId];
+				}
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	private prioritizeUpdateRequests (compilation, parameters) {
+		const prioritizedItemTypes = [[], [], []];
+		let requestChain = this.promiseService.when();
+
+		for (const itemType in compilation)
+			prioritizedItemTypes[this.getItemTypeUpdatePriority(itemType)].push(itemType);
+
+		for (const itemTypes of prioritizedItemTypes) {
+			if (itemTypes.length === 0)
+				continue;
+
+			requestChain = requestChain.then(
+				this.executeUpdateRequests(itemTypes, compilation, parameters),
+				this.errorHandler.reject
+			);
+		}
+
+		return requestChain;
+	}
+
+	// construct a callback function
+	private executeUpdateRequests (itemTypes, compilation, parameters) {
+		return () => {
+			const requests = [];
+
+			for (const itemType of itemTypes) {
+				requests.push(this.executeUpdateRequest(itemType, compilation[itemType], parameters));
+			}
+
+			return this.promiseService.all(requests);
+		};
+	}
+
+	private executeUpdateRequest (itemType, itemEntries, parameterMap) {
+		const request = {};
+		const requestColumns = this.requestColumnExpansionFactory.construct();
+		const collectionMap = {};
+
+		request[itemType] = {};
+
+		// we need to do the formatRequest call here (fields might have been updated)
+		for (const itemId in itemEntries) {
+			const itemEntry = itemEntries[itemId];
+			// RMCore todo: type
+			const itemRequest: any = request[itemType][itemId] = {};
+			const parameters = getPath(parameterMap, [itemType, itemId]);
+
+			itemRequest.values = this.itemEntryService.formatRequest(itemEntry);
+
+			if (parameters !== undefined)
+				itemRequest.parameters = parameters;
+
+			requestColumns.expand(itemEntry.columns);
+			this.collectionHandler.expandCollectionMap(itemEntry, collectionMap);
+		}
+
+		for (const collectionId in collectionMap) {
+			const entry = collectionMap[collectionId];
+
+			if (entry.fitting.length > 0)
+				requestColumns.expand(entry.collection.columns);
+		}
+
+		return this.apiRequestService.updateItems(itemType, request, requestColumns.get()).then(
+			response => {
+				const columnExpansion = this.columnExpansionFactory.construct(
+					itemType,
+					requestColumns.get(),
+					response.fetchColumnsObject()
+				);
+
+				for (const itemId in itemEntries) {
+					const itemEntry = itemEntries[itemId];
+					const fields = response.fetchObject(itemType, itemId);
+
+					if (fields === undefined) {
+						console.warn('Update failed!', itemEntry);
+						continue;
+					}
+
+					const previous = this.apiFormatter.copyFields(itemEntry.initial, {}, itemEntry.columns.main);
+
+					this.itemEntryService.setDerived(
+						itemEntry,
+						response.fetchDerivedObject(itemType, itemId, itemEntry.columns.root)
+					);
+
+					this.itemEntryService.updateFields(itemEntry, fields);
+					this.itemEntryService.callOnChange(itemEntry, previous);
+
+					const expandResource = columnExpansion.run(itemEntry.columns, true);
+
+					if (expandResource === null)
+						continue;
+
+					this.itemEntryService.expand(
+						itemEntry,
+						fields,
+						response.fetchDerivedObject(itemType, itemId, expandResource.difference.root),
+						expandResource
+					);
+				}
+
+				this.collectionHandler.removeFromAndAddToCollections(collectionMap);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	private executeDeleteRequests (compilation) {
+		const requests = [];
+
+		for (const itemType in compilation) // clearing not necessary
+			requests.push(this.executeDeleteRequest(itemType, compilation[itemType]));
+
+		return this.promiseService.all(requests);
+	}
+
+	private executeDeleteRequest (itemType, itemEntries: ItemEntry[]) {
+		const idArray = [];
+
+		for (const itemEntry of itemEntries)
+			idArray.push(itemEntry.itemId);
+
+		return this.apiRequestService.delete(
+			itemType,
+			idArray
+		).then(
+			response => {
+				const responseIdArray = response.items;
+				const collectionMap = {};
+
+				for (const itemEntry of itemEntries) {
+					if (!inArray(itemEntry.itemId, responseIdArray))
+						console.warn('Delete failed!', itemEntry);
+
+					this.collectionHandler.expandCollectionMap(itemEntry, collectionMap);
+				}
+
+				this.collectionHandler.removeFromCollections(collectionMap, true);
+			},
+			this.errorHandler.reject
+		);
+	}
+
+	private executeMoveRequests (compilation, conversionMap) {
+		const self = this;
+		const requests = [];
+
+		for (const parentType in compilation) {
+			for (const parentId in compilation[parentType])
+				executeMoveRequest(parentType, parentId);
+		}
+
+		return this.promiseService.all(requests);
+
+		function executeMoveRequest (parentType, parentId) {
+			// only the parent id could have been updated
+			const compilationEntries = compilation[parentType][parentId];
+			const newParentId = this.getMapValue(parentType, parentId, conversionMap);
+
+			requests.push(
+				self.apiRequestService.moveItems(
+					parentType,
+					newParentId !== undefined ? newParentId : parentId,
+					this.buildMoveRequest(compilationEntries)
+				).then(
+					response => {
+						self.processMoveResponse(response, compilationEntries);
+					},
+					self.errorHandler.reject
+				)
+			);
+		}
+	}
+
+	private processMoveResponse (response, compilationEntries) {
+		// TODO: process response
+
+		const itemEntries = [];
+		const removeCollectionMap = {};
+		const addCollectionMap = {};
+
+		for (const compilationEntry of compilationEntries) {
+			const itemEntry: ItemEntry = compilationEntry.item;
+
+			this.addCollectionMapEntry(
+				removeCollectionMap,
+				compilationEntry.parentId,
+				itemEntry,
+				itemEntry.itemId
+			);
+
+			this.addCollectionMapEntry(
+				addCollectionMap,
+				itemEntry.parent.itemId,
+				itemEntry,
+				itemEntry
+			);
+
+			itemEntries.push(itemEntry);
+		}
+
+		this.forEachCollection(removeCollectionMap, 'removeItems');
+		this.forEachCollection(addCollectionMap, 'addItems');
+	}
+
+	private addCollectionMapEntry (collectionMap, parentId, itemEntry, value) {
+		const collectionMapEntry = createPath(
+			collectionMap,
+			[itemEntry.parent.itemType, parentId, itemEntry.itemType],
+			[{}, {}, []]
+		);
+
+		collectionMapEntry.push(value);
+	}
+
+	private forEachCollection (collectionMap, method) {
+		for (const parentType in collectionMap) {
+			for (const parentId in collectionMap[parentType]) {
+				for (const itemType in collectionMap[parentType][parentId]) {
+					this.collectionHandler.entries.getByParent(parentType, parentId, itemType)[method](
+						collectionMap[parentType][parentId][itemType],
+						null,
+						true
+					);
+				}
+			}
+		}
+	}
+
+	private onItemsCreated (conversionMap, singleItems: ItemEntry[], collections: CollectionEntry[]) {
+		if (!hasProperties(conversionMap))
+			return;
+
+		for (const collectionEntry of collections) {
+			const parent = collectionEntry.parent;
+			const updatedColumns: any = collectionEntry.getUpdatedItemColumns(conversionMap);
+
+			if (parent !== null) {
+				const newParentId = this.getMapValue(parent.itemType, parent.itemId, conversionMap);
+
+				if (newParentId !== undefined)
+					parent.itemId = newParentId;
+
+				collectionEntry.query = this.collectionEntryService.createQuery(collectionEntry.options);
+			}
+
+			if (!hasProperties(updatedColumns))
+				continue;
+
+			if (updatedColumns.id !== undefined)
+				collectionEntry.onItemsCreated(conversionMap[collectionEntry.itemType]);
+
+			// there might be item columns (like subproject) which should be updated
+			collectionEntry.forEach(
+				itemEntry => {
+					this.itemEntryService.updateItemFields(itemEntry, conversionMap);
+				}
+			);
+		}
+
+		for (const itemEntry of singleItems) {
+			const parent = itemEntry.parent;
+
+			this.itemEntryService.updateItemFields(itemEntry, conversionMap);
+
+			if (parent !== undefined) {
+				const newParentId = this.getMapValue(parent.itemType, parent.itemId, conversionMap);
+
+				if (newParentId !== undefined)
+					parent.itemId = newParentId;
+			}
+		}
+	}
+
+	// proper order: create - move - delete - update
+	private executeRequests (changes: ChangesCompiler, parameters, breakupByParent, onAfterCreateCallback) {
+		const compilation = changes.compilation;
+		const singleItems = changes.singleItems;
+		const collections = changes.collections;
+		const conversionMap = {};
+
+		return this.executeCreateRequests(compilation.create, parameters, conversionMap, breakupByParent, onAfterCreateCallback).then(
+			() => {
+				this.onItemsCreated(conversionMap, singleItems, collections);
+
+				return this.executeMoveRequests(compilation.move, conversionMap);
+			},
+			error => {
+				this.onItemsCreated(conversionMap, singleItems, collections);
+
+				return this.errorHandler.reject(error);
+			}
+		).then(
+			() => {
+				return this.executeDeleteRequests(compilation.delete);
+			},
+			this.errorHandler.reject
+		).then(
+			() => {
+				return this.prioritizeUpdateRequests(compilation.update, parameters);
+			},
+			this.errorHandler.reject
+		).then(
+			() => {
+				return conversionMap;
+			}, // item id conversion map
+			this.errorHandler.reject
+		);
+	}
+}

package/src/classes/CollectionCache.ts

@@ -0,0 +1,234 @@
+import QueryMatcherFactory from "../factories/QueryMatcherFactory";
+import CollectionEntry from "../models/CollectionEntry";
+
+enum CONSTANTS {
+	MAYBE = 'maybe'
+}
+
+export default class CollectionCache {
+	entries = {};
+
+	constructor (
+		private queryMatcherFactory: QueryMatcherFactory
+	) {
+
+	}
+
+	contains (collectionEntry) {
+		for (const itemType in this.entries) {
+			for (const entry of this.entries[itemType]) {
+				if (collectionEntry === entry)
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	some (callback) {
+		for (const itemType in this.entries) {
+			for (const entry of this.entries[itemType]) {
+				if (callback(entry))
+					return true;
+			}
+		}
+
+		return false;
+	}
+
+	// TODO: check if this is still in use
+	forEach (callback) {
+		for (const itemType in this.entries) {
+			for (const entry of this.entries[itemType])
+				callback(entry);
+		}
+	}
+
+	toArray () {
+		const result = [];
+
+		for (const itemType in this.entries) {
+			for (const entry of this.entries[itemType])
+				result.push(entry);
+		}
+
+		return result;
+	}
+
+	add (collectionEntry: CollectionEntry) {
+		const itemType = collectionEntry.itemType;
+
+		if (this.entries[itemType] === undefined)
+			this.entries[itemType] = [];
+
+		this.entries[itemType].push(collectionEntry);
+		return collectionEntry;
+	}
+
+	clear (collectionEntry?: CollectionEntry) {
+		if (collectionEntry === undefined) {
+			this.entries = {};
+
+			return true;
+		}
+
+		const itemType = collectionEntry.itemType;
+
+		if (this.entries[itemType] === undefined)
+			return false;
+
+		const index = this.entries[itemType].indexOf(collectionEntry);
+
+		if (index === -1)
+			return false;
+
+		this.entries[itemType].splice(index, 1);
+
+		return true;
+	}
+
+	getByItemType (itemType) {
+		if (this.entries[itemType] === undefined)
+			return [];
+
+		return this.entries[itemType].slice();
+	}
+
+	// TODO: think of better name
+	getByParent (parentType, parentId, itemType) {
+		if (this.entries[itemType] === undefined)
+			return null;
+
+		for (const collectionEntry of this.entries[itemType]) {
+			if (collectionEntry.matchParent(parentType, parentId))
+				return collectionEntry;
+		}
+
+		return null;
+	}
+
+	getResourceByParent (parentType, parentId, itemType) {
+		const collectionEntry = this.getByParent(parentType, parentId, itemType);
+
+		if (collectionEntry === null)
+			return null;
+
+		return collectionEntry.getCurrentResource();
+	}
+
+	getCollectionsByParent (parentType, parentId) {
+		const result = [];
+
+		for (const itemType in this.entries) {
+			for (const collectionEntry of this.entries[itemType]) {
+				if (collectionEntry.matchParent(parentType, parentId))
+					result.push(collectionEntry);
+			}
+		}
+
+		return result;
+	}
+
+	/**
+	 * Only resources
+	 * @param {String} itemType
+	 * @param {String|Integer} itemId
+	 * @returns {Object} Array of collections.
+	 */
+	getByContainingItem (itemType, itemId) {
+		const result = [];
+
+		if (this.entries[itemType] === undefined)
+			return result;
+
+		for (const collectionEntry of this.entries[itemType]) {
+			if (collectionEntry.getItemById(itemId) !== undefined)
+				result.push(collectionEntry);
+		}
+
+		return result;
+	}
+
+	/**
+	 * Returns an array of collections the item 'belongs' in.
+	 * @param {String} parentType
+	 * @param {String} parentId
+	 * @param {String} itemType
+	 * @returns {Object}
+	 */
+	getByFittingItem (parentType, parentId, itemType, fields) {
+		const fittingResult = [];
+		const maybeResult = [];
+		const notFittingResult = [];
+		const result = {fitting: fittingResult, notfitting: notFittingResult, maybe: maybeResult};
+
+		if (this.entries[itemType] === undefined)
+			return result;
+
+		// console.time('getByFittingItem');
+
+		const queryMatcher = this.queryMatcherFactory.construct(parentType, parentId, fields, itemType);
+
+		for (const collectionEntry of this.entries[itemType]) {
+			const matchResult = queryMatcher.matchQuery(collectionEntry.query.object);
+
+			// TODO: maybe?
+			if (matchResult === true) // might also return 'maybe'
+				fittingResult.push(collectionEntry);
+			else if (matchResult === CONSTANTS.MAYBE)
+				maybeResult.push(collectionEntry);
+			else
+				notFittingResult.push(collectionEntry);
+		}
+
+		// console.timeEnd('getByFittingItem');
+
+		return result;
+	}
+
+	getByQuery (itemType, query) {
+		if (this.entries[itemType] === undefined)
+			return null;
+
+		for (const collectionEntry of this.entries[itemType]) {
+			if (collectionEntry.query.string === query.string)
+				return collectionEntry;
+		}
+
+		return null;
+	}
+
+	getByKey (itemType, entryKey) {
+		const result = [];
+
+		if (this.entries[itemType] === undefined)
+			return result;
+
+		for (const entry of this.entries[itemType]) {
+			if (entry.options.entryKey === entryKey)
+				result.push(entry);
+		}
+
+		return result;
+	}
+
+	getResourceByKey (itemType, resourceKey) {
+		const result = [];
+
+		if (this.entries[itemType] === undefined)
+			return result;
+
+		for (const entry of this.entries[itemType]) {
+			for (const resource of entry.resources) {
+				if (resource === null)
+					continue;
+
+				if (resource.options.resourceKey === resourceKey)
+					result.push(resource);
+			}
+
+		}
+
+		return result;
+	}
+}