@rentman/rm-core 1.0.0 → 1.0.2

package/src/classes/ChangesProcessor.ts

@@ -1,475 +0,0 @@
-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

@@ -1,234 +0,0 @@
-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;
-	}
-}